diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bb6bc325a3bb..8963039dd50b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -289,7 +289,7 @@ jobs:
           fi
 
           # Get closest bors merge commit
-          PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+          PARENT_COMMIT=`git rev-list --author='122020455+rust-bors\[bot\]@users.noreply.github.com' -n1 --first-parent HEAD^1`
 
           ./build/citool/debug/citool postprocess-metrics \
               --job-name ${CI_JOB_NAME} \
diff --git a/.github/workflows/post-merge.yml b/.github/workflows/post-merge.yml
index d38cc0e8a17f..51e0a40d46f2 100644
--- a/.github/workflows/post-merge.yml
+++ b/.github/workflows/post-merge.yml
@@ -29,7 +29,7 @@ jobs:
           sleep 60
 
           # Get closest bors merge commit
-          PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+          PARENT_COMMIT=`git rev-list --author='122020455+rust-bors\[bot\]@users.noreply.github.com' -n1 --first-parent HEAD^1`
           echo "Parent: ${PARENT_COMMIT}"
 
           # Find PR for the current commit
diff --git a/Cargo.lock b/Cargo.lock
index d3637d1f4b3e..9c791babc399 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -182,19 +182,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
-[[package]]
-name = "askama"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f75363874b771be265f4ffe307ca705ef6f3baa19011c149da8674a87f1b75c4"
-dependencies = [
- "askama_derive 0.14.0",
- "itoa",
- "percent-encoding",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "askama"
 version = "0.15.1"
@@ -208,30 +195,13 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "askama_derive"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "129397200fe83088e8a68407a8e2b1f826cf0086b21ccdb866a722c8bcd3a94f"
-dependencies = [
- "askama_parser 0.14.0",
- "basic-toml",
- "memchr",
- "proc-macro2",
- "quote",
- "rustc-hash 2.1.1",
- "serde",
- "serde_derive",
- "syn 2.0.110",
-]
-
 [[package]]
 name = "askama_derive"
 version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ba5e7259a1580c61571e3116ebaaa01e3c001b2132b17c4cc5c70780ca3e994"
 dependencies = [
- "askama_parser 0.15.1",
+ "askama_parser",
  "basic-toml",
  "memchr",
  "proc-macro2",
@@ -248,19 +218,7 @@ version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "236ce20b77cb13506eaf5024899f4af6e12e8825f390bd943c4c37fd8f322e46"
 dependencies = [
- "askama_derive 0.15.1",
-]
-
-[[package]]
-name = "askama_parser"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6ab5630b3d5eaf232620167977f95eb51f3432fc76852328774afbd242d4358"
-dependencies = [
- "memchr",
- "serde",
- "serde_derive",
- "winnow 0.7.13",
+ "askama_derive",
 ]
 
 [[package]]
@@ -445,22 +403,21 @@ dependencies = [
 
 [[package]]
 name = "capstone"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "015ef5d5ca1743e3f94af9509ba6bd2886523cfee46e48d15c2ef5216fd4ac9a"
+checksum = "f442ae0f2f3f1b923334b4a5386c95c69c1cfa072bafa23d6fae6d9682eb1dd4"
 dependencies = [
  "capstone-sys",
- "libc",
+ "static_assertions",
 ]
 
 [[package]]
 name = "capstone-sys"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2267cb8d16a1e4197863ec4284ffd1aec26fe7e57c58af46b02590a0235809a0"
+checksum = "a4e8087cab6731295f5a2a2bd82989ba4f41d3a428aab2e7c98d8f4db38aac05"
 dependencies = [
  "cc",
- "libc",
 ]
 
 [[package]]
@@ -676,7 +633,7 @@ name = "clippy"
 version = "0.1.94"
 dependencies = [
  "anstream",
- "askama 0.14.0",
+ "askama",
  "cargo_metadata 0.18.1",
  "clippy_config",
  "clippy_lints",
@@ -1567,7 +1524,7 @@ name = "generate-copyright"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "askama 0.15.1",
+ "askama",
  "cargo_metadata 0.21.0",
  "serde",
  "serde_json",
@@ -2232,9 +2189,9 @@ dependencies = [
 
 [[package]]
 name = "libffi"
-version = "5.0.0"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0444124f3ffd67e1b0b0c661a7f81a278a135eb54aaad4078e79fbc8be50c8a5"
+checksum = "0498fe5655f857803e156523e644dcdcdc3b3c7edda42ea2afdae2e09b2db87b"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -2242,9 +2199,9 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "4.0.0"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d722da8817ea580d0669da6babe2262d7b86a1af1103da24102b8bb9c101ce7"
+checksum = "71d4f1d4ce15091955144350b75db16a96d4a63728500122706fb4d29a26afbb"
 dependencies = [
  "cc",
 ]
@@ -3413,9 +3370,9 @@ checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.5"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+checksum = "8be87abb9e40db7466e0681dc8ecd9dcfd40360cb10b4c8fe24a7c4c3669b198"
 
 [[package]]
 name = "rustc-main"
@@ -4422,6 +4379,7 @@ dependencies = [
  "rustc_errors",
  "rustc_fluent_macro",
  "rustc_hir",
+ "rustc_index",
  "rustc_macros",
  "rustc_middle",
  "rustc_session",
@@ -4913,7 +4871,7 @@ name = "rustdoc"
 version = "0.0.0"
 dependencies = [
  "arrayvec",
- "askama 0.15.1",
+ "askama",
  "base64",
  "expect-test",
  "indexmap",
@@ -5659,6 +5617,7 @@ dependencies = [
  "build_helper",
  "cargo_metadata 0.21.0",
  "fluent-syntax",
+ "globset",
  "ignore",
  "miropt-test-tools",
  "regex",
@@ -6222,9 +6181,9 @@ dependencies = [
 
 [[package]]
 name = "wasi-preview1-component-adapter-provider"
-version = "38.0.4"
+version = "40.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ec3ef3783e18f2457796ed91b1e6c2adc46f2905f740d1527ab3053fe8e5682"
+checksum = "bb5e2b9858989c3a257de4ca169977f4f79897b64e4f482f188f4fcf8ac557d1"
 
 [[package]]
 name = "wasm-bindgen"
@@ -6273,17 +6232,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-component-ld"
-version = "0.5.19"
+version = "0.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bfc50dd0b883d841bc1dba5ff7020ca52fa7b2c3bb1266d8bf6a09dd032e115"
+checksum = "846d20ed66ae37b7a237e36dfcd2fdc979eae82a46cdb0586f9bba80782fd789"
 dependencies = [
  "anyhow",
  "clap",
+ "clap_lex",
  "lexopt",
  "libc",
  "tempfile",
  "wasi-preview1-component-adapter-provider",
- "wasmparser 0.241.2",
+ "wasmparser 0.243.0",
  "wat",
  "windows-sys 0.61.2",
  "winsplit",
@@ -6310,24 +6270,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.241.2"
+version = "0.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e01164c9dda68301e34fdae536c23ed6fe90ce6d97213ccc171eebbd3d02d6b8"
+checksum = "c55db9c896d70bd9fa535ce83cd4e1f2ec3726b0edd2142079f594fc3be1cb35"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.241.2",
+ "wasmparser 0.243.0",
 ]
 
 [[package]]
 name = "wasm-metadata"
-version = "0.241.2"
+version = "0.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "876fe286f2fa416386deedebe8407e6f19e0b5aeaef3d03161e77a15fa80f167"
+checksum = "eae05bf9579f45a62e8d0a4e3f52eaa8da518883ac5afa482ec8256c329ecd56"
 dependencies = [
  "anyhow",
  "indexmap",
- "wasm-encoder 0.241.2",
- "wasmparser 0.241.2",
+ "wasm-encoder 0.243.0",
+ "wasmparser 0.243.0",
 ]
 
 [[package]]
@@ -6352,9 +6312,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.241.2"
+version = "0.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46d90019b1afd4b808c263e428de644f3003691f243387d30d673211ee0cb8e8"
+checksum = "f6d8db401b0528ec316dfbe579e6ab4152d61739cfe076706d2009127970159d"
 dependencies = [
  "bitflags",
  "hashbrown 0.15.5",
@@ -6365,22 +6325,22 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "241.0.2"
+version = "243.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63f66e07e2ddf531fef6344dbf94d112df7c2f23ed6ffb10962e711500b8d816"
+checksum = "df21d01c2d91e46cb7a221d79e58a2d210ea02020d57c092e79255cc2999ca7f"
 dependencies = [
  "bumpalo",
  "leb128fmt",
  "memchr",
  "unicode-width 0.2.2",
- "wasm-encoder 0.241.2",
+ "wasm-encoder 0.243.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.241.2"
+version = "1.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45f923705c40830af909c5dec2352ec2821202e4a66008194585e1917458a26d"
+checksum = "226a9a91cd80a50449312fef0c75c23478fcecfcc4092bdebe1dc8e760ef521b"
 dependencies = [
  "wast",
 ]
@@ -6776,9 +6736,9 @@ dependencies = [
 
 [[package]]
 name = "wit-component"
-version = "0.241.2"
+version = "0.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0c57df25e7ee612d946d3b7646c1ddb2310f8280aa2c17e543b66e0812241"
+checksum = "36f9fc53513e461ce51dcf17a3e331752cb829f1d187069e54af5608fc998fe4"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -6787,17 +6747,17 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "wasm-encoder 0.241.2",
+ "wasm-encoder 0.243.0",
  "wasm-metadata",
- "wasmparser 0.241.2",
+ "wasmparser 0.243.0",
  "wit-parser",
 ]
 
 [[package]]
 name = "wit-parser"
-version = "0.241.2"
+version = "0.243.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ef1c6ad67f35c831abd4039c02894de97034100899614d1c44e2268ad01c91"
+checksum = "df983a8608e513d8997f435bb74207bf0933d0e49ca97aa9d8a6157164b9b7fc"
 dependencies = [
  "anyhow",
  "id-arena",
@@ -6808,7 +6768,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser 0.241.2",
+ "wasmparser 0.243.0",
 ]
 
 [[package]]
diff --git a/compiler/rustc_abi/src/extern_abi.rs b/compiler/rustc_abi/src/extern_abi.rs
index 6a5ea36f2a42..e44dea1ce593 100644
--- a/compiler/rustc_abi/src/extern_abi.rs
+++ b/compiler/rustc_abi/src/extern_abi.rs
@@ -67,7 +67,6 @@ pub enum ExternAbi {
 
     /* gpu */
     /// An entry-point function called by the GPU's host
-    // FIXME: should not be callable from Rust on GPU targets, is for host's use only
     GpuKernel,
     /// An entry-point function called by the GPU's host
     // FIXME: why do we have two of these?
diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index a0350dd6ff31..5e81ec28ee35 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -618,7 +618,7 @@ impl DroplessArena {
 /// - Types that are `!Copy` and `Drop`: these must be specified in the
 ///   arguments. The `TypedArena` will be used for them.
 ///
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
     #[derive(Default)]
     pub struct Arena<'tcx> {
diff --git a/compiler/rustc_ast/Cargo.toml b/compiler/rustc_ast/Cargo.toml
index 34d90adf5cb3..471a6bf1df13 100644
--- a/compiler/rustc_ast/Cargo.toml
+++ b/compiler/rustc_ast/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2024"
 # tidy-alphabetical-start
 bitflags = "2.4.1"
 memchr = "2.7.6"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_ast_ir = { path = "../rustc_ast_ir" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 7c922417ee29..fb2ccefe12a1 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -34,6 +34,7 @@ use rustc_span::source_map::{Spanned, respan};
 use rustc_span::{ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
+use crate::attr::data_structures::CfgEntry;
 pub use crate::format::*;
 use crate::token::{self, CommentKind, Delimiter};
 use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
@@ -2116,10 +2117,9 @@ pub struct MacroDef {
 
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub struct EiiExternTarget {
-    /// path to the extern item we're targetting
+    /// path to the extern item we're targeting
     pub extern_item_path: Path,
     pub impl_unsafe: bool,
-    pub span: Span,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]
@@ -3390,7 +3390,7 @@ impl NormalAttr {
             item: AttrItem {
                 unsafety: Safety::Default,
                 path: Path::from_ident(ident),
-                args: AttrArgs::Empty,
+                args: AttrItemKind::Unparsed(AttrArgs::Empty),
                 tokens: None,
             },
             tokens: None,
@@ -3402,11 +3402,53 @@ impl NormalAttr {
 pub struct AttrItem {
     pub unsafety: Safety,
     pub path: Path,
-    pub args: AttrArgs,
+    pub args: AttrItemKind,
     // Tokens for the meta item, e.g. just the `foo` within `#[foo]` or `#![foo]`.
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
+/// Some attributes are stored in a parsed form, for performance reasons.
+/// Their arguments don't have to be reparsed everytime they're used
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum AttrItemKind {
+    Parsed(EarlyParsedAttribute),
+    Unparsed(AttrArgs),
+}
+
+impl AttrItemKind {
+    pub fn unparsed(self) -> Option<AttrArgs> {
+        match self {
+            AttrItemKind::Unparsed(args) => Some(args),
+            AttrItemKind::Parsed(_) => None,
+        }
+    }
+
+    pub fn unparsed_ref(&self) -> Option<&AttrArgs> {
+        match self {
+            AttrItemKind::Unparsed(args) => Some(args),
+            AttrItemKind::Parsed(_) => None,
+        }
+    }
+
+    pub fn span(&self) -> Option<Span> {
+        match self {
+            AttrItemKind::Unparsed(args) => args.span(),
+            AttrItemKind::Parsed(_) => None,
+        }
+    }
+}
+
+/// Some attributes are stored in parsed form in the AST.
+/// This is done for performance reasons, so the attributes don't need to be reparsed on every use.
+///
+/// Currently all early parsed attributes are excluded from pretty printing at rustc_ast_pretty::pprust::state::print_attribute_inline.
+/// When adding new early parsed attributes, consider whether they should be pretty printed.
+#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum EarlyParsedAttribute {
+    CfgTrace(CfgEntry),
+    CfgAttrTrace,
+}
+
 impl AttrItem {
     pub fn is_valid_for_outer_style(&self) -> bool {
         self.path == sym::cfg_attr
@@ -3770,6 +3812,19 @@ pub struct Fn {
 pub struct EiiImpl {
     pub node_id: NodeId,
     pub eii_macro_path: Path,
+    /// This field is an implementation detail that prevents a lot of bugs.
+    /// See <https://github.com/rust-lang/rust/issues/149981> for an example.
+    ///
+    /// The problem is, that if we generate a declaration *together* with its default,
+    /// we generate both a declaration and an implementation. The generated implementation
+    /// uses the same mechanism to register itself as a user-defined implementation would,
+    /// despite being invisible to users. What does happen is a name resolution step.
+    /// The invisible default implementation has to find the declaration.
+    /// Both are generated at the same time, so we can skip that name resolution step.
+    ///
+    /// This field is that shortcut: we prefill the extern target to skip a name resolution step,
+    /// making sure it never fails. It'd be awful UX if we fail name resolution in code invisible to the user.
+    pub known_eii_macro_resolution: Option<EiiExternTarget>,
     pub impl_safety: Safety,
     pub span: Span,
     pub inner_span: Span,
diff --git a/compiler/rustc_ast/src/attr/data_structures.rs b/compiler/rustc_ast/src/attr/data_structures.rs
new file mode 100644
index 000000000000..2eab91801cd6
--- /dev/null
+++ b/compiler/rustc_ast/src/attr/data_structures.rs
@@ -0,0 +1,101 @@
+use std::fmt;
+
+use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_span::{Span, Symbol};
+use thin_vec::ThinVec;
+
+use crate::attr::version::RustcVersion;
+
+#[derive(Encodable, Decodable, Clone, Debug, PartialEq, Eq, Hash, HashStable_Generic)]
+pub enum CfgEntry {
+    All(ThinVec<CfgEntry>, Span),
+    Any(ThinVec<CfgEntry>, Span),
+    Not(Box<CfgEntry>, Span),
+    Bool(bool, Span),
+    NameValue { name: Symbol, value: Option<Symbol>, span: Span },
+    Version(Option<RustcVersion>, Span),
+}
+
+impl CfgEntry {
+    pub fn lower_spans(&mut self, lower_span: impl Copy + Fn(Span) -> Span) {
+        match self {
+            CfgEntry::All(subs, span) | CfgEntry::Any(subs, span) => {
+                *span = lower_span(*span);
+                subs.iter_mut().for_each(|sub| sub.lower_spans(lower_span));
+            }
+            CfgEntry::Not(sub, span) => {
+                *span = lower_span(*span);
+                sub.lower_spans(lower_span);
+            }
+            CfgEntry::Bool(_, span)
+            | CfgEntry::NameValue { span, .. }
+            | CfgEntry::Version(_, span) => {
+                *span = lower_span(*span);
+            }
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        let (Self::All(_, span)
+        | Self::Any(_, span)
+        | Self::Not(_, span)
+        | Self::Bool(_, span)
+        | Self::NameValue { span, .. }
+        | Self::Version(_, span)) = self;
+        *span
+    }
+
+    /// Same as `PartialEq` but doesn't check spans and ignore order of cfgs.
+    pub fn is_equivalent_to(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::All(a, _), Self::All(b, _)) | (Self::Any(a, _), Self::Any(b, _)) => {
+                a.len() == b.len() && a.iter().all(|a| b.iter().any(|b| a.is_equivalent_to(b)))
+            }
+            (Self::Not(a, _), Self::Not(b, _)) => a.is_equivalent_to(b),
+            (Self::Bool(a, _), Self::Bool(b, _)) => a == b,
+            (
+                Self::NameValue { name: name1, value: value1, .. },
+                Self::NameValue { name: name2, value: value2, .. },
+            ) => name1 == name2 && value1 == value2,
+            (Self::Version(a, _), Self::Version(b, _)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl fmt::Display for CfgEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn write_entries(
+            name: &str,
+            entries: &[CfgEntry],
+            f: &mut fmt::Formatter<'_>,
+        ) -> fmt::Result {
+            write!(f, "{name}(")?;
+            for (nb, entry) in entries.iter().enumerate() {
+                if nb != 0 {
+                    f.write_str(", ")?;
+                }
+                entry.fmt(f)?;
+            }
+            f.write_str(")")
+        }
+        match self {
+            Self::All(entries, _) => write_entries("all", entries, f),
+            Self::Any(entries, _) => write_entries("any", entries, f),
+            Self::Not(entry, _) => write!(f, "not({entry})"),
+            Self::Bool(value, _) => write!(f, "{value}"),
+            Self::NameValue { name, value, .. } => {
+                match value {
+                    // We use `as_str` and debug display to have characters escaped and `"`
+                    // characters surrounding the string.
+                    Some(value) => write!(f, "{name} = {:?}", value.as_str()),
+                    None => write!(f, "{name}"),
+                }
+            }
+            Self::Version(version, _) => match version {
+                Some(version) => write!(f, "{version}"),
+                None => Ok(()),
+            },
+        }
+    }
+}
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index c53188a22aed..0a2a34d932f6 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -1,5 +1,8 @@
 //! Functions dealing with attributes and meta items.
 
+pub mod data_structures;
+pub mod version;
+
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicU32, Ordering};
 
@@ -8,6 +11,7 @@ use rustc_span::{Ident, Span, Symbol, sym};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::{ThinVec, thin_vec};
 
+use crate::AttrItemKind;
 use crate::ast::{
     AttrArgs, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, DUMMY_NODE_ID, DelimArgs,
     Expr, ExprKind, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NormalAttr, Path,
@@ -62,6 +66,15 @@ impl Attribute {
         }
     }
 
+    /// Replaces the arguments of this attribute with new arguments `AttrItemKind`.
+    /// This is useful for making this attribute into a trace attribute, and should otherwise be avoided.
+    pub fn replace_args(&mut self, new_args: AttrItemKind) {
+        match &mut self.kind {
+            AttrKind::Normal(normal) => normal.item.args = new_args,
+            AttrKind::DocComment(..) => panic!("unexpected doc comment"),
+        }
+    }
+
     pub fn unwrap_normal_item(self) -> AttrItem {
         match self.kind {
             AttrKind::Normal(normal) => normal.item,
@@ -77,7 +90,7 @@ impl AttributeExt for Attribute {
 
     fn value_span(&self) -> Option<Span> {
         match &self.kind {
-            AttrKind::Normal(normal) => match &normal.item.args {
+            AttrKind::Normal(normal) => match &normal.item.args.unparsed_ref()? {
                 AttrArgs::Eq { expr, .. } => Some(expr.span),
                 _ => None,
             },
@@ -96,11 +109,11 @@ impl AttributeExt for Attribute {
     }
 
     /// For a single-segment attribute, returns its name; otherwise, returns `None`.
-    fn ident(&self) -> Option<Ident> {
+    fn name(&self) -> Option<Symbol> {
         match &self.kind {
             AttrKind::Normal(normal) => {
                 if let [ident] = &*normal.item.path.segments {
-                    Some(ident.ident)
+                    Some(ident.ident.name)
                 } else {
                     None
                 }
@@ -109,9 +122,18 @@ impl AttributeExt for Attribute {
         }
     }
 
-    fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
+    fn symbol_path(&self) -> Option<SmallVec<[Symbol; 1]>> {
         match &self.kind {
-            AttrKind::Normal(p) => Some(p.item.path.segments.iter().map(|i| i.ident).collect()),
+            AttrKind::Normal(p) => {
+                Some(p.item.path.segments.iter().map(|i| i.ident.name).collect())
+            }
+            AttrKind::DocComment(_, _) => None,
+        }
+    }
+
+    fn path_span(&self) -> Option<Span> {
+        match &self.kind {
+            AttrKind::Normal(attr) => Some(attr.item.path.span),
             AttrKind::DocComment(_, _) => None,
         }
     }
@@ -138,7 +160,7 @@ impl AttributeExt for Attribute {
 
     fn is_word(&self) -> bool {
         if let AttrKind::Normal(normal) = &self.kind {
-            matches!(normal.item.args, AttrArgs::Empty)
+            matches!(normal.item.args, AttrItemKind::Unparsed(AttrArgs::Empty))
         } else {
             false
         }
@@ -213,6 +235,34 @@ impl AttributeExt for Attribute {
         }
     }
 
+    fn deprecation_note(&self) -> Option<Symbol> {
+        match &self.kind {
+            AttrKind::Normal(normal) if normal.item.path == sym::deprecated => {
+                let meta = &normal.item;
+
+                // #[deprecated = "..."]
+                if let Some(s) = meta.value_str() {
+                    return Some(s);
+                }
+
+                // #[deprecated(note = "...")]
+                if let Some(list) = meta.meta_item_list() {
+                    for nested in list {
+                        if let Some(mi) = nested.meta_item()
+                            && mi.path == sym::note
+                            && let Some(s) = mi.value_str()
+                        {
+                            return Some(s);
+                        }
+                    }
+                }
+
+                None
+            }
+            _ => None,
+        }
+    }
+
     fn doc_resolution_scope(&self) -> Option<AttrStyle> {
         match &self.kind {
             AttrKind::DocComment(..) => Some(self.style),
@@ -255,6 +305,7 @@ impl Attribute {
 
     pub fn may_have_doc_links(&self) -> bool {
         self.doc_str().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
+            || self.deprecation_note().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
     }
 
     /// Extracts the MetaItem from inside this Attribute.
@@ -294,7 +345,7 @@ impl AttrItem {
     }
 
     pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
-        match &self.args {
+        match &self.args.unparsed_ref()? {
             AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
                 MetaItemKind::list_from_tokens(args.tokens.clone())
             }
@@ -315,7 +366,7 @@ impl AttrItem {
     /// #[attr("value")]
     /// ```
     fn value_str(&self) -> Option<Symbol> {
-        match &self.args {
+        match &self.args.unparsed_ref()? {
             AttrArgs::Eq { expr, .. } => match expr.kind {
                 ExprKind::Lit(token_lit) => {
                     LitKind::from_token_lit(token_lit).ok().and_then(|lit| lit.str())
@@ -339,7 +390,7 @@ impl AttrItem {
     /// #[attr("value")]
     /// ```
     fn value_span(&self) -> Option<Span> {
-        match &self.args {
+        match &self.args.unparsed_ref()? {
             AttrArgs::Eq { expr, .. } => Some(expr.span),
             AttrArgs::Delimited(_) | AttrArgs::Empty => None,
         }
@@ -355,7 +406,7 @@ impl AttrItem {
     }
 
     pub fn meta_kind(&self) -> Option<MetaItemKind> {
-        MetaItemKind::from_attr_args(&self.args)
+        MetaItemKind::from_attr_args(self.args.unparsed_ref()?)
     }
 }
 
@@ -690,7 +741,13 @@ fn mk_attr(
     args: AttrArgs,
     span: Span,
 ) -> Attribute {
-    mk_attr_from_item(g, AttrItem { unsafety, path, args, tokens: None }, None, style, span)
+    mk_attr_from_item(
+        g,
+        AttrItem { unsafety, path, args: AttrItemKind::Unparsed(args), tokens: None },
+        None,
+        style,
+        span,
+    )
 }
 
 pub fn mk_attr_from_item(
@@ -794,9 +851,7 @@ pub trait AttributeExt: Debug {
 
     /// For a single-segment attribute (i.e., `#[attr]` and not `#[path::atrr]`),
     /// return the name of the attribute; otherwise, returns `None`.
-    fn name(&self) -> Option<Symbol> {
-        self.ident().map(|ident| ident.name)
-    }
+    fn name(&self) -> Option<Symbol>;
 
     /// Get the meta item list, `#[attr(meta item list)]`
     fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>>;
@@ -807,9 +862,6 @@ pub trait AttributeExt: Debug {
     /// Gets the span of the value literal, as string, when using `#[attr = value]`
     fn value_span(&self) -> Option<Span>;
 
-    /// For a single-segment attribute, returns its ident; otherwise, returns `None`.
-    fn ident(&self) -> Option<Ident>;
-
     /// Checks whether the path of this attribute matches the name.
     ///
     /// Matches one segment of the path to each element in `name`
@@ -822,7 +874,7 @@ pub trait AttributeExt: Debug {
 
     #[inline]
     fn has_name(&self, name: Symbol) -> bool {
-        self.ident().map(|x| x.name == name).unwrap_or(false)
+        self.name().map(|x| x == name).unwrap_or(false)
     }
 
     #[inline]
@@ -836,13 +888,13 @@ pub trait AttributeExt: Debug {
     fn is_word(&self) -> bool;
 
     fn path(&self) -> SmallVec<[Symbol; 1]> {
-        self.ident_path()
-            .map(|i| i.into_iter().map(|i| i.name).collect())
-            .unwrap_or(smallvec![sym::doc])
+        self.symbol_path().unwrap_or(smallvec![sym::doc])
     }
 
+    fn path_span(&self) -> Option<Span>;
+
     /// Returns None for doc comments
-    fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>>;
+    fn symbol_path(&self) -> Option<SmallVec<[Symbol; 1]>>;
 
     /// Returns the documentation if this is a doc comment or a sugared doc comment.
     /// * `///doc` returns `Some("doc")`.
@@ -850,6 +902,11 @@ pub trait AttributeExt: Debug {
     /// * `#[doc(...)]` returns `None`.
     fn doc_str(&self) -> Option<Symbol>;
 
+    /// Returns the deprecation note if this is deprecation attribute.
+    /// * `#[deprecated = "note"]` returns `Some("note")`.
+    /// * `#[deprecated(note = "note", ...)]` returns `Some("note")`.
+    fn deprecation_note(&self) -> Option<Symbol>;
+
     fn is_proc_macro_attr(&self) -> bool {
         [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
             .iter()
@@ -903,10 +960,6 @@ impl Attribute {
         AttributeExt::value_span(self)
     }
 
-    pub fn ident(&self) -> Option<Ident> {
-        AttributeExt::ident(self)
-    }
-
     pub fn path_matches(&self, name: &[Symbol]) -> bool {
         AttributeExt::path_matches(self, name)
     }
@@ -938,10 +991,6 @@ impl Attribute {
         AttributeExt::path(self)
     }
 
-    pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
-        AttributeExt::ident_path(self)
-    }
-
     pub fn doc_str(&self) -> Option<Symbol> {
         AttributeExt::doc_str(self)
     }
diff --git a/compiler/rustc_hir/src/version.rs b/compiler/rustc_ast/src/attr/version.rs
similarity index 75%
rename from compiler/rustc_hir/src/version.rs
rename to compiler/rustc_ast/src/attr/version.rs
index 03182088d4c0..59deee40ae28 100644
--- a/compiler/rustc_hir/src/version.rs
+++ b/compiler/rustc_ast/src/attr/version.rs
@@ -1,16 +1,10 @@
-use std::borrow::Cow;
 use std::fmt::{self, Display};
 use std::sync::OnceLock;
 
-use rustc_error_messages::{DiagArgValue, IntoDiagArg};
-use rustc_macros::{
-    BlobDecodable, Encodable, HashStable_Generic, PrintAttribute, current_rustc_version,
-};
-
-use crate::attrs::PrintAttribute;
+use rustc_macros::{BlobDecodable, Encodable, HashStable_Generic, current_rustc_version};
 
 #[derive(Encodable, BlobDecodable, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(HashStable_Generic, PrintAttribute)]
+#[derive(HashStable_Generic)]
 pub struct RustcVersion {
     pub major: u16,
     pub minor: u16,
@@ -47,9 +41,3 @@ impl Display for RustcVersion {
         write!(formatter, "{}.{}.{}", self.major, self.minor, self.patch)
     }
 }
-
-impl IntoDiagArg for RustcVersion {
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-        DiagArgValue::Str(Cow::Owned(self.to_string()))
-    }
-}
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index d122adfdf966..83b751fbde90 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -366,6 +366,7 @@ macro_rules! common_visitor_and_walkers {
             crate::token::LitKind,
             crate::tokenstream::LazyAttrTokenStream,
             crate::tokenstream::TokenStream,
+            EarlyParsedAttribute,
             Movability,
             Mutability,
             Pinnedness,
@@ -457,6 +458,7 @@ macro_rules! common_visitor_and_walkers {
             ModSpans,
             MutTy,
             NormalAttr,
+            AttrItemKind,
             Parens,
             ParenthesizedArgs,
             PatFieldsRest,
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index 5bfe63008516..cf3f331a701b 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -98,7 +98,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // Let statements are allowed to have impl trait in bindings.
         let super_ = l.super_.map(|span| self.lower_span(span));
         let ty = l.ty.as_ref().map(|t| {
-            self.lower_ty(t, self.impl_trait_in_bindings_ctxt(ImplTraitPosition::Variable))
+            self.lower_ty_alloc(t, self.impl_trait_in_bindings_ctxt(ImplTraitPosition::Variable))
         });
         let init = l.kind.init().map(|init| self.lower_expr(init));
         let hir_id = self.lower_node_id(l.id);
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 0502fd2873e9..9fbfeb7a11e6 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -158,14 +158,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::Cast(expr, ty) => {
                     let expr = self.lower_expr(expr);
-                    let ty =
-                        self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
+                    let ty = self
+                        .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
                     hir::ExprKind::Cast(expr, ty)
                 }
                 ExprKind::Type(expr, ty) => {
                     let expr = self.lower_expr(expr);
-                    let ty =
-                        self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
+                    let ty = self
+                        .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
                     hir::ExprKind::Type(expr, ty)
                 }
                 ExprKind::AddrOf(k, m, ohs) => {
@@ -335,7 +335,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::FormatArgs(fmt) => self.lower_format_args(e.span, fmt),
                 ExprKind::OffsetOf(container, fields) => hir::ExprKind::OffsetOf(
-                    self.lower_ty(
+                    self.lower_ty_alloc(
                         container,
                         ImplTraitContext::Disallowed(ImplTraitPosition::OffsetOf),
                     ),
@@ -371,7 +371,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     *kind,
                     self.lower_expr(expr),
                     ty.as_ref().map(|ty| {
-                        self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast))
+                        self.lower_ty_alloc(
+                            ty,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Cast),
+                        )
                     }),
                 ),
 
@@ -617,7 +620,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         });
 
         if let Some(ty) = opt_ty {
-            let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Path));
+            let ty = self.lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Path));
             let block_expr = self.arena.alloc(self.expr_block(whole_block));
             hir::ExprKind::Type(block_expr, ty)
         } else {
diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index f6edcaa64dfe..be0a1d490da6 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -312,7 +312,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
 
     fn visit_const_arg(&mut self, const_arg: &'hir ConstArg<'hir, AmbigArg>) {
         self.insert(
-            const_arg.as_unambig_ct().span(),
+            const_arg.as_unambig_ct().span,
             const_arg.hir_id,
             Node::ConstArg(const_arg.as_unambig_ct()),
         );
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index bfce7c25b75d..3a7308ef7c97 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -2,7 +2,7 @@ use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
 use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
-use rustc_hir::attrs::{AttributeKind, EiiDecl};
+use rustc_hir::attrs::{AttributeKind, EiiDecl, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
 use rustc_hir::{
@@ -134,6 +134,56 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
+    fn lower_eii_extern_target(
+        &mut self,
+        id: NodeId,
+        eii_name: Ident,
+        EiiExternTarget { extern_item_path, impl_unsafe }: &EiiExternTarget,
+    ) -> Option<EiiDecl> {
+        self.lower_path_simple_eii(id, extern_item_path).map(|did| EiiDecl {
+            eii_extern_target: did,
+            impl_unsafe: *impl_unsafe,
+            name: eii_name,
+        })
+    }
+
+    fn lower_eii_impl(
+        &mut self,
+        EiiImpl {
+            node_id,
+            eii_macro_path,
+            impl_safety,
+            span,
+            inner_span,
+            is_default,
+            known_eii_macro_resolution,
+        }: &EiiImpl,
+    ) -> hir::attrs::EiiImpl {
+        let resolution = if let Some(target) = known_eii_macro_resolution
+            && let Some(decl) = self.lower_eii_extern_target(
+                *node_id,
+                // the expect is ok here since we always generate this path in the eii macro.
+                eii_macro_path.segments.last().expect("at least one segment").ident,
+                target,
+            ) {
+            EiiImplResolution::Known(decl)
+        } else if let Some(macro_did) = self.lower_path_simple_eii(*node_id, eii_macro_path) {
+            EiiImplResolution::Macro(macro_did)
+        } else {
+            EiiImplResolution::Error(
+                self.dcx().span_delayed_bug(*span, "eii never resolved without errors given"),
+            )
+        };
+
+        hir::attrs::EiiImpl {
+            span: self.lower_span(*span),
+            inner_span: self.lower_span(*inner_span),
+            impl_marked_unsafe: self.lower_safety(*impl_safety, hir::Safety::Safe).is_unsafe(),
+            is_default: *is_default,
+            resolution,
+        }
+    }
+
     fn generate_extra_attrs_for_item_kind(
         &mut self,
         id: NodeId,
@@ -143,49 +193,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ItemKind::Fn(box Fn { eii_impls, .. }) if eii_impls.is_empty() => Vec::new(),
             ItemKind::Fn(box Fn { eii_impls, .. }) => {
                 vec![hir::Attribute::Parsed(AttributeKind::EiiImpls(
-                    eii_impls
-                        .iter()
-                        .flat_map(
-                            |EiiImpl {
-                                 node_id,
-                                 eii_macro_path,
-                                 impl_safety,
-                                 span,
-                                 inner_span,
-                                 is_default,
-                             }| {
-                                self.lower_path_simple_eii(*node_id, eii_macro_path).map(|did| {
-                                    hir::attrs::EiiImpl {
-                                        eii_macro: did,
-                                        span: self.lower_span(*span),
-                                        inner_span: self.lower_span(*inner_span),
-                                        impl_marked_unsafe: self
-                                            .lower_safety(*impl_safety, hir::Safety::Safe)
-                                            .is_unsafe(),
-                                        is_default: *is_default,
-                                    }
-                                })
-                            },
-                        )
-                        .collect(),
+                    eii_impls.iter().map(|i| self.lower_eii_impl(i)).collect(),
                 ))]
             }
-            ItemKind::MacroDef(
-                _,
-                MacroDef {
-                    eii_extern_target: Some(EiiExternTarget { extern_item_path, impl_unsafe, span }),
-                    ..
-                },
-            ) => self
-                .lower_path_simple_eii(id, extern_item_path)
-                .map(|did| {
-                    vec![hir::Attribute::Parsed(AttributeKind::EiiExternTarget(EiiDecl {
-                        eii_extern_target: did,
-                        impl_unsafe: *impl_unsafe,
-                        span: self.lower_span(*span),
-                    }))]
-                })
+            ItemKind::MacroDef(name, MacroDef { eii_extern_target: Some(target), .. }) => self
+                .lower_eii_extern_target(id, *name, target)
+                .map(|decl| vec![hir::Attribute::Parsed(AttributeKind::EiiExternTarget(decl))])
                 .unwrap_or_default(),
+
             ItemKind::ExternCrate(..)
             | ItemKind::Use(..)
             | ItemKind::Static(..)
@@ -264,8 +279,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 define_opaque,
             }) => {
                 let ident = self.lower_ident(*ident);
-                let ty =
-                    self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
+                let ty = self
+                    .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
                 let body_id = self.lower_const_body(span, e.as_deref());
                 self.lower_define_opaque(hir_id, define_opaque);
                 hir::ItemKind::Static(*m, ident, ty, body_id)
@@ -279,8 +294,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
-                        let ty = this
-                            .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
+                        let ty = this.lower_ty_alloc(
+                            ty,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
+                        );
                         let rhs = this.lower_const_item_rhs(attrs, rhs.as_ref(), span);
                         (ty, rhs)
                     },
@@ -379,7 +396,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             );
                             this.arena.alloc(this.ty(span, hir::TyKind::Err(guar)))
                         }
-                        Some(ty) => this.lower_ty(
+                        Some(ty) => this.lower_ty_alloc(
                             ty,
                             ImplTraitContext::OpaqueTy {
                                 origin: hir::OpaqueTyOrigin::TyAlias {
@@ -453,7 +470,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             .as_deref()
                             .map(|of_trait| this.lower_trait_impl_header(of_trait));
 
-                        let lowered_ty = this.lower_ty(
+                        let lowered_ty = this.lower_ty_alloc(
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ImplSelf),
                         );
@@ -758,8 +775,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 safety,
                 define_opaque,
             }) => {
-                let ty =
-                    self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
+                let ty = self
+                    .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
                 let safety = self.lower_safety(*safety, hir::Safety::Unsafe);
                 if define_opaque.is_some() {
                     self.dcx().span_err(i.span, "foreign statics cannot define opaque types");
@@ -870,7 +887,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         (index, f): (usize, &FieldDef),
     ) -> hir::FieldDef<'hir> {
-        let ty = self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
+        let ty =
+            self.lower_ty_alloc(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs, f.span, Target::Field);
         hir::FieldDef {
@@ -908,8 +926,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     i.id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
-                        let ty = this
-                            .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
+                        let ty = this.lower_ty_alloc(
+                            ty,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
+                        );
                         let rhs = rhs
                             .as_ref()
                             .map(|rhs| this.lower_const_item_rhs(attrs, Some(rhs), i.span));
@@ -1008,7 +1028,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let ty = ty.as_ref().map(|x| {
-                            this.lower_ty(
+                            this.lower_ty_alloc(
                                 x,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::AssocTy),
                             )
@@ -1120,8 +1140,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     i.id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
-                        let ty = this
-                            .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
+                        let ty = this.lower_ty_alloc(
+                            ty,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
+                        );
                         this.lower_define_opaque(hir_id, &define_opaque);
                         let rhs = this.lower_const_item_rhs(attrs, rhs.as_ref(), i.span);
                         hir::ImplItemKind::Const(ty, rhs)
@@ -1180,7 +1202,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                 hir::ImplItemKind::Type(ty)
                             }
                             Some(ty) => {
-                                let ty = this.lower_ty(
+                                let ty = this.lower_ty_alloc(
                                     ty,
                                     ImplTraitContext::OpaqueTy {
                                         origin: hir::OpaqueTyOrigin::TyAlias {
@@ -1916,7 +1938,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         bound_generic_params,
                         hir::GenericParamSource::Binder,
                     ),
-                    bounded_ty: self.lower_ty(
+                    bounded_ty: self.lower_ty_alloc(
                         bounded_ty,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                     ),
@@ -1945,10 +1967,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             WherePredicateKind::EqPredicate(WhereEqPredicate { lhs_ty, rhs_ty }) => {
                 hir::WherePredicateKind::EqPredicate(hir::WhereEqPredicate {
-                    lhs_ty: self
-                        .lower_ty(lhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
-                    rhs_ty: self
-                        .lower_ty(rhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
+                    lhs_ty: self.lower_ty_alloc(
+                        lhs_ty,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    ),
+                    rhs_ty: self.lower_ty_alloc(
+                        rhs_ty,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    ),
                 })
             }
         });
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 416fef8e3af3..42eb8673f30c 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1125,8 +1125,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let kind = match &constraint.kind {
             AssocItemConstraintKind::Equality { term } => {
                 let term = match term {
-                    Term::Ty(ty) => self.lower_ty(ty, itctx).into(),
-                    Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),
+                    Term::Ty(ty) => self.lower_ty_alloc(ty, itctx).into(),
+                    Term::Const(c) => self.lower_anon_const_to_const_arg_and_alloc(c).into(),
                 };
                 hir::AssocItemConstraintKind::Equality { term }
             }
@@ -1250,17 +1250,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                     _ => {}
                 }
-                GenericArg::Type(self.lower_ty(ty, itctx).try_as_ambig_ty().unwrap())
-            }
-            ast::GenericArg::Const(ct) => {
-                GenericArg::Const(self.lower_anon_const_to_const_arg(ct).try_as_ambig_ct().unwrap())
+                GenericArg::Type(self.lower_ty_alloc(ty, itctx).try_as_ambig_ty().unwrap())
             }
+            ast::GenericArg::Const(ct) => GenericArg::Const(
+                self.lower_anon_const_to_const_arg_and_alloc(ct).try_as_ambig_ct().unwrap(),
+            ),
         }
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> {
-        self.arena.alloc(self.lower_ty_direct(t, itctx))
+    fn lower_ty_alloc(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> {
+        self.arena.alloc(self.lower_ty(t, itctx))
     }
 
     fn lower_path_ty(
@@ -1324,11 +1324,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.ty(span, hir::TyKind::Tup(tys))
     }
 
-    fn lower_ty_direct(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty<'hir> {
+    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty<'hir> {
         let kind = match &t.kind {
             TyKind::Infer => hir::TyKind::Infer(()),
             TyKind::Err(guar) => hir::TyKind::Err(*guar),
-            TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
+            TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty_alloc(ty, itctx)),
             TyKind::Ptr(mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
             TyKind::Ref(region, mt) => {
                 let lifetime = self.lower_ty_direct_lifetime(t, *region);
@@ -1362,15 +1362,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params);
                 hir::TyKind::UnsafeBinder(self.arena.alloc(hir::UnsafeBinderTy {
                     generic_params,
-                    inner_ty: self.lower_ty(&f.inner_ty, itctx),
+                    inner_ty: self.lower_ty_alloc(&f.inner_ty, itctx),
                 }))
             }
             TyKind::Never => hir::TyKind::Never,
             TyKind::Tup(tys) => hir::TyKind::Tup(
-                self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx))),
+                self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty(ty, itctx))),
             ),
             TyKind::Paren(ty) => {
-                return self.lower_ty_direct(ty, itctx);
+                return self.lower_ty(ty, itctx);
             }
             TyKind::Path(qself, path) => {
                 return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx);
@@ -1393,7 +1393,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 ))
             }
             TyKind::Array(ty, length) => hir::TyKind::Array(
-                self.lower_ty(ty, itctx),
+                self.lower_ty_alloc(ty, itctx),
                 self.lower_array_length_to_const_arg(length),
             ),
             TyKind::TraitObject(bounds, kind) => {
@@ -1493,7 +1493,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
             }
             TyKind::Pat(ty, pat) => {
-                hir::TyKind::Pat(self.lower_ty(ty, itctx), self.lower_ty_pat(pat, ty.span))
+                hir::TyKind::Pat(self.lower_ty_alloc(ty, itctx), self.lower_ty_pat(pat, ty.span))
             }
             TyKind::MacCall(_) => {
                 span_bug!(t.span, "`TyKind::MacCall` should have been expanded by now")
@@ -1693,7 +1693,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     ImplTraitContext::Disallowed(ImplTraitPosition::PointerParam)
                 }
             };
-            self.lower_ty_direct(&param.ty, itctx)
+            self.lower_ty(&param.ty, itctx)
         }));
 
         let output = match coro {
@@ -1732,7 +1732,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             ImplTraitContext::Disallowed(ImplTraitPosition::PointerReturn)
                         }
                     };
-                    hir::FnRetTy::Return(self.lower_ty(ty, itctx))
+                    hir::FnRetTy::Return(self.lower_ty_alloc(ty, itctx))
                 }
                 FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(self.lower_span(*span)),
             },
@@ -1843,7 +1843,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 // Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
                 // `impl Future` opaque type that `async fn` implicitly
                 // generates.
-                self.lower_ty(ty, itctx)
+                self.lower_ty_alloc(ty, itctx)
             }
             FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
         };
@@ -1986,8 +1986,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let (name, kind) = self.lower_generic_param_kind(param, source);
 
         let hir_id = self.lower_node_id(param.id);
-        self.lower_attrs(hir_id, &param.attrs, param.span(), Target::Param);
-        hir::GenericParam {
+        let param_attrs = &param.attrs;
+        let param_span = param.span();
+        let param = hir::GenericParam {
             hir_id,
             def_id: self.local_def_id(param.id),
             name,
@@ -1996,7 +1997,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             kind,
             colon_span: param.colon_span.map(|s| self.lower_span(s)),
             source,
-        }
+        };
+        self.lower_attrs(hir_id, param_attrs, param_span, Target::from_generic_param(&param));
+        param
     }
 
     fn lower_generic_param_kind(
@@ -2036,7 +2039,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         }
                     })
                     .map(|def| {
-                        self.lower_ty(
+                        self.lower_ty_alloc(
                             def,
                             ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
                         )
@@ -2047,8 +2050,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 (hir::ParamName::Plain(self.lower_ident(param.ident)), kind)
             }
             GenericParamKind::Const { ty, span: _, default } => {
-                let ty = self
-                    .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault));
+                let ty = self.lower_ty_alloc(
+                    ty,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
+                );
 
                 // Not only do we deny const param defaults in binders but we also map them to `None`
                 // since later compiler stages cannot handle them (and shouldn't need to be able to).
@@ -2064,7 +2069,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             false
                         }
                     })
-                    .map(|def| self.lower_anon_const_to_const_arg(def));
+                    .map(|def| self.lower_anon_const_to_const_arg_and_alloc(def));
 
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
@@ -2198,7 +2203,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
-        hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl }
+        hir::MutTy { ty: self.lower_ty_alloc(&mt.ty, itctx), mutbl: mt.mutbl }
     }
 
     #[instrument(level = "debug", skip(self), ret)]
@@ -2283,10 +2288,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // `ExprKind::Paren(ExprKind::Underscore)` and should also be lowered to `GenericArg::Infer`
         match c.value.peel_parens().kind {
             ExprKind::Underscore => {
-                let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span), ());
-                self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
+                let ct_kind = hir::ConstArgKind::Infer(());
+                self.arena.alloc(hir::ConstArg {
+                    hir_id: self.lower_node_id(c.id),
+                    kind: ct_kind,
+                    span: self.lower_span(c.value.span),
+                })
             }
-            _ => self.lower_anon_const_to_const_arg(c),
+            _ => self.lower_anon_const_to_const_arg_and_alloc(c),
         }
     }
 
@@ -2354,7 +2363,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir::ConstArgKind::Anon(ct)
         };
 
-        self.arena.alloc(hir::ConstArg { hir_id: self.next_id(), kind: ct_kind })
+        self.arena.alloc(hir::ConstArg {
+            hir_id: self.next_id(),
+            kind: ct_kind,
+            span: self.lower_span(span),
+        })
     }
 
     fn lower_const_item_rhs(
@@ -2365,15 +2378,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> hir::ConstItemRhs<'hir> {
         match rhs {
             Some(ConstItemRhs::TypeConst(anon)) => {
-                hir::ConstItemRhs::TypeConst(self.lower_anon_const_to_const_arg(anon))
+                hir::ConstItemRhs::TypeConst(self.lower_anon_const_to_const_arg_and_alloc(anon))
             }
             None if attr::contains_name(attrs, sym::type_const) => {
                 let const_arg = ConstArg {
                     hir_id: self.next_id(),
                     kind: hir::ConstArgKind::Error(
-                        DUMMY_SP,
                         self.dcx().span_delayed_bug(DUMMY_SP, "no block"),
                     ),
+                    span: DUMMY_SP,
                 };
                 hir::ConstItemRhs::TypeConst(self.arena.alloc(const_arg))
             }
@@ -2386,16 +2399,65 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     #[instrument(level = "debug", skip(self), ret)]
     fn lower_expr_to_const_arg_direct(&mut self, expr: &Expr) -> hir::ConstArg<'hir> {
+        let span = self.lower_span(expr.span);
+
         let overly_complex_const = |this: &mut Self| {
             let e = this.dcx().struct_span_err(
                 expr.span,
                 "complex const arguments must be placed inside of a `const` block",
             );
 
-            ConstArg { hir_id: this.next_id(), kind: hir::ConstArgKind::Error(expr.span, e.emit()) }
+            ConstArg { hir_id: this.next_id(), kind: hir::ConstArgKind::Error(e.emit()), span }
         };
 
         match &expr.kind {
+            ExprKind::Call(func, args) if let ExprKind::Path(qself, path) = &func.kind => {
+                let qpath = self.lower_qpath(
+                    func.id,
+                    qself,
+                    path,
+                    ParamMode::Explicit,
+                    AllowReturnTypeNotation::No,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    None,
+                );
+
+                let lowered_args = self.arena.alloc_from_iter(args.iter().map(|arg| {
+                    let const_arg = if let ExprKind::ConstBlock(anon_const) = &arg.kind {
+                        let def_id = self.local_def_id(anon_const.id);
+                        let def_kind = self.tcx.def_kind(def_id);
+                        assert_eq!(DefKind::AnonConst, def_kind);
+                        self.lower_anon_const_to_const_arg(anon_const)
+                    } else {
+                        self.lower_expr_to_const_arg_direct(arg)
+                    };
+
+                    &*self.arena.alloc(const_arg)
+                }));
+
+                ConstArg {
+                    hir_id: self.next_id(),
+                    kind: hir::ConstArgKind::TupleCall(qpath, lowered_args),
+                    span,
+                }
+            }
+            ExprKind::Tup(exprs) => {
+                let exprs = self.arena.alloc_from_iter(exprs.iter().map(|expr| {
+                    let expr = if let ExprKind::ConstBlock(anon_const) = &expr.kind {
+                        let def_id = self.local_def_id(anon_const.id);
+                        let def_kind = self.tcx.def_kind(def_id);
+                        assert_eq!(DefKind::AnonConst, def_kind);
+
+                        self.lower_anon_const_to_const_arg(anon_const)
+                    } else {
+                        self.lower_expr_to_const_arg_direct(&expr)
+                    };
+
+                    &*self.arena.alloc(expr)
+                }));
+
+                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Tup(exprs), span }
+            }
             ExprKind::Path(qself, path) => {
                 let qpath = self.lower_qpath(
                     expr.id,
@@ -2408,7 +2470,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     None,
                 );
 
-                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Path(qpath) }
+                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Path(qpath), span }
             }
             ExprKind::Struct(se) => {
                 let path = self.lower_qpath(
@@ -2436,7 +2498,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         let def_kind = self.tcx.def_kind(def_id);
                         assert_eq!(DefKind::AnonConst, def_kind);
 
-                        self.lower_anon_const_to_const_arg_direct(anon_const)
+                        self.lower_anon_const_to_const_arg(anon_const)
                     } else {
                         self.lower_expr_to_const_arg_direct(&f.expr)
                     };
@@ -2449,18 +2511,27 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     })
                 }));
 
-                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Struct(path, fields) }
+                ConstArg {
+                    hir_id: self.next_id(),
+                    kind: hir::ConstArgKind::Struct(path, fields),
+                    span,
+                }
             }
             ExprKind::Underscore => ConstArg {
                 hir_id: self.lower_node_id(expr.id),
-                kind: hir::ConstArgKind::Infer(expr.span, ()),
+                kind: hir::ConstArgKind::Infer(()),
+                span,
             },
             ExprKind::Block(block, _) => {
                 if let [stmt] = block.stmts.as_slice()
                     && let StmtKind::Expr(expr) = &stmt.kind
                     && matches!(
                         expr.kind,
-                        ExprKind::Block(..) | ExprKind::Path(..) | ExprKind::Struct(..)
+                        ExprKind::Block(..)
+                            | ExprKind::Path(..)
+                            | ExprKind::Struct(..)
+                            | ExprKind::Call(..)
+                            | ExprKind::Tup(..)
                     )
                 {
                     return self.lower_expr_to_const_arg_direct(expr);
@@ -2468,18 +2539,31 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 overly_complex_const(self)
             }
+            ExprKind::Lit(literal) => {
+                let span = expr.span;
+                let literal = self.lower_lit(literal, span);
+
+                ConstArg {
+                    hir_id: self.lower_node_id(expr.id),
+                    kind: hir::ConstArgKind::Literal(literal.node),
+                    span,
+                }
+            }
             _ => overly_complex_const(self),
         }
     }
 
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_anon_const`].
-    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> &'hir hir::ConstArg<'hir> {
-        self.arena.alloc(self.lower_anon_const_to_const_arg_direct(anon))
+    fn lower_anon_const_to_const_arg_and_alloc(
+        &mut self,
+        anon: &AnonConst,
+    ) -> &'hir hir::ConstArg<'hir> {
+        self.arena.alloc(self.lower_anon_const_to_const_arg(anon))
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
+    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
         let tcx = self.tcx;
 
         // We cannot change parsing depending on feature gates available,
@@ -2491,7 +2575,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             return match anon.mgca_disambiguation {
                 MgcaDisambiguation::AnonConst => {
                     let lowered_anon = self.lower_anon_const_to_anon_const(anon);
-                    ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Anon(lowered_anon) }
+                    ConstArg {
+                        hir_id: self.next_id(),
+                        kind: hir::ConstArgKind::Anon(lowered_anon),
+                        span: lowered_anon.span,
+                    }
                 }
                 MgcaDisambiguation::Direct => self.lower_expr_to_const_arg_direct(&anon.value),
             };
@@ -2528,11 +2616,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             return ConstArg {
                 hir_id: self.lower_node_id(anon.id),
                 kind: hir::ConstArgKind::Path(qpath),
+                span: self.lower_span(expr.span),
             };
         }
 
         let lowered_anon = self.lower_anon_const_to_anon_const(anon);
-        ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Anon(lowered_anon) }
+        ConstArg {
+            hir_id: self.next_id(),
+            kind: hir::ConstArgKind::Anon(lowered_anon),
+            span: self.lower_span(expr.span),
+        }
     }
 
     /// See [`hir::ConstArg`] for when to use this function vs
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index 7a5d8d9847a1..e066bce95158 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -444,16 +444,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let pat_hir_id = self.lower_node_id(pattern.id);
         let node = match &pattern.kind {
             TyPatKind::Range(e1, e2, Spanned { node: end, span }) => hir::TyPatKind::Range(
-                e1.as_deref().map(|e| self.lower_anon_const_to_const_arg(e)).unwrap_or_else(|| {
-                    self.lower_ty_pat_range_end(
-                        hir::LangItem::RangeMin,
-                        span.shrink_to_lo(),
-                        base_type,
-                    )
-                }),
+                e1.as_deref()
+                    .map(|e| self.lower_anon_const_to_const_arg_and_alloc(e))
+                    .unwrap_or_else(|| {
+                        self.lower_ty_pat_range_end(
+                            hir::LangItem::RangeMin,
+                            span.shrink_to_lo(),
+                            base_type,
+                        )
+                    }),
                 e2.as_deref()
                     .map(|e| match end {
-                        RangeEnd::Included(..) => self.lower_anon_const_to_const_arg(e),
+                        RangeEnd::Included(..) => self.lower_anon_const_to_const_arg_and_alloc(e),
                         RangeEnd::Excluded => self.lower_excluded_range_end(e),
                     })
                     .unwrap_or_else(|| {
@@ -511,6 +513,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.arena.alloc(hir::ConstArg {
             hir_id: self.next_id(),
             kind: hir::ConstArgKind::Anon(self.arena.alloc(anon_const)),
+            span,
         })
     }
 
@@ -555,6 +558,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             })
         });
         let hir_id = self.next_id();
-        self.arena.alloc(hir::ConstArg { kind: hir::ConstArgKind::Anon(ct), hir_id })
+        self.arena.alloc(hir::ConstArg { kind: hir::ConstArgKind::Anon(ct), hir_id, span })
     }
 }
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 3322e0fb66b4..bfb42efb684f 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -36,7 +36,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let qself = qself
             .as_ref()
             // Reject cases like `<impl Trait>::Assoc` and `<impl Trait as Trait>::Assoc`.
-            .map(|q| self.lower_ty(&q.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Path)));
+            .map(|q| {
+                self.lower_ty_alloc(&q.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Path))
+            });
 
         let partial_res =
             self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
@@ -510,7 +512,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // we generally don't permit such things (see #51008).
         let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
         let inputs = self.arena.alloc_from_iter(inputs.iter().map(|ty| {
-            self.lower_ty_direct(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
+            self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
         }));
         let output_ty = match output {
             // Only allow `impl Trait` in return position. i.e.:
@@ -520,9 +522,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // ```
             FnRetTy::Ty(ty) if matches!(itctx, ImplTraitContext::OpaqueTy { .. }) => {
                 if self.tcx.features().impl_trait_in_fn_trait_return() {
-                    self.lower_ty(ty, itctx)
+                    self.lower_ty_alloc(ty, itctx)
                 } else {
-                    self.lower_ty(
+                    self.lower_ty_alloc(
                         ty,
                         ImplTraitContext::FeatureGated(
                             ImplTraitPosition::FnTraitReturn,
@@ -531,9 +533,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     )
                 }
             }
-            FnRetTy::Ty(ty) => {
-                self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
-            }
+            FnRetTy::Ty(ty) => self
+                .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn)),
             FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
         };
         let args = smallvec![GenericArg::Type(
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index a083ca7d133e..eddcf12fca29 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -401,9 +401,16 @@ impl<'a> AstValidator<'a> {
                     | CanonAbi::Rust
                     | CanonAbi::RustCold
                     | CanonAbi::Arm(_)
-                    | CanonAbi::GpuKernel
                     | CanonAbi::X86(_) => { /* nothing to check */ }
 
+                    CanonAbi::GpuKernel => {
+                        // An `extern "gpu-kernel"` function cannot be `async` and/or `gen`.
+                        self.reject_coroutine(abi, sig);
+
+                        // An `extern "gpu-kernel"` function cannot return a value.
+                        self.reject_return(abi, sig);
+                    }
+
                     CanonAbi::Custom => {
                         // An `extern "custom"` function must be unsafe.
                         self.reject_safe_fn(abi, ctxt, sig);
@@ -433,18 +440,7 @@ impl<'a> AstValidator<'a> {
                                 self.dcx().emit_err(errors::AbiX86Interrupt { spans, param_count });
                             }
 
-                            if let FnRetTy::Ty(ref ret_ty) = sig.decl.output
-                                && match &ret_ty.kind {
-                                    TyKind::Never => false,
-                                    TyKind::Tup(tup) if tup.is_empty() => false,
-                                    _ => true,
-                                }
-                            {
-                                self.dcx().emit_err(errors::AbiMustNotHaveReturnType {
-                                    span: ret_ty.span,
-                                    abi,
-                                });
-                            }
+                            self.reject_return(abi, sig);
                         } else {
                             // An `extern "interrupt"` function must have type `fn()`.
                             self.reject_params_or_return(abi, ident, sig);
@@ -496,6 +492,18 @@ impl<'a> AstValidator<'a> {
         }
     }
 
+    fn reject_return(&self, abi: ExternAbi, sig: &FnSig) {
+        if let FnRetTy::Ty(ref ret_ty) = sig.decl.output
+            && match &ret_ty.kind {
+                TyKind::Never => false,
+                TyKind::Tup(tup) if tup.is_empty() => false,
+                _ => true,
+            }
+        {
+            self.dcx().emit_err(errors::AbiMustNotHaveReturnType { span: ret_ty.span, abi });
+        }
+    }
+
     fn reject_params_or_return(&self, abi: ExternAbi, ident: &Ident, sig: &FnSig) {
         let mut spans: Vec<_> = sig.decl.inputs.iter().map(|p| p.span).collect();
         if let FnRetTy::Ty(ref ret_ty) = sig.decl.output
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index dbbd3906b525..028a5048d543 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -160,7 +160,7 @@ impl<'a> PostExpansionVisitor<'a> {
 
 impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
     fn visit_attribute(&mut self, attr: &ast::Attribute) {
-        let attr_info = attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
+        let attr_info = attr.name().and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name));
         // Check feature gates for built-in attributes.
         if let Some(BuiltinAttribute {
             gate: AttributeGate::Gated { feature, message, check, notes, .. },
@@ -505,7 +505,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
         half_open_range_patterns_in_slices,
         "half-open range patterns in slices are unstable"
     );
-    gate_all!(associated_const_equality, "associated const equality is incomplete");
     gate_all!(yeet_expr, "`do yeet` expression is experimental");
     gate_all!(const_closures, "const closures are experimental");
     gate_all!(builtin_syntax, "`builtin #` syntax is unstable");
@@ -518,6 +517,23 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(postfix_match, "postfix match is experimental");
     gate_all!(mut_ref, "mutable by-reference bindings are experimental");
     gate_all!(min_generic_const_args, "unbraced const blocks as const args are experimental");
+    // associated_const_equality is stabilized as part of min_generic_const_args
+    if let Some(spans) = spans.get(&sym::associated_const_equality) {
+        for span in spans {
+            if !visitor.features.min_generic_const_args()
+                && !span.allows_unstable(sym::min_generic_const_args)
+            {
+                #[allow(rustc::untranslatable_diagnostic)]
+                feature_err(
+                    &visitor.sess,
+                    sym::min_generic_const_args,
+                    *span,
+                    "associated const equality is incomplete",
+                )
+                .emit();
+            }
+        }
+    }
     gate_all!(global_registration, "global registration is experimental");
     gate_all!(return_type_notation, "return type notation is experimental");
     gate_all!(pin_ergonomics, "pinned reference syntax is experimental");
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 1aa08dfd3d5e..0cf0eae821e9 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -694,7 +694,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             }
             ast::Safety::Default | ast::Safety::Safe(_) => {}
         }
-        match &item.args {
+        match &item.args.unparsed_ref().expect("Parsed attributes are never printed") {
             AttrArgs::Delimited(DelimArgs { dspan: _, delim, tokens }) => self.print_mac_common(
                 Some(MacHeader::Path(&item.path)),
                 false,
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index 798cc1076541..ccf0a394afd0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -294,11 +294,9 @@ pub fn parse_cfg_attr(
     sess: &Session,
     features: Option<&Features>,
 ) -> Option<(CfgEntry, Vec<(AttrItem, Span)>)> {
-    match cfg_attr.get_normal_item().args {
-        ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, ref tokens })
-            if !tokens.is_empty() =>
-        {
-            check_cfg_attr_bad_delim(&sess.psess, dspan, delim);
+    match cfg_attr.get_normal_item().args.unparsed_ref().unwrap() {
+        ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, tokens }) if !tokens.is_empty() => {
+            check_cfg_attr_bad_delim(&sess.psess, *dspan, *delim);
             match parse_in(&sess.psess, tokens.clone(), "`cfg_attr` input", |p| {
                 parse_cfg_attr_internal(p, sess, features, cfg_attr)
             }) {
@@ -322,7 +320,7 @@ pub fn parse_cfg_attr(
         }
         _ => {
             let (span, reason) = if let ast::AttrArgs::Delimited(ast::DelimArgs { dspan, .. }) =
-                cfg_attr.get_normal_item().args
+                cfg_attr.get_normal_item().args.unparsed_ref()?
             {
                 (dspan.entire(), AttributeParseErrorReason::ExpectedAtLeastOneArgument)
             } else {
@@ -371,13 +369,7 @@ fn parse_cfg_attr_internal<'a>(
         attribute.span,
         attribute.get_normal_item().span(),
         attribute.style,
-        AttrPath {
-            segments: attribute
-                .ident_path()
-                .expect("cfg_attr is not a doc comment")
-                .into_boxed_slice(),
-            span: attribute.span,
-        },
+        AttrPath { segments: attribute.path().into_boxed_slice(), span: attribute.span },
         Some(attribute.get_normal_item().unsafety),
         ParsedDescription::Attribute,
         pred_span,
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
index 00a2d12106e7..24b989e22a2b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
@@ -7,7 +7,7 @@ use rustc_hir::attrs::CfgEntry;
 use rustc_parse::exp;
 use rustc_parse::parser::Parser;
 use rustc_session::Session;
-use rustc_span::{ErrorGuaranteed, Ident, Span};
+use rustc_span::{ErrorGuaranteed, Span, sym};
 
 use crate::parser::MetaItemOrLitParser;
 use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
@@ -86,10 +86,7 @@ pub fn parse_cfg_select(
                 cfg_span,
                 cfg_span,
                 AttrStyle::Inner,
-                AttrPath {
-                    segments: vec![Ident::from_str("cfg_select")].into_boxed_slice(),
-                    span: cfg_span,
-                },
+                AttrPath { segments: vec![sym::cfg_select].into_boxed_slice(), span: cfg_span },
                 None,
                 ParsedDescription::Macro,
                 cfg_span,
diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 01c503357fc7..5604fbd25edc 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -9,7 +9,7 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let ArgParser::NameValue(n) = args else {
@@ -33,7 +33,7 @@ impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -56,7 +56,7 @@ impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -79,7 +79,7 @@ impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -102,7 +102,7 @@ impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -123,7 +123,7 @@ pub(crate) struct NoCoreParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
     const PATH: &[Symbol] = &[sym::no_core];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
 }
 
@@ -132,7 +132,7 @@ pub(crate) struct NoStdParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
     const PATH: &[Symbol] = &[sym::no_std];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
 }
 
@@ -141,7 +141,7 @@ pub(crate) struct RustcCoherenceIsCoreParser;
 impl<S: Stage> NoArgsAttributeParser<S> for RustcCoherenceIsCoreParser {
     const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcCoherenceIsCore;
 }
 
@@ -151,7 +151,7 @@ impl<S: Stage> SingleAttributeParser<S> for WindowsSubsystemParser {
     const PATH: &[Symbol] = &[sym::windows_subsystem];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: ["windows", "console"], "https://doc.rust-lang.org/reference/runtime.html#the-windows_subsystem-attribute");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
index 922a5bd297ac..834b1d988cb4 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -305,3 +305,18 @@ impl<S: Stage> SingleAttributeParser<S> for RustcScalableVectorParser {
         Some(AttributeKind::RustcScalableVector { element_count: Some(n), span: cx.attr_span })
     }
 }
+
+pub(crate) struct RustcHasIncoherentInherentImplsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcHasIncoherentInherentImplsParser {
+    const PATH: &[Symbol] = &[sym::rustc_has_incoherent_inherent_impls];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Trait),
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+        Allow(Target::ForeignTy),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcHasIncoherentInherentImpls;
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 6d4f77ef1751..8d27e2e276dd 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -1,6 +1,7 @@
 use std::num::NonZero;
 
 use rustc_errors::ErrorGuaranteed;
+use rustc_hir::target::GenericParamKind;
 use rustc_hir::{
     DefaultBodyStability, MethodKind, PartialConstStability, Stability, StabilityLevel,
     StableSince, Target, UnstableReason, VERSION_PLACEHOLDER,
@@ -43,7 +44,7 @@ const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
     Allow(Target::TyAlias),
     Allow(Target::Variant),
     Allow(Target::Field),
-    Allow(Target::Param),
+    Allow(Target::GenericParam { kind: GenericParamKind::Type, has_default: true }),
     Allow(Target::Static),
     Allow(Target::ForeignFn),
     Allow(Target::ForeignStatic),
diff --git a/compiler/rustc_attr_parsing/src/attributes/transparency.rs b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
index 52aa42b1085a..7db84f8f2d95 100644
--- a/compiler/rustc_attr_parsing/src/attributes/transparency.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
@@ -15,7 +15,7 @@ impl<S: Stage> SingleAttributeParser<S> for TransparencyParser {
     });
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::MacroDef)]);
     const TEMPLATE: AttributeTemplate =
-        template!(NameValueStr: ["transparent", "semitransparent", "opaque"]);
+        template!(NameValueStr: ["transparent", "semiopaque", "opaque"]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(nv) = args.name_value() else {
@@ -24,12 +24,12 @@ impl<S: Stage> SingleAttributeParser<S> for TransparencyParser {
         };
         match nv.value_as_str() {
             Some(sym::transparent) => Some(Transparency::Transparent),
-            Some(sym::semiopaque | sym::semitransparent) => Some(Transparency::SemiOpaque),
+            Some(sym::semiopaque) => Some(Transparency::SemiOpaque),
             Some(sym::opaque) => Some(Transparency::Opaque),
             Some(_) => {
                 cx.expected_specific_argument_strings(
                     nv.value_span,
-                    &[sym::transparent, sym::semitransparent, sym::opaque],
+                    &[sym::transparent, sym::semiopaque, sym::opaque],
                 );
                 None
             }
diff --git a/compiler/rustc_attr_parsing/src/attributes/util.rs b/compiler/rustc_attr_parsing/src/attributes/util.rs
index 431ba539b2ba..ebec8e8443fc 100644
--- a/compiler/rustc_attr_parsing/src/attributes/util.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/util.rs
@@ -28,8 +28,7 @@ pub fn parse_version(s: Symbol) -> Option<RustcVersion> {
 }
 
 pub fn is_builtin_attr(attr: &impl AttributeExt) -> bool {
-    attr.is_doc_comment().is_some()
-        || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name))
+    attr.is_doc_comment().is_some() || attr.name().is_some_and(|name| is_builtin_attr_name(name))
 }
 
 /// Parse a single integer.
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index b85bb6c6c89d..732bf111b256 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -4,12 +4,12 @@ use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
 
 use private::Sealed;
-use rustc_ast::{AttrStyle, CRATE_NODE_ID, MetaItemLit, NodeId};
+use rustc_ast::{AttrStyle, MetaItemLit, NodeId};
 use rustc_errors::{Diag, Diagnostic, Level};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint, AttributeLintKind};
-use rustc_hir::{AttrPath, CRATE_HIR_ID, HirId};
+use rustc_hir::{AttrPath, HirId};
 use rustc_session::Session;
 use rustc_session::lint::{Lint, LintId};
 use rustc_span::{ErrorGuaranteed, Span, Symbol};
@@ -62,12 +62,12 @@ use crate::attributes::proc_macro_attrs::{
 use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
-    RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser,
-    RustcLegacyConstGenericsParser, RustcLintDiagnosticsParser, RustcLintOptDenyFieldAccessParser,
-    RustcLintOptTyParser, RustcLintQueryInstabilityParser,
-    RustcLintUntrackedQueryInformationParser, RustcMainParser, RustcMustImplementOneOfParser,
-    RustcNeverReturnsNullPointerParser, RustcNoImplicitAutorefsParser,
-    RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
+    RustcHasIncoherentInherentImplsParser, RustcLayoutScalarValidRangeEndParser,
+    RustcLayoutScalarValidRangeStartParser, RustcLegacyConstGenericsParser,
+    RustcLintDiagnosticsParser, RustcLintOptDenyFieldAccessParser, RustcLintOptTyParser,
+    RustcLintQueryInstabilityParser, RustcLintUntrackedQueryInformationParser, RustcMainParser,
+    RustcMustImplementOneOfParser, RustcNeverReturnsNullPointerParser,
+    RustcNoImplicitAutorefsParser, RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
     RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
@@ -264,6 +264,7 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
+        Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
         Single<WithoutArgs<RustcLintDiagnosticsParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,
         Single<WithoutArgs<RustcLintQueryInstabilityParser>>,
@@ -303,8 +304,6 @@ pub trait Stage: Sized + 'static + Sealed {
     ) -> ErrorGuaranteed;
 
     fn should_emit(&self) -> ShouldEmit;
-
-    fn id_is_crate_root(id: Self::Id) -> bool;
 }
 
 // allow because it's a sealed trait
@@ -326,10 +325,6 @@ impl Stage for Early {
     fn should_emit(&self) -> ShouldEmit {
         self.emit_errors
     }
-
-    fn id_is_crate_root(id: Self::Id) -> bool {
-        id == CRATE_NODE_ID
-    }
 }
 
 // allow because it's a sealed trait
@@ -351,10 +346,6 @@ impl Stage for Late {
     fn should_emit(&self) -> ShouldEmit {
         ShouldEmit::ErrorsAndLints
     }
-
-    fn id_is_crate_root(id: Self::Id) -> bool {
-        id == CRATE_HIR_ID
-    }
 }
 
 /// used when parsing attributes for miscellaneous things *before* ast lowering
diff --git a/compiler/rustc_attr_parsing/src/early_parsed.rs b/compiler/rustc_attr_parsing/src/early_parsed.rs
new file mode 100644
index 000000000000..6a33cb38edf9
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/early_parsed.rs
@@ -0,0 +1,53 @@
+use rustc_ast::EarlyParsedAttribute;
+use rustc_ast::attr::data_structures::CfgEntry;
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+use thin_vec::ThinVec;
+
+pub(crate) const EARLY_PARSED_ATTRIBUTES: &[&[Symbol]] =
+    &[&[sym::cfg_trace], &[sym::cfg_attr_trace]];
+
+/// This struct contains the state necessary to convert early parsed attributes to hir attributes
+/// The only conversion that really happens here is that multiple early parsed attributes are
+/// merged into a single hir attribute, representing their combined state.
+/// FIXME: We should make this a nice and extendable system if this is going to be used more often
+#[derive(Default)]
+pub(crate) struct EarlyParsedState {
+    /// Attribute state for `#[cfg]` trace attributes
+    cfg_trace: ThinVec<(CfgEntry, Span)>,
+
+    /// Attribute state for `#[cfg_attr]` trace attributes
+    /// The arguments of these attributes is no longer relevant for any later passes, only their presence.
+    /// So we discard the arguments here.
+    cfg_attr_trace: bool,
+}
+
+impl EarlyParsedState {
+    pub(crate) fn accept_early_parsed_attribute(
+        &mut self,
+        attr_span: Span,
+        lower_span: impl Copy + Fn(Span) -> Span,
+        parsed: &EarlyParsedAttribute,
+    ) {
+        match parsed {
+            EarlyParsedAttribute::CfgTrace(cfg) => {
+                let mut cfg = cfg.clone();
+                cfg.lower_spans(lower_span);
+                self.cfg_trace.push((cfg, attr_span));
+            }
+            EarlyParsedAttribute::CfgAttrTrace => {
+                self.cfg_attr_trace = true;
+            }
+        }
+    }
+
+    pub(crate) fn finalize_early_parsed_attributes(self, attributes: &mut Vec<Attribute>) {
+        if !self.cfg_trace.is_empty() {
+            attributes.push(Attribute::Parsed(AttributeKind::CfgTrace(self.cfg_trace)));
+        }
+        if self.cfg_attr_trace {
+            attributes.push(Attribute::Parsed(AttributeKind::CfgAttrTrace));
+        }
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index 91596ff0de60..e38fffa6587c 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -2,7 +2,7 @@ use std::convert::identity;
 
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
-use rustc_ast::{AttrStyle, NodeId, Safety};
+use rustc_ast::{AttrItemKind, AttrStyle, NodeId, Safety};
 use rustc_errors::DiagCtxtHandle;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::AttributeKind;
@@ -13,6 +13,7 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
 use crate::context::{AcceptContext, FinalizeContext, SharedContext, Stage};
+use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
 use crate::parser::{ArgParser, PathParser, RefPathParser};
 use crate::session_diagnostics::ParsedDescription;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
@@ -146,8 +147,12 @@ impl<'sess> AttributeParser<'sess, Early> {
             normal_attr.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
 
         let path = AttrPath::from_ast(&normal_attr.item.path, identity);
-        let args =
-            ArgParser::from_attr_args(&normal_attr.item.args, &parts, &sess.psess, emit_errors)?;
+        let args = ArgParser::from_attr_args(
+            &normal_attr.item.args.unparsed_ref().unwrap(),
+            &parts,
+            &sess.psess,
+            emit_errors,
+        )?;
         Self::parse_single_args(
             sess,
             attr.span,
@@ -263,12 +268,12 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         target_id: S::Id,
         target: Target,
         omit_doc: OmitDoc,
-
         lower_span: impl Copy + Fn(Span) -> Span,
         mut emit_lint: impl FnMut(AttributeLint<S::Id>),
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
         let mut attr_paths: Vec<RefPathParser<'_>> = Vec::new();
+        let mut early_parsed_state = EarlyParsedState::default();
 
         for attr in attrs {
             // If we're only looking for a single attribute, skip all the ones we don't care about.
@@ -288,6 +293,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 continue;
             }
 
+            let attr_span = lower_span(attr.span);
             match &attr.kind {
                 ast::AttrKind::DocComment(comment_kind, symbol) => {
                     if omit_doc == OmitDoc::Skip {
@@ -297,7 +303,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                         style: attr.style,
                         kind: DocFragmentKind::Sugared(*comment_kind),
-                        span: lower_span(attr.span),
+                        span: attr_span,
                         comment: *symbol,
                     }))
                 }
@@ -305,6 +311,15 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     attr_paths.push(PathParser(&n.item.path));
                     let attr_path = AttrPath::from_ast(&n.item.path, lower_span);
 
+                    let args = match &n.item.args {
+                        AttrItemKind::Unparsed(args) => args,
+                        AttrItemKind::Parsed(parsed) => {
+                            early_parsed_state
+                                .accept_early_parsed_attribute(attr_span, lower_span, parsed);
+                            continue;
+                        }
+                    };
+
                     self.check_attribute_safety(
                         &attr_path,
                         lower_span(n.item.span()),
@@ -318,7 +333,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                     if let Some(accepts) = S::parsers().accepters.get(parts.as_slice()) {
                         let Some(args) = ArgParser::from_attr_args(
-                            &n.item.args,
+                            args,
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
@@ -351,7 +366,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                                 style: attr.style,
                                 kind: DocFragmentKind::Raw(nv.value_span),
-                                span: attr.span,
+                                span: attr_span,
                                 comment,
                             }));
                             continue;
@@ -365,7 +380,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                     target_id,
                                     emit_lint: &mut emit_lint,
                                 },
-                                attr_span: lower_span(attr.span),
+                                attr_span,
                                 inner_span: lower_span(n.item.span()),
                                 attr_style: attr.style,
                                 parsed_description: ParsedDescription::Attribute,
@@ -396,17 +411,18 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                         attributes.push(Attribute::Unparsed(Box::new(AttrItem {
                             path: attr_path.clone(),
-                            args: self.lower_attr_args(&n.item.args, lower_span),
+                            args: self
+                                .lower_attr_args(n.item.args.unparsed_ref().unwrap(), lower_span),
                             id: HashIgnoredAttrId { attr_id: attr.id },
                             style: attr.style,
-                            span: lower_span(attr.span),
+                            span: attr_span,
                         })));
                     }
                 }
             }
         }
 
-        let mut parsed_attributes = Vec::new();
+        early_parsed_state.finalize_early_parsed_attributes(&mut attributes);
         for f in &S::parsers().finalizers {
             if let Some(attr) = f(&mut FinalizeContext {
                 shared: SharedContext {
@@ -417,18 +433,16 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 },
                 all_attrs: &attr_paths,
             }) {
-                parsed_attributes.push(Attribute::Parsed(attr));
+                attributes.push(Attribute::Parsed(attr));
             }
         }
 
-        attributes.extend(parsed_attributes);
-
         attributes
     }
 
     /// Returns whether there is a parser for an attribute with this name
     pub fn is_parsed_attribute(path: &[Symbol]) -> bool {
-        Late::parsers().accepters.contains_key(path)
+        Late::parsers().accepters.contains_key(path) || EARLY_PARSED_ATTRIBUTES.contains(&path)
     }
 
     fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
index 411b4dd75e66..349e6c234520 100644
--- a/compiler/rustc_attr_parsing/src/lib.rs
+++ b/compiler/rustc_attr_parsing/src/lib.rs
@@ -99,6 +99,7 @@ mod interface;
 /// like lists or name-value pairs.
 pub mod parser;
 
+mod early_parsed;
 mod safety;
 mod session_diagnostics;
 mod target_checking;
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 474f848038d1..d79579fdf0b7 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -36,7 +36,7 @@ pub type RefPathParser<'p> = PathParser<&'p Path>;
 impl<P: Borrow<Path>> PathParser<P> {
     pub fn get_attribute_path(&self) -> hir::AttrPath {
         AttrPath {
-            segments: self.segments().copied().collect::<Vec<_>>().into_boxed_slice(),
+            segments: self.segments().map(|s| s.name).collect::<Vec<_>>().into_boxed_slice(),
             span: self.span(),
         }
     }
@@ -122,10 +122,10 @@ impl ArgParser {
                 }
 
                 if args.delim != Delimiter::Parenthesis {
-                    psess.dcx().emit_err(MetaBadDelim {
+                    should_emit.emit_err(psess.dcx().create_err(MetaBadDelim {
                         span: args.dspan.entire(),
                         sugg: MetaBadDelimSugg { open: args.dspan.open, close: args.dspan.close },
-                    });
+                    }));
                     return None;
                 }
 
diff --git a/compiler/rustc_attr_parsing/src/safety.rs b/compiler/rustc_attr_parsing/src/safety.rs
index 817785108a1e..9fca57f88025 100644
--- a/compiler/rustc_attr_parsing/src/safety.rs
+++ b/compiler/rustc_attr_parsing/src/safety.rs
@@ -4,7 +4,7 @@ use rustc_hir::AttrPath;
 use rustc_hir::lints::{AttributeLint, AttributeLintKind};
 use rustc_session::lint::LintId;
 use rustc_session::lint::builtin::UNSAFE_ATTR_OUTSIDE_UNSAFE;
-use rustc_span::{Span, sym};
+use rustc_span::Span;
 
 use crate::context::Stage;
 use crate::{AttributeParser, ShouldEmit};
@@ -22,12 +22,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
             return;
         }
 
-        let name = (attr_path.segments.len() == 1).then_some(attr_path.segments[0].name);
-        if let Some(name) = name
-            && [sym::cfg_trace, sym::cfg_attr_trace].contains(&name)
-        {
-            return;
-        }
+        let name = (attr_path.segments.len() == 1).then_some(attr_path.segments[0]);
 
         // FIXME: We should retrieve this information from the attribute parsers instead of from `BUILTIN_ATTRIBUTE_MAP`
         let builtin_attr_info = name.and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name));
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index 88efb910c160..52c2d10f4797 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -15,11 +15,6 @@ use crate::session_diagnostics::InvalidTarget;
 pub(crate) enum AllowedTargets {
     AllowList(&'static [Policy]),
     AllowListWarnRest(&'static [Policy]),
-    /// Special, and not the same as `AllowList(&[Allow(Target::Crate)])`.
-    /// For crate-level attributes we emit a specific set of lints to warn
-    /// people about accidentally not using them on the crate.
-    /// Only use this for attributes that are *exclusively* valid at the crate level.
-    CrateLevel,
 }
 
 pub(crate) enum AllowedResult {
@@ -53,7 +48,6 @@ impl AllowedTargets {
                     AllowedResult::Warn
                 }
             }
-            AllowedTargets::CrateLevel => AllowedResult::Allowed,
         }
     }
 
@@ -61,7 +55,6 @@ impl AllowedTargets {
         match self {
             AllowedTargets::AllowList(list) => list,
             AllowedTargets::AllowListWarnRest(list) => list,
-            AllowedTargets::CrateLevel => ALL_TARGETS,
         }
         .iter()
         .filter_map(|target| match target {
@@ -95,7 +88,10 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         target: Target,
         cx: &mut AcceptContext<'_, 'sess, S>,
     ) {
-        Self::check_type(matches!(allowed_targets, AllowedTargets::CrateLevel), target, cx);
+        if allowed_targets.allowed_targets() == &[Target::Crate] {
+            Self::check_crate_level(target, cx);
+            return;
+        }
 
         match allowed_targets.is_allowed(target) {
             AllowedResult::Allowed => {}
@@ -104,7 +100,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 let (applied, only) = allowed_targets_applied(allowed_targets, target, cx.features);
                 let name = cx.attr_path.clone();
 
-                let lint = if name.segments[0].name == sym::deprecated
+                let lint = if name.segments[0] == sym::deprecated
                     && ![
                         Target::Closure,
                         Target::Expression,
@@ -149,18 +145,10 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         }
     }
 
-    pub(crate) fn check_type(
-        crate_level: bool,
-        target: Target,
-        cx: &mut AcceptContext<'_, 'sess, S>,
-    ) {
-        let is_crate_root = S::id_is_crate_root(cx.target_id);
-
-        if is_crate_root {
-            return;
-        }
-
-        if !crate_level {
+    pub(crate) fn check_crate_level(target: Target, cx: &mut AcceptContext<'_, 'sess, S>) {
+        // For crate-level attributes we emit a specific set of lints to warn
+        // people about accidentally not using them on the crate.
+        if target == Target::Crate {
             return;
         }
 
@@ -310,5 +298,29 @@ pub(crate) const ALL_TARGETS: &'static [Policy] = {
         Allow(Target::Crate),
         Allow(Target::Delegation { mac: false }),
         Allow(Target::Delegation { mac: true }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Const,
+            has_default: false,
+        }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Const,
+            has_default: true,
+        }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Lifetime,
+            has_default: false,
+        }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Lifetime,
+            has_default: true,
+        }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Type,
+            has_default: false,
+        }),
+        Allow(Target::GenericParam {
+            kind: rustc_hir::target::GenericParamKind::Type,
+            has_default: true,
+        }),
     ]
 };
diff --git a/compiler/rustc_attr_parsing/src/validate_attr.rs b/compiler/rustc_attr_parsing/src/validate_attr.rs
index e69ed0eea6b0..f56e85b11061 100644
--- a/compiler/rustc_attr_parsing/src/validate_attr.rs
+++ b/compiler/rustc_attr_parsing/src/validate_attr.rs
@@ -27,7 +27,7 @@ pub fn check_attr(psess: &ParseSess, attr: &Attribute) {
         return;
     }
 
-    let builtin_attr_info = attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
+    let builtin_attr_info = attr.name().and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name));
 
     // Check input tokens for built-in and key-value attributes.
     match builtin_attr_info {
@@ -48,7 +48,7 @@ pub fn check_attr(psess: &ParseSess, attr: &Attribute) {
         }
         _ => {
             let attr_item = attr.get_normal_item();
-            if let AttrArgs::Eq { .. } = attr_item.args {
+            if let AttrArgs::Eq { .. } = attr_item.args.unparsed_ref().unwrap() {
                 // All key-value attributes are restricted to meta-item syntax.
                 match parse_meta(psess, attr) {
                     Ok(_) => {}
@@ -67,7 +67,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
         unsafety: item.unsafety,
         span: attr.span,
         path: item.path.clone(),
-        kind: match &item.args {
+        kind: match &item.args.unparsed_ref().unwrap() {
             AttrArgs::Empty => MetaItemKind::Word,
             AttrArgs::Delimited(DelimArgs { dspan, delim, tokens }) => {
                 check_meta_bad_delim(psess, *dspan, *delim);
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 097416b4f280..e5aad4cdbd06 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1581,12 +1581,18 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                                     .unwrap();
                                 }
                                 (None, None) => {
+                                    // `struct_tail` returns regions which haven't been mapped
+                                    // to nll vars yet so we do it here as `outlives_constraints`
+                                    // expects nll vars.
+                                    let src_lt = self.universal_regions.to_region_vid(src_lt);
+                                    let dst_lt = self.universal_regions.to_region_vid(dst_lt);
+
                                     // The principalless (no non-auto traits) case:
                                     // You can only cast `dyn Send + 'long` to `dyn Send + 'short`.
                                     self.constraints.outlives_constraints.push(
                                         OutlivesConstraint {
-                                            sup: src_lt.as_var(),
-                                            sub: dst_lt.as_var(),
+                                            sup: src_lt,
+                                            sub: dst_lt,
                                             locations: location.to_locations(),
                                             span: location.to_locations().span(self.body),
                                             category: ConstraintCategory::Cast {
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index f0f6f2dcf82c..e4fded0cb01e 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -182,6 +182,8 @@ builtin_macros_expected_other = expected operand, {$is_inline_asm ->
 
 builtin_macros_export_macro_rules = cannot export macro_rules! macros from a `proc-macro` crate type currently
 
+builtin_macros_format_add_missing_colon = add a colon before the format specifier
+
 builtin_macros_format_duplicate_arg = duplicate argument named `{$ident}`
     .label1 = previously here
     .label2 = duplicate argument
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 39abb66df30c..95191b82ff3f 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -358,7 +358,7 @@ mod llvm_enzyme {
         let inline_item = ast::AttrItem {
             unsafety: ast::Safety::Default,
             path: ast::Path::from_ident(Ident::with_dummy_span(sym::inline)),
-            args: ast::AttrArgs::Delimited(never_arg),
+            args: rustc_ast::ast::AttrItemKind::Unparsed(ast::AttrArgs::Delimited(never_arg)),
             tokens: None,
         };
         let inline_never_attr = Box::new(ast::NormalAttr { item: inline_item, tokens: None });
@@ -421,11 +421,13 @@ mod llvm_enzyme {
             }
         };
         // Now update for d_fn
-        rustc_ad_attr.item.args = rustc_ast::AttrArgs::Delimited(rustc_ast::DelimArgs {
-            dspan: DelimSpan::dummy(),
-            delim: rustc_ast::token::Delimiter::Parenthesis,
-            tokens: ts,
-        });
+        rustc_ad_attr.item.args = rustc_ast::ast::AttrItemKind::Unparsed(
+            rustc_ast::AttrArgs::Delimited(rustc_ast::DelimArgs {
+                dspan: DelimSpan::dummy(),
+                delim: rustc_ast::token::Delimiter::Parenthesis,
+                tokens: ts,
+            }),
+        );
 
         let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
         let d_attr = outer_normal_attr(&rustc_ad_attr, new_id, span);
diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs
index 7bc9080ba022..557daa94b98e 100644
--- a/compiler/rustc_builtin_macros/src/cfg.rs
+++ b/compiler/rustc_builtin_macros/src/cfg.rs
@@ -13,7 +13,7 @@ use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpa
 use rustc_hir::AttrPath;
 use rustc_hir::attrs::CfgEntry;
 use rustc_parse::exp;
-use rustc_span::{ErrorGuaranteed, Ident, Span};
+use rustc_span::{ErrorGuaranteed, Span, sym};
 
 use crate::errors;
 
@@ -47,7 +47,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
         span,
         span,
         AttrStyle::Inner,
-        AttrPath { segments: vec![Ident::from_str("cfg")].into_boxed_slice(), span },
+        AttrPath { segments: vec![sym::cfg].into_boxed_slice(), span },
         None,
         ParsedDescription::Macro,
         span,
diff --git a/compiler/rustc_builtin_macros/src/cfg_eval.rs b/compiler/rustc_builtin_macros/src/cfg_eval.rs
index dd770fe5f1a1..bca3f0f10ea3 100644
--- a/compiler/rustc_builtin_macros/src/cfg_eval.rs
+++ b/compiler/rustc_builtin_macros/src/cfg_eval.rs
@@ -47,10 +47,7 @@ fn has_cfg_or_cfg_attr(annotatable: &Annotatable) -> bool {
     impl<'ast> visit::Visitor<'ast> for CfgFinder {
         type Result = ControlFlow<()>;
         fn visit_attribute(&mut self, attr: &'ast Attribute) -> ControlFlow<()> {
-            if attr
-                .ident()
-                .is_some_and(|ident| ident.name == sym::cfg || ident.name == sym::cfg_attr)
-            {
+            if attr.name().is_some_and(|name| name == sym::cfg || name == sym::cfg_attr) {
                 ControlFlow::Break(())
             } else {
                 ControlFlow::Continue(())
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index bb6557802ece..7c84530abbee 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -807,24 +807,29 @@ impl<'a> TraitDef<'a> {
                     rustc_ast::AttrItem {
                         unsafety: Safety::Default,
                         path: rustc_const_unstable,
-                        args: AttrArgs::Delimited(DelimArgs {
-                            dspan: DelimSpan::from_single(self.span),
-                            delim: rustc_ast::token::Delimiter::Parenthesis,
-                            tokens: [
-                                TokenKind::Ident(sym::feature, IdentIsRaw::No),
-                                TokenKind::Eq,
-                                TokenKind::lit(LitKind::Str, sym::derive_const, None),
-                                TokenKind::Comma,
-                                TokenKind::Ident(sym::issue, IdentIsRaw::No),
-                                TokenKind::Eq,
-                                TokenKind::lit(LitKind::Str, sym::derive_const_issue, None),
-                            ]
-                            .into_iter()
-                            .map(|kind| {
-                                TokenTree::Token(Token { kind, span: self.span }, Spacing::Alone)
-                            })
-                            .collect(),
-                        }),
+                        args: rustc_ast::ast::AttrItemKind::Unparsed(AttrArgs::Delimited(
+                            DelimArgs {
+                                dspan: DelimSpan::from_single(self.span),
+                                delim: rustc_ast::token::Delimiter::Parenthesis,
+                                tokens: [
+                                    TokenKind::Ident(sym::feature, IdentIsRaw::No),
+                                    TokenKind::Eq,
+                                    TokenKind::lit(LitKind::Str, sym::derive_const, None),
+                                    TokenKind::Comma,
+                                    TokenKind::Ident(sym::issue, IdentIsRaw::No),
+                                    TokenKind::Eq,
+                                    TokenKind::lit(LitKind::Str, sym::derive_const_issue, None),
+                                ]
+                                .into_iter()
+                                .map(|kind| {
+                                    TokenTree::Token(
+                                        Token { kind, span: self.span },
+                                        Spacing::Alone,
+                                    )
+                                })
+                                .collect(),
+                            },
+                        )),
                         tokens: None,
                     },
                     self.span,
diff --git a/compiler/rustc_builtin_macros/src/eii.rs b/compiler/rustc_builtin_macros/src/eii.rs
index 9049639925dd..0ebd3dc826d4 100644
--- a/compiler/rustc_builtin_macros/src/eii.rs
+++ b/compiler/rustc_builtin_macros/src/eii.rs
@@ -103,19 +103,19 @@ fn eii_(
 
     // span of the declaring item without attributes
     let item_span = func.sig.span;
-    // span of the eii attribute and the item below it, i.e. the full declaration
-    let decl_span = eii_attr_span.to(item_span);
     let foreign_item_name = func.ident;
 
     let mut return_items = Vec::new();
 
     if func.body.is_some() {
         return_items.push(Box::new(generate_default_impl(
+            ecx,
             &func,
             impl_unsafe,
             macro_name,
             eii_attr_span,
             item_span,
+            foreign_item_name,
         )))
     }
 
@@ -133,7 +133,7 @@ fn eii_(
         macro_name,
         foreign_item_name,
         impl_unsafe,
-        decl_span,
+        &attrs_from_decl,
     )));
 
     return_items.into_iter().map(wrap_item).collect()
@@ -187,11 +187,13 @@ fn filter_attrs_for_multiple_eii_attr(
 }
 
 fn generate_default_impl(
+    ecx: &mut ExtCtxt<'_>,
     func: &ast::Fn,
     impl_unsafe: bool,
     macro_name: Ident,
     eii_attr_span: Span,
     item_span: Span,
+    foreign_item_name: Ident,
 ) -> ast::Item {
     // FIXME: re-add some original attrs
     let attrs = ThinVec::new();
@@ -208,6 +210,21 @@ fn generate_default_impl(
         },
         span: eii_attr_span,
         is_default: true,
+        known_eii_macro_resolution: Some(ast::EiiExternTarget {
+            extern_item_path: ast::Path {
+                span: foreign_item_name.span,
+                segments: thin_vec![
+                    ast::PathSegment {
+                        ident: Ident::from_str_and_span("super", foreign_item_name.span,),
+                        id: DUMMY_NODE_ID,
+                        args: None
+                    },
+                    ast::PathSegment { ident: foreign_item_name, id: DUMMY_NODE_ID, args: None },
+                ],
+                tokens: None,
+            },
+            impl_unsafe,
+        }),
     });
 
     ast::Item {
@@ -236,18 +253,66 @@ fn generate_default_impl(
                         stmts: thin_vec![ast::Stmt {
                             id: DUMMY_NODE_ID,
                             kind: ast::StmtKind::Item(Box::new(ast::Item {
-                                attrs,
+                                attrs: ThinVec::new(),
                                 id: DUMMY_NODE_ID,
                                 span: item_span,
                                 vis: ast::Visibility {
-                                    span: eii_attr_span,
+                                    span: item_span,
                                     kind: ast::VisibilityKind::Inherited,
                                     tokens: None
                                 },
-                                kind: ItemKind::Fn(Box::new(default_func)),
+                                kind: ItemKind::Mod(
+                                    ast::Safety::Default,
+                                    Ident::from_str_and_span("dflt", item_span),
+                                    ast::ModKind::Loaded(
+                                        thin_vec![
+                                            Box::new(ast::Item {
+                                                attrs: thin_vec![ecx.attr_nested_word(
+                                                    sym::allow,
+                                                    sym::unused_imports,
+                                                    item_span
+                                                ),],
+                                                id: DUMMY_NODE_ID,
+                                                span: item_span,
+                                                vis: ast::Visibility {
+                                                    span: eii_attr_span,
+                                                    kind: ast::VisibilityKind::Inherited,
+                                                    tokens: None
+                                                },
+                                                kind: ItemKind::Use(ast::UseTree {
+                                                    prefix: ast::Path::from_ident(
+                                                        Ident::from_str_and_span(
+                                                            "super", item_span,
+                                                        )
+                                                    ),
+                                                    kind: ast::UseTreeKind::Glob,
+                                                    span: item_span,
+                                                }),
+                                                tokens: None,
+                                            }),
+                                            Box::new(ast::Item {
+                                                attrs,
+                                                id: DUMMY_NODE_ID,
+                                                span: item_span,
+                                                vis: ast::Visibility {
+                                                    span: eii_attr_span,
+                                                    kind: ast::VisibilityKind::Inherited,
+                                                    tokens: None
+                                                },
+                                                kind: ItemKind::Fn(Box::new(default_func)),
+                                                tokens: None,
+                                            }),
+                                        ],
+                                        ast::Inline::Yes,
+                                        ast::ModSpans {
+                                            inner_span: item_span,
+                                            inject_use_span: item_span,
+                                        }
+                                    )
+                                ),
                                 tokens: None,
                             })),
-                            span: eii_attr_span
+                            span: eii_attr_span,
                         }],
                         id: DUMMY_NODE_ID,
                         rules: ast::BlockCheckMode::Default,
@@ -352,10 +417,14 @@ fn generate_attribute_macro_to_implement(
     macro_name: Ident,
     foreign_item_name: Ident,
     impl_unsafe: bool,
-    decl_span: Span,
+    attrs_from_decl: &[Attribute],
 ) -> ast::Item {
     let mut macro_attrs = ThinVec::new();
 
+    // To avoid e.g. `error: attribute macro has missing stability attribute`
+    // errors for eii's in std.
+    macro_attrs.extend_from_slice(attrs_from_decl);
+
     // #[builtin_macro(eii_shared_macro)]
     macro_attrs.push(ecx.attr_nested_word(sym::rustc_builtin_macro, sym::eii_shared_macro, span));
 
@@ -394,7 +463,6 @@ fn generate_attribute_macro_to_implement(
                 eii_extern_target: Some(ast::EiiExternTarget {
                     extern_item_path: ast::Path::from_ident(foreign_item_name),
                     impl_unsafe,
-                    span: decl_span,
                 }),
             },
         ),
@@ -451,7 +519,7 @@ pub(crate) fn eii_extern_target(
         false
     };
 
-    d.eii_extern_target = Some(EiiExternTarget { extern_item_path, impl_unsafe, span });
+    d.eii_extern_target = Some(EiiExternTarget { extern_item_path, impl_unsafe });
 
     // Return the original item and the new methods.
     vec![item]
@@ -508,6 +576,7 @@ pub(crate) fn eii_shared_macro(
         impl_safety: meta_item.unsafety,
         span,
         is_default,
+        known_eii_macro_resolution: None,
     });
 
     vec![item]
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index ad31eae10f60..e673ad3f8a64 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -643,6 +643,15 @@ pub(crate) enum InvalidFormatStringSuggestion {
         span: Span,
         replacement: String,
     },
+    #[suggestion(
+        builtin_macros_format_add_missing_colon,
+        code = ":?",
+        applicability = "machine-applicable"
+    )]
+    AddMissingColon {
+        #[primary_span]
+        span: Span,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index a0ee7ac19899..12cb2cd00694 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -329,6 +329,10 @@ fn make_format_args(
                     replacement,
                 });
             }
+            parse::Suggestion::AddMissingColon(span) => {
+                let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
+                e.sugg_ = Some(errors::InvalidFormatStringSuggestion::AddMissingColon { span });
+            }
         }
         let guar = ecx.dcx().emit_err(e);
         return ExpandResult::Ready(Err(guar));
diff --git a/compiler/rustc_codegen_cranelift/example/mini_core.rs b/compiler/rustc_codegen_cranelift/example/mini_core.rs
index b522ea193716..301547cadaf7 100644
--- a/compiler/rustc_codegen_cranelift/example/mini_core.rs
+++ b/compiler/rustc_codegen_cranelift/example/mini_core.rs
@@ -744,43 +744,43 @@ unsafe extern "C" {
 pub struct VaList<'a>(&'a mut VaListImpl);
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro stringify($($t:tt)*) {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro file() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro line() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro cfg() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro asm() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro global_asm() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro naked_asm() {
     /* compiler built-in */
 }
diff --git a/compiler/rustc_codegen_cranelift/src/global_asm.rs b/compiler/rustc_codegen_cranelift/src/global_asm.rs
index 8d8cdb14dbc6..97d6cecf6848 100644
--- a/compiler/rustc_codegen_cranelift/src/global_asm.rs
+++ b/compiler/rustc_codegen_cranelift/src/global_asm.rs
@@ -233,7 +233,7 @@ pub(crate) fn compile_global_asm(
                 #![allow(internal_features)]
                 #![no_core]
                 #[rustc_builtin_macro]
-                #[rustc_macro_transparency = "semitransparent"]
+                #[rustc_macro_transparency = "semiopaque"]
                 macro global_asm() { /* compiler built-in */ }
                 global_asm!(r###"
                 "####,
diff --git a/compiler/rustc_codegen_gcc/example/mini_core.rs b/compiler/rustc_codegen_gcc/example/mini_core.rs
index 64a5b431bd07..0aba44a88c5a 100644
--- a/compiler/rustc_codegen_gcc/example/mini_core.rs
+++ b/compiler/rustc_codegen_gcc/example/mini_core.rs
@@ -748,25 +748,25 @@ extern "C" {
 pub struct VaList<'a>(&'a mut VaListImpl);
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro stringify($($t:tt)*) {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro file() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro line() {
     /* compiler built-in */
 }
 
 #[rustc_builtin_macro]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro cfg() {
     /* compiler built-in */
 }
diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl
index a637ae8184b4..85cb7499cca4 100644
--- a/compiler/rustc_codegen_llvm/messages.ftl
+++ b/compiler/rustc_codegen_llvm/messages.ftl
@@ -1,4 +1,7 @@
-codegen_llvm_autodiff_component_unavailable = failed to load our autodiff backend. Did you install it via rustup?
+codegen_llvm_autodiff_component_missing = autodiff backend not found in the sysroot: {$err}
+    .note = it will be distributed via rustup in the future
+
+codegen_llvm_autodiff_component_unavailable = failed to load our autodiff backend: {$err}
 
 codegen_llvm_autodiff_without_enable = using the autodiff feature requires -Z autodiff=Enable
 codegen_llvm_autodiff_without_lto = using the autodiff feature requires setting `lto="fat"` in your Cargo.toml
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index 388118f9b4f1..d00e70638b45 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -93,8 +93,13 @@ pub(crate) fn compile_codegen_unit(
             // They are necessary for correct offload execution. We do this here to simplify the
             // `offload` intrinsic, avoiding the need for tracking whether it's the first
             // intrinsic call or not.
-            let has_host_offload =
-                cx.sess().opts.unstable_opts.offload.iter().any(|o| matches!(o, Offload::Host(_)));
+            let has_host_offload = cx
+                .sess()
+                .opts
+                .unstable_opts
+                .offload
+                .iter()
+                .any(|o| matches!(o, Offload::Host(_) | Offload::Test));
             if has_host_offload && !cx.sess().target.is_like_gpu {
                 cx.offload_globals.replace(Some(OffloadGlobals::declare(&cx)));
             }
diff --git a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
index fba92f996aa6..b8eb4f038216 100644
--- a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
@@ -49,8 +49,9 @@ impl<'ll> OffloadGlobals<'ll> {
         let bin_desc = cx.type_named_struct("struct.__tgt_bin_desc");
         cx.set_struct_body(bin_desc, &tgt_bin_desc_ty, false);
 
-        let register_lib = declare_offload_fn(&cx, "__tgt_register_lib", mapper_fn_ty);
-        let unregister_lib = declare_offload_fn(&cx, "__tgt_unregister_lib", mapper_fn_ty);
+        let reg_lib_decl = cx.type_func(&[cx.type_ptr()], cx.type_void());
+        let register_lib = declare_offload_fn(&cx, "__tgt_register_lib", reg_lib_decl);
+        let unregister_lib = declare_offload_fn(&cx, "__tgt_unregister_lib", reg_lib_decl);
         let init_ty = cx.type_func(&[], cx.type_void());
         let init_rtls = declare_offload_fn(cx, "__tgt_init_all_rtls", init_ty);
 
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 08c53179bc14..2b04f81c267f 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -187,6 +187,10 @@ fn check_and_apply_linkage<'ll, 'tcx>(
         };
         llvm::set_linkage(g1, base::linkage_to_llvm(linkage));
 
+        // Normally this is done in `get_static_inner`, but when as we generate an internal global,
+        // it will apply the dso_local to the internal global instead, so do it here, too.
+        cx.assume_dso_local(g1, true);
+
         // Declare an internal global `extern_with_linkage_foo` which
         // is initialized with the address of `foo`. If `foo` is
         // discarded during linking (for example, if `foo` has weak
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 07b04863af6b..4b2544b7efdf 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -211,6 +211,10 @@ pub(crate) unsafe fn create_module<'ll>(
             // LLVM 22 updated the NVPTX layout to indicate 256-bit vector load/store: https://github.com/llvm/llvm-project/pull/155198
             target_data_layout = target_data_layout.replace("-i256:256", "");
         }
+        if sess.target.arch == Arch::PowerPC64 {
+            // LLVM 22 updated the ABI alignment for double on AIX: https://github.com/llvm/llvm-project/pull/144673
+            target_data_layout = target_data_layout.replace("-f64:32:64", "");
+        }
     }
 
     // Ensure the data-layout values hardcoded remain the defaults.
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index c73140e041b6..bd42cf556966 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -34,7 +34,16 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> {
 
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_autodiff_component_unavailable)]
-pub(crate) struct AutoDiffComponentUnavailable;
+pub(crate) struct AutoDiffComponentUnavailable {
+    pub err: String,
+}
+
+#[derive(Diagnostic)]
+#[diag(codegen_llvm_autodiff_component_missing)]
+#[note]
+pub(crate) struct AutoDiffComponentMissing {
+    pub err: String,
+}
 
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_autodiff_without_lto)]
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 095274744993..438a74e0a091 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -249,8 +249,14 @@ impl CodegenBackend for LlvmCodegenBackend {
 
             use crate::back::lto::enable_autodiff_settings;
             if sess.opts.unstable_opts.autodiff.contains(&AutoDiff::Enable) {
-                if let Err(_) = llvm::EnzymeWrapper::get_or_init(&sess.opts.sysroot) {
-                    sess.dcx().emit_fatal(crate::errors::AutoDiffComponentUnavailable);
+                match llvm::EnzymeWrapper::get_or_init(&sess.opts.sysroot) {
+                    Ok(_) => {}
+                    Err(llvm::EnzymeLibraryError::NotFound { err }) => {
+                        sess.dcx().emit_fatal(crate::errors::AutoDiffComponentMissing { err });
+                    }
+                    Err(llvm::EnzymeLibraryError::LoadFailed { err }) => {
+                        sess.dcx().emit_fatal(crate::errors::AutoDiffComponentUnavailable { err });
+                    }
                 }
                 enable_autodiff_settings(&sess.opts.unstable_opts.autodiff);
             }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index b11310b970d0..67fbc0f53adc 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -153,7 +153,7 @@ pub(crate) mod Enzyme_AD {
     fn load_ptr_by_symbol_mut_void(
         lib: &libloading::Library,
         bytes: &[u8],
-    ) -> Result<*mut c_void, Box<dyn std::error::Error>> {
+    ) -> Result<*mut c_void, libloading::Error> {
         unsafe {
             let s: libloading::Symbol<'_, *mut c_void> = lib.get(bytes)?;
             // libloading = 0.9.0: try_as_raw_ptr always succeeds and returns Some
@@ -192,15 +192,27 @@ pub(crate) mod Enzyme_AD {
 
     static ENZYME_INSTANCE: OnceLock<Mutex<EnzymeWrapper>> = OnceLock::new();
 
+    #[derive(Debug)]
+    pub(crate) enum EnzymeLibraryError {
+        NotFound { err: String },
+        LoadFailed { err: String },
+    }
+
+    impl From<libloading::Error> for EnzymeLibraryError {
+        fn from(err: libloading::Error) -> Self {
+            Self::LoadFailed { err: format!("{err:?}") }
+        }
+    }
+
     impl EnzymeWrapper {
         /// Initialize EnzymeWrapper with the given sysroot if not already initialized.
         /// Safe to call multiple times - subsequent calls are no-ops due to OnceLock.
         pub(crate) fn get_or_init(
             sysroot: &rustc_session::config::Sysroot,
-        ) -> Result<MutexGuard<'static, Self>, Box<dyn std::error::Error>> {
+        ) -> Result<MutexGuard<'static, Self>, EnzymeLibraryError> {
             let mtx: &'static Mutex<EnzymeWrapper> = ENZYME_INSTANCE.get_or_try_init(|| {
                 let w = Self::call_dynamic(sysroot)?;
-                Ok::<_, Box<dyn std::error::Error>>(Mutex::new(w))
+                Ok::<_, EnzymeLibraryError>(Mutex::new(w))
             })?;
 
             Ok(mtx.lock().unwrap())
@@ -351,7 +363,7 @@ pub(crate) mod Enzyme_AD {
         #[allow(non_snake_case)]
         fn call_dynamic(
             sysroot: &rustc_session::config::Sysroot,
-        ) -> Result<Self, Box<dyn std::error::Error>> {
+        ) -> Result<Self, EnzymeLibraryError> {
             let enzyme_path = Self::get_enzyme_path(sysroot)?;
             let lib = unsafe { libloading::Library::new(enzyme_path)? };
 
@@ -416,7 +428,7 @@ pub(crate) mod Enzyme_AD {
             })
         }
 
-        fn get_enzyme_path(sysroot: &Sysroot) -> Result<String, String> {
+        fn get_enzyme_path(sysroot: &Sysroot) -> Result<String, EnzymeLibraryError> {
             let llvm_version_major = unsafe { LLVMRustVersionMajor() };
 
             let path_buf = sysroot
@@ -434,15 +446,19 @@ pub(crate) mod Enzyme_AD {
                         .map(|p| p.join("lib").display().to_string())
                         .collect::<Vec<String>>()
                         .join("\n* ");
-                    format!(
-                        "failed to find a `libEnzyme-{llvm_version_major}` folder \
+                    EnzymeLibraryError::NotFound {
+                        err: format!(
+                            "failed to find a `libEnzyme-{llvm_version_major}` folder \
                     in the sysroot candidates:\n* {candidates}"
-                    )
+                        ),
+                    }
                 })?;
 
             Ok(path_buf
                 .to_str()
-                .ok_or_else(|| format!("invalid UTF-8 in path: {}", path_buf.display()))?
+                .ok_or_else(|| EnzymeLibraryError::LoadFailed {
+                    err: format!("invalid UTF-8 in path: {}", path_buf.display()),
+                })?
                 .to_string())
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 9b08f4e9869c..63f820dc2918 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -379,19 +379,19 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         {
             false
         }
-        // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
-        (Arch::Arm64EC, _) => false,
+        // Unsupported <https://github.com/llvm/llvm-project/issues/94434> (fixed in llvm22)
+        (Arch::Arm64EC, _) if major < 22 => false,
         // Selection failure <https://github.com/llvm/llvm-project/issues/50374> (fixed in llvm21)
         (Arch::S390x, _) if major < 21 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
         (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
         // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
-        (Arch::CSky, _) => false,
+        (Arch::CSky, _) if major < 22 => false, // (fixed in llvm22)
         (Arch::Hexagon, _) if major < 21 => false, // (fixed in llvm21)
         (Arch::LoongArch32 | Arch::LoongArch64, _) if major < 21 => false, // (fixed in llvm21)
-        (Arch::PowerPC | Arch::PowerPC64, _) => false,
-        (Arch::Sparc | Arch::Sparc64, _) => false,
-        (Arch::Wasm32 | Arch::Wasm64, _) => false,
+        (Arch::PowerPC | Arch::PowerPC64, _) if major < 22 => false, // (fixed in llvm22)
+        (Arch::Sparc | Arch::Sparc64, _) if major < 22 => false, // (fixed in llvm22)
+        (Arch::Wasm32 | Arch::Wasm64, _) if major < 22 => false, // (fixed in llvm22)
         // `f16` support only requires that symbols converting to and from `f32` are available. We
         // provide these in `compiler-builtins`, so `f16` should be available on all platforms that
         // do not have other ABI issues or LLVM crashes.
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
index 41cf92390b0d..1878f4043ee8 100644
--- a/compiler/rustc_codegen_llvm/src/mono_item.rs
+++ b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -10,7 +10,6 @@ use rustc_middle::mir::mono::Visibility;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt};
 use rustc_session::config::CrateType;
-use rustc_span::Symbol;
 use rustc_target::spec::{Arch, RelocModel};
 use tracing::debug;
 
@@ -92,17 +91,19 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
 }
 
 impl CodegenCx<'_, '_> {
-    fn add_aliases(&self, aliasee: &llvm::Value, aliases: &[(Symbol, Linkage, Visibility)]) {
+    fn add_aliases(&self, aliasee: &llvm::Value, aliases: &[(DefId, Linkage, Visibility)]) {
         let ty = self.get_type_of_global(aliasee);
 
         for (alias, linkage, visibility) in aliases {
+            let symbol_name = self.tcx.symbol_name(Instance::mono(self.tcx, *alias));
+
             tracing::debug!("ALIAS: {alias:?} {linkage:?} {visibility:?}");
             let lldecl = llvm::add_alias(
                 self.llmod,
                 ty,
                 AddressSpace::ZERO,
                 aliasee,
-                &CString::new(alias.as_str()).unwrap(),
+                &CString::new(symbol_name.name).unwrap(),
             );
 
             llvm::set_visibility(lldecl, base::visibility_to_llvm(*visibility));
@@ -110,7 +111,7 @@ impl CodegenCx<'_, '_> {
         }
     }
 
-    /// Whether a definition or declaration can be assumed to be local to a group of
+    /// A definition or declaration can be assumed to be local to a group of
     /// libraries that form a single DSO or executable.
     /// Marks the local as DSO if so.
     pub(crate) fn assume_dso_local(&self, llval: &llvm::Value, is_declaration: bool) -> bool {
@@ -152,7 +153,7 @@ impl CodegenCx<'_, '_> {
             return false;
         }
 
-        // With pie relocation model calls of functions defined in the translation
+        // With pie relocation model, calls of functions defined in the translation
         // unit can use copy relocations.
         if self.tcx.sess.relocation_model() == RelocModel::Pie && !is_declaration {
             return true;
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index b23415a732cc..688f461e7478 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -1,12 +1,13 @@
-use rustc_abi::{Align, BackendRepr, Endian, HasDataLayout, Primitive, Size, TyAndLayout};
+use rustc_abi::{Align, BackendRepr, Endian, HasDataLayout, Primitive, Size};
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::IntPredicate;
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::traits::{
     BaseTypeCodegenMethods, BuilderMethods, ConstCodegenMethods, LayoutTypeCodegenMethods,
 };
+use rustc_middle::bug;
 use rustc_middle::ty::Ty;
-use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
+use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
 use rustc_target::spec::{Abi, Arch, Env};
 
 use crate::builder::Builder;
@@ -82,6 +83,7 @@ enum PassMode {
 enum SlotSize {
     Bytes8 = 8,
     Bytes4 = 4,
+    Bytes1 = 1,
 }
 
 enum AllowHigherAlign {
@@ -728,7 +730,7 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
 fn copy_to_temporary_if_more_aligned<'ll, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     reg_addr: &'ll Value,
-    layout: TyAndLayout<'tcx, Ty<'tcx>>,
+    layout: TyAndLayout<'tcx>,
     src_align: Align,
 ) -> &'ll Value {
     if layout.layout.align.abi > src_align {
@@ -751,7 +753,7 @@ fn copy_to_temporary_if_more_aligned<'ll, 'tcx>(
 fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     va_list_addr: &'ll Value,
-    layout: TyAndLayout<'tcx, Ty<'tcx>>,
+    layout: TyAndLayout<'tcx>,
 ) -> &'ll Value {
     let dl = bx.cx.data_layout();
     let ptr_align_abi = dl.data_layout().pointer_align().abi;
@@ -1003,15 +1005,17 @@ fn emit_xtensa_va_arg<'ll, 'tcx>(
     return bx.load(layout.llvm_type(bx), value_ptr, layout.align.abi);
 }
 
+/// Determine the va_arg implementation to use. The LLVM va_arg instruction
+/// is lacking in some instances, so we should only use it as a fallback.
 pub(super) fn emit_va_arg<'ll, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     addr: OperandRef<'tcx, &'ll Value>,
     target_ty: Ty<'tcx>,
 ) -> &'ll Value {
-    // Determine the va_arg implementation to use. The LLVM va_arg instruction
-    // is lacking in some instances, so we should only use it as a fallback.
-    let target = &bx.cx.tcx.sess.target;
+    let layout = bx.cx.layout_of(target_ty);
+    let target_ty_size = layout.layout.size().bytes();
 
+    let target = &bx.cx.tcx.sess.target;
     match target.arch {
         Arch::X86 => emit_ptr_va_arg(
             bx,
@@ -1069,23 +1073,79 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             AllowHigherAlign::Yes,
             ForceRightAdjust::No,
         ),
+        Arch::LoongArch32 => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            if target_ty_size > 2 * 4 { PassMode::Indirect } else { PassMode::Direct },
+            SlotSize::Bytes4,
+            AllowHigherAlign::Yes,
+            ForceRightAdjust::No,
+        ),
+        Arch::LoongArch64 => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            if target_ty_size > 2 * 8 { PassMode::Indirect } else { PassMode::Direct },
+            SlotSize::Bytes8,
+            AllowHigherAlign::Yes,
+            ForceRightAdjust::No,
+        ),
+        Arch::AmdGpu => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            PassMode::Direct,
+            SlotSize::Bytes4,
+            AllowHigherAlign::No,
+            ForceRightAdjust::No,
+        ),
+        Arch::Nvptx64 => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            PassMode::Direct,
+            SlotSize::Bytes1,
+            AllowHigherAlign::Yes,
+            ForceRightAdjust::No,
+        ),
+        Arch::Wasm32 => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            if layout.is_aggregate() || layout.is_zst() || layout.is_1zst() {
+                PassMode::Indirect
+            } else {
+                PassMode::Direct
+            },
+            SlotSize::Bytes4,
+            AllowHigherAlign::Yes,
+            ForceRightAdjust::No,
+        ),
+        Arch::Wasm64 => bug!("c-variadic functions are not fully implemented for wasm64"),
+        Arch::CSky => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            PassMode::Direct,
+            SlotSize::Bytes4,
+            AllowHigherAlign::Yes,
+            ForceRightAdjust::No,
+        ),
         // Windows x86_64
-        Arch::X86_64 if target.is_like_windows => {
-            let target_ty_size = bx.cx.size_of(target_ty).bytes();
-            emit_ptr_va_arg(
-                bx,
-                addr,
-                target_ty,
-                if target_ty_size > 8 || !target_ty_size.is_power_of_two() {
-                    PassMode::Indirect
-                } else {
-                    PassMode::Direct
-                },
-                SlotSize::Bytes8,
-                AllowHigherAlign::No,
-                ForceRightAdjust::No,
-            )
-        }
+        Arch::X86_64 if target.is_like_windows => emit_ptr_va_arg(
+            bx,
+            addr,
+            target_ty,
+            if target_ty_size > 8 || !target_ty_size.is_power_of_two() {
+                PassMode::Indirect
+            } else {
+                PassMode::Direct
+            },
+            SlotSize::Bytes8,
+            AllowHigherAlign::No,
+            ForceRightAdjust::No,
+        ),
         // This includes `target.is_like_darwin`, which on x86_64 targets is like sysv64.
         Arch::X86_64 => emit_x86_64_sysv64_va_arg(bx, addr, target_ty),
         Arch::Xtensa => emit_xtensa_va_arg(bx, addr, target_ty),
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 1d87dc5da8d2..4875f309cca5 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -10,6 +10,8 @@ codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$erro
 
 codegen_ssa_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `{$shorthand}` to stdout, but stdout is a tty
 
+codegen_ssa_bpf_staticlib_not_supported = linking static libraries is not supported for BPF
+
 codegen_ssa_cgu_not_recorded =
     CGU-reuse for `{$cgu_user_name}` is (mangled: `{$cgu_name}`) was not recorded
 
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index 93f6cb3b87e6..3f12e857391b 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -22,10 +22,11 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use crate::common;
-// Re-exporting for rustc_codegen_llvm::back::archive
-pub use crate::errors::{ArchiveBuildFailure, ExtractBundledLibsError, UnknownArchiveKind};
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
+pub use crate::errors::ExtractBundledLibsError;
 use crate::errors::{
-    DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary, ErrorWritingDEFFile,
+    ArchiveBuildFailure, DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary,
+    ErrorWritingDEFFile, UnknownArchiveKind,
 };
 
 /// An item to be included in an import library.
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index c73e950bed40..637d54dd06c6 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -839,6 +839,11 @@ impl<'a> Linker for GccLinker<'a> {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
             self.link_arg(path);
+        } else if self.sess.target.is_like_wasm {
+            self.link_arg("--no-export-dynamic");
+            for (sym, _) in symbols {
+                self.link_arg("--export").link_arg(sym);
+            }
         } else if crate_type == CrateType::Executable && !self.sess.target.is_like_solaris {
             let res: io::Result<()> = try {
                 let mut f = File::create_buffered(&path)?;
@@ -853,11 +858,6 @@ impl<'a> Linker for GccLinker<'a> {
                 self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
             }
             self.link_arg("--dynamic-list").link_arg(path);
-        } else if self.sess.target.is_like_wasm {
-            self.link_arg("--no-export-dynamic");
-            for (sym, _) in symbols {
-                self.link_arg("--export").link_arg(sym);
-            }
         } else {
             // Write an LD version script
             let res: io::Result<()> = try {
@@ -2075,7 +2075,7 @@ impl<'a> Linker for BpfLinker<'a> {
     }
 
     fn link_staticlib_by_name(&mut self, _name: &str, _verbatim: bool, _whole_archive: bool) {
-        panic!("staticlibs not supported")
+        self.sess.dcx().emit_fatal(errors::BpfStaticlibNotSupported)
     }
 
     fn link_staticlib_by_path(&mut self, path: &Path, _whole_archive: bool) {
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 6dff79374f20..8a2a6823fdf4 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -330,14 +330,12 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
             let mut e_flags: u32 = 0x0;
 
             // Check if compression is enabled
-            // `unstable_target_features` is used here because "zca" is gated behind riscv_target_feature.
-            if sess.unstable_target_features.contains(&sym::zca) {
+            if sess.target_features.contains(&sym::zca) {
                 e_flags |= elf::EF_RISCV_RVC;
             }
 
             // Check if RVTSO is enabled
-            // `unstable_target_features` is used here because "ztso" is gated behind riscv_target_feature.
-            if sess.unstable_target_features.contains(&sym::ztso) {
+            if sess.target_features.contains(&sym::ztso) {
                 e_flags |= elf::EF_RISCV_TSO;
             }
 
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 8ab0b367f08a..c8aa7c04585c 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -6,7 +6,8 @@ use std::time::{Duration, Instant};
 use itertools::Itertools;
 use rustc_abi::FIRST_VARIANT;
 use rustc_ast::expand::allocator::{
-    ALLOC_ERROR_HANDLER, ALLOCATOR_METHODS, AllocatorKind, AllocatorMethod, AllocatorTy,
+    ALLOC_ERROR_HANDLER, ALLOCATOR_METHODS, AllocatorKind, AllocatorMethod, AllocatorMethodInput,
+    AllocatorTy,
 };
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
@@ -671,7 +672,7 @@ pub fn allocator_shim_contents(tcx: TyCtxt<'_>, kind: AllocatorKind) -> Vec<Allo
         methods.push(AllocatorMethod {
             name: ALLOC_ERROR_HANDLER,
             special: None,
-            inputs: &[],
+            inputs: &[AllocatorMethodInput { name: "layout", ty: AllocatorTy::Layout }],
             output: AllocatorTy::Never,
         });
     }
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 6056b1582e42..7dda824e2b18 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -3,7 +3,9 @@ use std::str::FromStr;
 use rustc_abi::{Align, ExternAbi};
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
 use rustc_ast::{LitKind, MetaItem, MetaItemInner, attr};
-use rustc_hir::attrs::{AttributeKind, InlineAttr, Linkage, RtsanSetting, UsedBy};
+use rustc_hir::attrs::{
+    AttributeKind, EiiImplResolution, InlineAttr, Linkage, RtsanSetting, UsedBy,
+};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{self as hir, Attribute, LangItem, find_attr, lang_items};
@@ -13,10 +15,10 @@ use rustc_middle::middle::codegen_fn_attrs::{
 use rustc_middle::mir::mono::Visibility;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{self as ty, Instance, TyCtxt};
+use rustc_middle::ty::{self as ty, TyCtxt};
 use rustc_session::lint;
 use rustc_session::parse::feature_err;
-use rustc_span::{Ident, Span, Symbol, sym};
+use rustc_span::{Span, sym};
 use rustc_target::spec::Os;
 
 use crate::errors;
@@ -285,13 +287,23 @@ fn process_builtin_attrs(
                 }
                 AttributeKind::EiiImpls(impls) => {
                     for i in impls {
-                        let extern_item = find_attr!(
-                            tcx.get_all_attrs(i.eii_macro),
-                            AttributeKind::EiiExternTarget(target) => target.eii_extern_target
-                        )
-                        .expect("eii should have declaration macro with extern target attribute");
-
-                        let symbol_name = tcx.symbol_name(Instance::mono(tcx, extern_item));
+                        let extern_item = match i.resolution {
+                            EiiImplResolution::Macro(def_id) => {
+                                let Some(extern_item) = find_attr!(
+                                    tcx.get_all_attrs(def_id),
+                                    AttributeKind::EiiExternTarget(target) => target.eii_extern_target
+                                ) else {
+                                    tcx.dcx().span_delayed_bug(
+                                        i.span,
+                                        "resolved to something that's not an EII",
+                                    );
+                                    continue;
+                                };
+                                extern_item
+                            }
+                            EiiImplResolution::Known(decl) => decl.eii_extern_target,
+                            EiiImplResolution::Error(_eg) => continue,
+                        };
 
                         // this is to prevent a bug where a single crate defines both the default and explicit implementation
                         // for an EII. In that case, both of them may be part of the same final object file. I'm not 100% sure
@@ -304,13 +316,13 @@ fn process_builtin_attrs(
                             // iterate over all implementations *in the current crate*
                             // (this is ok since we generate codegen fn attrs in the local crate)
                             // if any of them is *not default* then don't emit the alias.
-                            && tcx.externally_implementable_items(LOCAL_CRATE).get(&i.eii_macro).expect("at least one").1.iter().any(|(_, imp)| !imp.is_default)
+                            && tcx.externally_implementable_items(LOCAL_CRATE).get(&extern_item).expect("at least one").1.iter().any(|(_, imp)| !imp.is_default)
                         {
                             continue;
                         }
 
                         codegen_fn_attrs.foreign_item_symbol_aliases.push((
-                            Symbol::intern(symbol_name.name),
+                            extern_item,
                             if i.is_default { Linkage::LinkOnceAny } else { Linkage::External },
                             Visibility::Default,
                         ));
@@ -327,7 +339,7 @@ fn process_builtin_attrs(
             }
         }
 
-        let Some(Ident { name, .. }) = attr.ident() else {
+        let Some(name) = attr.name() else {
             continue;
         };
 
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 18279a4d05fe..02476a332252 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -260,7 +260,7 @@ fn push_debuginfo_type_name<'tcx>(
                     .map(|bound| {
                         let ExistentialProjection { def_id: item_def_id, term, .. } =
                             tcx.instantiate_bound_regions_with_erased(bound);
-                        // FIXME(associated_const_equality): allow for consts here
+                        // FIXME(mgca): allow for consts here
                         (item_def_id, term.expect_type())
                     })
                     .collect();
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 95306c140895..39727685aec1 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -661,7 +661,7 @@ pub(crate) struct RlibArchiveBuildFailure {
 }
 
 #[derive(Diagnostic)]
-// Public for rustc_codegen_llvm::back::archive
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub enum ExtractBundledLibsError<'a> {
     #[diag(codegen_ssa_extract_bundled_libs_open_file)]
     OpenFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
@@ -700,19 +700,21 @@ pub(crate) struct UnsupportedLinkSelfContained;
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_archive_build_failure)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct ArchiveBuildFailure {
+pub(crate) struct ArchiveBuildFailure {
     pub path: PathBuf,
     pub error: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_unknown_archive_kind)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct UnknownArchiveKind<'a> {
+pub(crate) struct UnknownArchiveKind<'a> {
     pub kind: &'a str,
 }
 
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_bpf_staticlib_not_supported)]
+pub(crate) struct BpfStaticlibNotSupported;
+
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_multiple_main_functions)]
 #[help]
diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
index 4a47799b2bdc..4bbb7470debe 100644
--- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
@@ -181,7 +181,8 @@ fn prefix_and_suffix<'tcx>(
                 }
             }
             Linkage::Internal => {
-                // write nothing
+                // LTO can fail when internal linkage is used.
+                emit_fatal("naked functions may not have internal linkage")
             }
             Linkage::Common => emit_fatal("Functions may not have common linkage"),
             Linkage::AvailableExternally => {
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index 113e0d66c48a..02615e3bbc18 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -6,9 +6,7 @@
 // having basically only two use-cases that act in different ways.
 
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::DefKind;
-use rustc_hir::{LangItem, find_attr};
+use rustc_hir::LangItem;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, AdtDef, Ty};
@@ -366,14 +364,10 @@ where
         // check performed after the promotion. Verify that with an assertion.
         assert!(promoted.is_none() || Q::ALLOW_PROMOTED);
 
-        // Avoid looking at attrs of anon consts as that will ICE
-        let is_type_const_item =
-            matches!(cx.tcx.def_kind(def), DefKind::Const | DefKind::AssocConst)
-                && find_attr!(cx.tcx.get_all_attrs(def), AttributeKind::TypeConst(_));
-
         // Don't peak inside trait associated constants, also `#[type_const] const` items
         // don't have bodies so there's nothing to look at
-        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !is_type_const_item {
+        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !cx.tcx.is_type_const(def)
+        {
             let qualifs = cx.tcx.at(constant.span).mir_const_qualif(def);
 
             if !Q::in_qualifs(&qualifs) {
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 7538130e9d92..719187b99012 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -8,7 +8,7 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, CRATE_HIR_ID, LangItem};
 use rustc_middle::mir::AssertMessage;
-use rustc_middle::mir::interpret::ReportedErrorInfo;
+use rustc_middle::mir::interpret::{Pointer, ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout, ValidityRequirement};
 use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -22,7 +22,7 @@ use crate::errors::{LongRunning, LongRunningWarn};
 use crate::fluent_generated as fluent;
 use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
-    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
+    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, RangeSet, Scalar,
     compile_time_machine, err_inval, interp_ok, throw_exhaust, throw_inval, throw_ub,
     throw_ub_custom, throw_unsup, throw_unsup_format,
 };
@@ -586,6 +586,11 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 }
             }
 
+            sym::type_of => {
+                let ty = ecx.read_type_id(&args[0])?;
+                ecx.write_type_info(ty, dest)?;
+            }
+
             _ => {
                 // We haven't handled the intrinsic, let's see if we can use a fallback body.
                 if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
diff --git a/compiler/rustc_const_eval/src/const_eval/mod.rs b/compiler/rustc_const_eval/src/const_eval/mod.rs
index 624ca1dd2da0..e70488b81c4c 100644
--- a/compiler/rustc_const_eval/src/const_eval/mod.rs
+++ b/compiler/rustc_const_eval/src/const_eval/mod.rs
@@ -13,6 +13,7 @@ mod error;
 mod eval_queries;
 mod fn_queries;
 mod machine;
+mod type_info;
 mod valtrees;
 
 pub use self::dummy_machine::*;
diff --git a/compiler/rustc_const_eval/src/const_eval/type_info.rs b/compiler/rustc_const_eval/src/const_eval/type_info.rs
new file mode 100644
index 000000000000..f932b198b426
--- /dev/null
+++ b/compiler/rustc_const_eval/src/const_eval/type_info.rs
@@ -0,0 +1,175 @@
+use rustc_abi::FieldIdx;
+use rustc_hir::LangItem;
+use rustc_middle::mir::interpret::CtfeProvenance;
+use rustc_middle::span_bug;
+use rustc_middle::ty::layout::TyAndLayout;
+use rustc_middle::ty::{self, ScalarInt, Ty};
+use rustc_span::{Symbol, sym};
+
+use crate::const_eval::CompileTimeMachine;
+use crate::interpret::{
+    Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Writeable, interp_ok,
+};
+
+impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
+    /// Writes a `core::mem::type_info::TypeInfo` for a given type, `ty` to the given place.
+    pub(crate) fn write_type_info(
+        &mut self,
+        ty: Ty<'tcx>,
+        dest: &impl Writeable<'tcx, CtfeProvenance>,
+    ) -> InterpResult<'tcx> {
+        let ty_struct = self.tcx.require_lang_item(LangItem::Type, self.tcx.span);
+        let ty_struct = self.tcx.type_of(ty_struct).no_bound_vars().unwrap();
+        assert_eq!(ty_struct, dest.layout().ty);
+        let ty_struct = ty_struct.ty_adt_def().unwrap().non_enum_variant();
+        // Fill all fields of the `TypeInfo` struct.
+        for (idx, field) in ty_struct.fields.iter_enumerated() {
+            let field_dest = self.project_field(dest, idx)?;
+            let downcast = |name: Symbol| {
+                let variants = field_dest.layout().ty.ty_adt_def().unwrap().variants();
+                let variant_id = variants
+                    .iter_enumerated()
+                    .find(|(_idx, var)| var.name == name)
+                    .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
+                    .0;
+
+                interp_ok((variant_id, self.project_downcast(&field_dest, variant_id)?))
+            };
+            match field.name {
+                sym::kind => {
+                    let variant_index = match ty.kind() {
+                        ty::Tuple(fields) => {
+                            let (variant, variant_place) = downcast(sym::Tuple)?;
+                            // project to the single tuple variant field of `type_info::Tuple` struct type
+                            let tuple_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            assert_eq!(
+                                1,
+                                tuple_place
+                                    .layout()
+                                    .ty
+                                    .ty_adt_def()
+                                    .unwrap()
+                                    .non_enum_variant()
+                                    .fields
+                                    .len()
+                            );
+                            self.write_tuple_fields(tuple_place, fields, ty)?;
+                            variant
+                        }
+                        // For now just merge all primitives into one `Leaf` variant with no data
+                        ty::Uint(_) | ty::Int(_) | ty::Float(_) | ty::Char | ty::Bool => {
+                            downcast(sym::Leaf)?.0
+                        }
+                        ty::Adt(_, _)
+                        | ty::Foreign(_)
+                        | ty::Str
+                        | ty::Array(_, _)
+                        | ty::Pat(_, _)
+                        | ty::Slice(_)
+                        | ty::RawPtr(..)
+                        | ty::Ref(..)
+                        | ty::FnDef(..)
+                        | ty::FnPtr(..)
+                        | ty::UnsafeBinder(..)
+                        | ty::Dynamic(..)
+                        | ty::Closure(..)
+                        | ty::CoroutineClosure(..)
+                        | ty::Coroutine(..)
+                        | ty::CoroutineWitness(..)
+                        | ty::Never
+                        | ty::Alias(..)
+                        | ty::Param(_)
+                        | ty::Bound(..)
+                        | ty::Placeholder(_)
+                        | ty::Infer(..)
+                        | ty::Error(_) => downcast(sym::Other)?.0,
+                    };
+                    self.write_discriminant(variant_index, &field_dest)?
+                }
+                sym::size => {
+                    let layout = self.layout_of(ty)?;
+                    let variant_index = if layout.is_sized() {
+                        let (variant, variant_place) = downcast(sym::Some)?;
+                        let size_field_place =
+                            self.project_field(&variant_place, FieldIdx::ZERO)?;
+                        self.write_scalar(
+                            ScalarInt::try_from_target_usize(layout.size.bytes(), self.tcx.tcx)
+                                .unwrap(),
+                            &size_field_place,
+                        )?;
+                        variant
+                    } else {
+                        downcast(sym::None)?.0
+                    };
+                    self.write_discriminant(variant_index, &field_dest)?;
+                }
+                other => span_bug!(self.tcx.span, "unknown `Type` field {other}"),
+            }
+        }
+
+        interp_ok(())
+    }
+
+    pub(crate) fn write_tuple_fields(
+        &mut self,
+        tuple_place: impl Writeable<'tcx, CtfeProvenance>,
+        fields: &[Ty<'tcx>],
+        tuple_ty: Ty<'tcx>,
+    ) -> InterpResult<'tcx> {
+        // project into the `type_info::Tuple::fields` field
+        let fields_slice_place = self.project_field(&tuple_place, FieldIdx::ZERO)?;
+        // get the `type_info::Field` type from `fields: &[Field]`
+        let field_type = fields_slice_place
+            .layout()
+            .ty
+            .builtin_deref(false)
+            .unwrap()
+            .sequence_element_type(self.tcx.tcx);
+        // Create an array with as many elements as the number of fields in the inspected tuple
+        let fields_layout =
+            self.layout_of(Ty::new_array(self.tcx.tcx, field_type, fields.len() as u64))?;
+        let fields_place = self.allocate(fields_layout, MemoryKind::Stack)?;
+        let mut fields_places = self.project_array_fields(&fields_place)?;
+
+        let tuple_layout = self.layout_of(tuple_ty)?;
+
+        while let Some((i, place)) = fields_places.next(self)? {
+            let field_ty = fields[i as usize];
+            self.write_field(field_ty, place, tuple_layout, i)?;
+        }
+
+        let fields_place = fields_place.map_provenance(CtfeProvenance::as_immutable);
+
+        let ptr = Immediate::new_slice(fields_place.ptr(), fields.len() as u64, self);
+
+        self.write_immediate(ptr, &fields_slice_place)
+    }
+
+    fn write_field(
+        &mut self,
+        field_ty: Ty<'tcx>,
+        place: MPlaceTy<'tcx>,
+        layout: TyAndLayout<'tcx>,
+        idx: u64,
+    ) -> InterpResult<'tcx> {
+        for (field_idx, field_ty_field) in
+            place.layout.ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&place, field_idx)?;
+            match field_ty_field.name {
+                sym::ty => self.write_type_id(field_ty, &field_place)?,
+                sym::offset => {
+                    let offset = layout.fields.offset(idx as usize);
+                    self.write_scalar(
+                        ScalarInt::try_from_target_usize(offset.bytes(), self.tcx.tcx).unwrap(),
+                        &field_place,
+                    )?;
+                }
+                other => {
+                    span_bug!(self.tcx.def_span(field_ty_field.did), "unimplemented field {other}")
+                }
+            }
+        }
+        interp_ok(())
+    }
+}
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index d70d157d8808..94832c0c2577 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -27,6 +27,7 @@ use super::{
     throw_ub_custom, throw_ub_format,
 };
 use crate::fluent_generated as fluent;
+use crate::interpret::Writeable;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum MulAddType {
@@ -68,10 +69,10 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> (AllocId
 }
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// Generates a value of `TypeId` for `ty` in-place.
-    fn write_type_id(
+    pub(crate) fn write_type_id(
         &mut self,
         ty: Ty<'tcx>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
+        dest: &impl Writeable<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx, ()> {
         let tcx = self.tcx;
         let type_id_hash = tcx.type_id_hash(ty).as_u128();
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 492c845df171..28f711f362bd 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -7,8 +7,8 @@ use rustc_ast::tokenstream::{
     AttrTokenStream, AttrTokenTree, LazyAttrTokenStream, Spacing, TokenTree,
 };
 use rustc_ast::{
-    self as ast, AttrKind, AttrStyle, Attribute, HasAttrs, HasTokens, MetaItem, MetaItemInner,
-    NodeId, NormalAttr,
+    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, EarlyParsedAttribute, HasAttrs,
+    HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
 };
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
@@ -288,7 +288,9 @@ impl<'a> StripUnconfigured<'a> {
     pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
         // A trace attribute left in AST in place of the original `cfg_attr` attribute.
         // It can later be used by lints or other diagnostics.
-        let trace_attr = attr_into_trace(cfg_attr.clone(), sym::cfg_attr_trace);
+        let mut trace_attr = cfg_attr.clone();
+        trace_attr.replace_args(AttrItemKind::Parsed(EarlyParsedAttribute::CfgAttrTrace));
+        let trace_attr = attr_into_trace(trace_attr, sym::cfg_attr_trace);
 
         let Some((cfg_predicate, expanded_attrs)) =
             rustc_attr_parsing::parse_cfg_attr(cfg_attr, &self.sess, self.features)
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 6422779e13c9..c130d9f59940 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -7,12 +7,16 @@ use rustc_ast::mut_visit::*;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{self, AssocCtxt, Visitor, VisitorResult, try_visit, walk_list};
 use rustc_ast::{
-    self as ast, AssocItemKind, AstNodeWrapper, AttrArgs, AttrStyle, AttrVec, DUMMY_NODE_ID,
-    ExprKind, ForeignItemKind, HasAttrs, HasNodeId, Inline, ItemKind, MacStmtStyle, MetaItemInner,
-    MetaItemKind, ModKind, NodeId, PatKind, StmtKind, TyKind, token,
+    self as ast, AssocItemKind, AstNodeWrapper, AttrArgs, AttrItemKind, AttrStyle, AttrVec,
+    DUMMY_NODE_ID, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs, HasNodeId, Inline,
+    ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId, PatKind, StmtKind,
+    TyKind, token,
 };
 use rustc_ast_pretty::pprust;
-use rustc_attr_parsing::{AttributeParser, Early, EvalConfigResult, ShouldEmit, validate_attr};
+use rustc_attr_parsing::{
+    AttributeParser, CFG_TEMPLATE, Early, EvalConfigResult, ShouldEmit, eval_config_entry,
+    parse_cfg, validate_attr,
+};
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::PResult;
@@ -813,10 +817,10 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     };
                     let attr_item = attr.get_normal_item();
                     let safety = attr_item.unsafety;
-                    if let AttrArgs::Eq { .. } = attr_item.args {
+                    if let AttrArgs::Eq { .. } = attr_item.args.unparsed_ref().unwrap() {
                         self.cx.dcx().emit_err(UnsupportedKeyValue { span });
                     }
-                    let inner_tokens = attr_item.args.inner_tokens();
+                    let inner_tokens = attr_item.args.unparsed_ref().unwrap().inner_tokens();
                     match expander.expand_with_safety(self.cx, safety, span, inner_tokens, tokens) {
                         Ok(tok_result) => {
                             let fragment = self.parse_ast_fragment(
@@ -2110,7 +2114,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
         let mut attr_pos = None;
         for (pos, attr) in item.attrs().iter().enumerate() {
             if !attr.is_doc_comment() && !self.cx.expanded_inert_attrs.is_marked(attr) {
-                let name = attr.ident().map(|ident| ident.name);
+                let name = attr.name();
                 if name == Some(sym::cfg) || name == Some(sym::cfg_attr) {
                     cfg_pos = Some(pos); // a cfg attr found, no need to search anymore
                     break;
@@ -2187,22 +2191,18 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
             } else if rustc_attr_parsing::is_builtin_attr(attr)
                 && !AttributeParser::<Early>::is_parsed_attribute(&attr.path())
             {
-                let attr_name = attr.ident().unwrap().name;
-                // `#[cfg]` and `#[cfg_attr]` are special - they are
-                // eagerly evaluated.
-                if attr_name != sym::cfg_trace && attr_name != sym::cfg_attr_trace {
-                    self.cx.sess.psess.buffer_lint(
-                        UNUSED_ATTRIBUTES,
-                        attr.span,
-                        self.cx.current_expansion.lint_node_id,
-                        crate::errors::UnusedBuiltinAttribute {
-                            attr_name,
-                            macro_name: pprust::path_to_string(&call.path),
-                            invoc_span: call.path.span,
-                            attr_span: attr.span,
-                        },
-                    );
-                }
+                let attr_name = attr.name().unwrap();
+                self.cx.sess.psess.buffer_lint(
+                    UNUSED_ATTRIBUTES,
+                    attr.span,
+                    self.cx.current_expansion.lint_node_id,
+                    crate::errors::UnusedBuiltinAttribute {
+                        attr_name,
+                        macro_name: pprust::path_to_string(&call.path),
+                        invoc_span: call.path.span,
+                        attr_span: attr.span,
+                    },
+                );
             }
         }
     }
@@ -2213,11 +2213,26 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
         attr: ast::Attribute,
         pos: usize,
     ) -> EvalConfigResult {
-        let res = self.cfg().cfg_true(&attr, ShouldEmit::ErrorsAndLints);
+        let Some(cfg) = AttributeParser::parse_single(
+            self.cfg().sess,
+            &attr,
+            attr.span,
+            self.cfg().lint_node_id,
+            self.cfg().features,
+            ShouldEmit::ErrorsAndLints,
+            parse_cfg,
+            &CFG_TEMPLATE,
+        ) else {
+            // Cfg attribute was not parsable, give up
+            return EvalConfigResult::True;
+        };
+
+        let res = eval_config_entry(self.cfg().sess, &cfg);
         if res.as_bool() {
             // A trace attribute left in AST in place of the original `cfg` attribute.
             // It can later be used by lints or other diagnostics.
-            let trace_attr = attr_into_trace(attr, sym::cfg_trace);
+            let mut trace_attr = attr_into_trace(attr, sym::cfg_trace);
+            trace_attr.replace_args(AttrItemKind::Parsed(EarlyParsedAttribute::CfgTrace(cfg)));
             node.visit_attrs(|attrs| attrs.insert(pos, trace_attr));
         }
 
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index dddd62a4945a..d53d180a4ab9 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -558,25 +558,20 @@ fn metavar_expr_concat<'tx>(
             MetaVarExprConcatElem::Ident(elem) => elem.name,
             MetaVarExprConcatElem::Literal(elem) => *elem,
             MetaVarExprConcatElem::Var(ident) => {
-                match matched_from_ident(dcx, *ident, tscx.interp)? {
-                    NamedMatch::MatchedSeq(named_matches) => {
-                        let Some((curr_idx, _)) = tscx.repeats.last() else {
-                            return Err(dcx.struct_span_err(dspan.entire(), "invalid syntax"));
-                        };
-                        match &named_matches[*curr_idx] {
-                            // FIXME(c410-f3r) Nested repetitions are unimplemented
-                            MatchedSeq(_) => {
-                                return Err(dcx.struct_span_err(
-                                    ident.span,
-                                    "nested repetitions with `${concat(...)}` metavariable expressions are not yet supported",
-                                ));
-                            }
-                            MatchedSingle(pnr) => extract_symbol_from_pnr(dcx, pnr, ident.span)?,
-                        }
-                    }
-                    NamedMatch::MatchedSingle(pnr) => {
+                let key = MacroRulesNormalizedIdent::new(*ident);
+                match lookup_cur_matched(key, tscx.interp, &tscx.repeats) {
+                    Some(NamedMatch::MatchedSingle(pnr)) => {
                         extract_symbol_from_pnr(dcx, pnr, ident.span)?
                     }
+                    Some(NamedMatch::MatchedSeq(..)) => {
+                        return Err(dcx.struct_span_err(
+                            ident.span,
+                            "`${concat(...)}` variable is still repeating at this depth",
+                        ));
+                    }
+                    None => {
+                        return Err(dcx.create_err(MveUnrecognizedVar { span: ident.span, key }));
+                    }
                 }
             }
         };
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 13c1f2219bed..43032bf938c0 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -235,7 +235,7 @@ declare_features! (
     (accepted, generic_param_attrs, "1.27.0", Some(48848)),
     /// Allows the `#[global_allocator]` attribute.
     (accepted, global_allocator, "1.28.0", Some(27389)),
-    // FIXME: explain `globs`.
+    /// Allows globs imports (`use module::*;`) to import all public items from a module.
     (accepted, globs, "1.0.0", None),
     /// Allows using `..=X` as a pattern.
     (accepted, half_open_range_patterns, "1.66.0", Some(67264)),
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 9d8a84c52e98..6aaf4542260c 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -60,6 +60,9 @@ declare_features! (
     (removed, allocator, "1.0.0", None, None),
     /// Allows a test to fail without failing the whole suite.
     (removed, allow_fail, "1.60.0", Some(46488), Some("removed due to no clear use cases"), 93416),
+    /// Allows users to enforce equality of associated constants `TraitImpl<AssocConst=3>`.
+    (removed, associated_const_equality, "CURRENT_RUSTC_VERSION", Some(92827),
+     Some("merged into `min_generic_const_args`")),
     (removed, await_macro, "1.38.0", Some(50547),
      Some("subsumed by `.await` syntax"), 62293),
     /// Allows using the `box $expr` syntax.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index ca2ce2f18812..8959bc586af7 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -233,28 +233,20 @@ declare_features! (
     (internal, link_cfg, "1.14.0", None),
     /// Allows using `?Trait` trait bounds in more contexts.
     (internal, more_maybe_bounds, "1.82.0", None),
-    /// Allows the `multiple_supertrait_upcastable` lint.
-    (unstable, multiple_supertrait_upcastable, "1.69.0", None),
     /// Allow negative trait bounds. This is an internal-only feature for testing the trait solver!
     (internal, negative_bounds, "1.71.0", None),
     /// Set the maximum pattern complexity allowed (not limited by default).
     (internal, pattern_complexity_limit, "1.78.0", None),
-    /// Allows using pattern types.
-    (internal, pattern_types, "1.79.0", Some(123646)),
     /// Allows using `#[prelude_import]` on glob `use` items.
     (internal, prelude_import, "1.2.0", None),
     /// Used to identify crates that contain the profiler runtime.
     (internal, profiler_runtime, "1.18.0", None),
     /// Allows using `rustc_*` attributes (RFC 572).
     (internal, rustc_attrs, "1.0.0", None),
-    /// Introduces a hierarchy of `Sized` traits (RFC 3729).
-    (unstable, sized_hierarchy, "1.89.0", None),
     /// Allows using the `#[stable]` and `#[unstable]` attributes.
     (internal, staged_api, "1.0.0", None),
     /// Added for testing unstable lints; perma-unstable.
     (internal, test_unstable_lint, "1.60.0", None),
-    /// Helps with formatting for `group_imports = "StdExternalCrate"`.
-    (unstable, unqualified_local_imports, "1.83.0", Some(138299)),
     /// Use for stable + negative coherence and strict coherence depending on trait's
     /// rustc_strict_coherence value.
     (unstable, with_negative_coherence, "1.60.0", None),
@@ -295,6 +287,8 @@ declare_features! (
     (internal, needs_panic_runtime, "1.10.0", Some(32837)),
     /// Allows using the `#![panic_runtime]` attribute.
     (internal, panic_runtime, "1.10.0", Some(32837)),
+    /// Allows using pattern types.
+    (internal, pattern_types, "1.79.0", Some(123646)),
     /// Allows using `#[rustc_allow_const_fn_unstable]`.
     /// This is an attribute on `const fn` for the same
     /// purpose as `#[allow_internal_unstable]`.
@@ -305,12 +299,16 @@ declare_features! (
     (internal, rustdoc_internals, "1.58.0", Some(90418)),
     /// Allows using the `rustdoc::missing_doc_code_examples` lint
     (unstable, rustdoc_missing_doc_code_examples, "1.31.0", Some(101730)),
+    /// Introduces a hierarchy of `Sized` traits (RFC 3729).
+    (unstable, sized_hierarchy, "1.89.0", Some(144404)),
     /// Allows using `#[structural_match]` which indicates that a type is structurally matchable.
     /// FIXME: Subsumed by trait `StructuralPartialEq`, cannot move to removed until a library
     /// feature with the same name exists.
     (unstable, structural_match, "1.8.0", Some(31434)),
     /// Allows using the `rust-call` ABI.
     (unstable, unboxed_closures, "1.0.0", Some(29625)),
+    /// Helps with formatting for `group_imports = "StdExternalCrate"`.
+    (unstable, unqualified_local_imports, "1.83.0", Some(138299)),
     // !!!!    !!!!    !!!!    !!!!   !!!!    !!!!    !!!!    !!!!    !!!!    !!!!    !!!!
     // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way.
     // !!!!    !!!!    !!!!    !!!!   !!!!    !!!!    !!!!    !!!!    !!!!    !!!!    !!!!
@@ -363,8 +361,6 @@ declare_features! (
     (unstable, asm_goto_with_outputs, "1.85.0", Some(119364)),
     /// Allows the `may_unwind` option in inline assembly.
     (unstable, asm_unwind, "1.58.0", Some(93334)),
-    /// Allows users to enforce equality of associated constants `TraitImpl<AssocConst=3>`.
-    (unstable, associated_const_equality, "1.58.0", Some(92827)),
     /// Allows associated type defaults.
     (unstable, associated_type_defaults, "1.2.0", Some(29661)),
     /// Allows implementing `AsyncDrop`.
@@ -571,6 +567,8 @@ declare_features! (
     (unstable, more_qualified_paths, "1.54.0", Some(86935)),
     /// The `movrs` target feature on x86.
     (unstable, movrs_target_feature, "1.88.0", Some(137976)),
+    /// Allows the `multiple_supertrait_upcastable` lint.
+    (unstable, multiple_supertrait_upcastable, "1.69.0", Some(150833)),
     /// Allows the `#[must_not_suspend]` attribute.
     (unstable, must_not_suspend, "1.57.0", Some(83310)),
     /// Allows `mut ref` and `mut ref mut` identifier patterns.
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index f418c391ece7..c791f54902d1 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -1,9 +1,9 @@
 use std::borrow::Cow;
-use std::fmt;
 use std::path::PathBuf;
 
 pub use ReprAttr::*;
 use rustc_abi::Align;
+pub use rustc_ast::attr::data_structures::*;
 use rustc_ast::token::DocFragmentKind;
 use rustc_ast::{AttrStyle, ast};
 use rustc_data_structures::fx::FxIndexMap;
@@ -11,7 +11,7 @@ use rustc_error_messages::{DiagArgValue, IntoDiagArg};
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::Transparency;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 pub use rustc_target::spec::SanitizerSet;
 use thin_vec::ThinVec;
 
@@ -19,9 +19,22 @@ use crate::attrs::pretty_printing::PrintAttribute;
 use crate::limit::Limit;
 use crate::{DefaultBodyStability, PartialConstStability, RustcVersion, Stability};
 
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub enum EiiImplResolution {
+    /// Usually, finding the extern item that an EII implementation implements means finding
+    /// the defid of the associated attribute macro, and looking at *its* attributes to find
+    /// what foreign item its associated with.
+    Macro(DefId),
+    /// Sometimes though, we already know statically and can skip some name resolution.
+    /// Stored together with the eii's name for diagnostics.
+    Known(EiiDecl),
+    /// For when resolution failed, but we want to continue compilation
+    Error(ErrorGuaranteed),
+}
+
 #[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
 pub struct EiiImpl {
-    pub eii_macro: DefId,
+    pub resolution: EiiImplResolution,
     pub impl_marked_unsafe: bool,
     pub span: Span,
     pub inner_span: Span,
@@ -33,7 +46,7 @@ pub struct EiiDecl {
     pub eii_extern_target: DefId,
     /// whether or not it is unsafe to implement this EII
     pub impl_unsafe: bool,
-    pub span: Span,
+    pub name: Ident,
 }
 
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, PrintAttribute)]
@@ -212,83 +225,6 @@ impl<ModId> StrippedCfgItem<ModId> {
     }
 }
 
-#[derive(Encodable, Decodable, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(HashStable_Generic, PrintAttribute)]
-pub enum CfgEntry {
-    All(ThinVec<CfgEntry>, Span),
-    Any(ThinVec<CfgEntry>, Span),
-    Not(Box<CfgEntry>, Span),
-    Bool(bool, Span),
-    NameValue { name: Symbol, value: Option<Symbol>, span: Span },
-    Version(Option<RustcVersion>, Span),
-}
-
-impl CfgEntry {
-    pub fn span(&self) -> Span {
-        let (Self::All(_, span)
-        | Self::Any(_, span)
-        | Self::Not(_, span)
-        | Self::Bool(_, span)
-        | Self::NameValue { span, .. }
-        | Self::Version(_, span)) = self;
-        *span
-    }
-
-    /// Same as `PartialEq` but doesn't check spans and ignore order of cfgs.
-    pub fn is_equivalent_to(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::All(a, _), Self::All(b, _)) | (Self::Any(a, _), Self::Any(b, _)) => {
-                a.len() == b.len() && a.iter().all(|a| b.iter().any(|b| a.is_equivalent_to(b)))
-            }
-            (Self::Not(a, _), Self::Not(b, _)) => a.is_equivalent_to(b),
-            (Self::Bool(a, _), Self::Bool(b, _)) => a == b,
-            (
-                Self::NameValue { name: name1, value: value1, .. },
-                Self::NameValue { name: name2, value: value2, .. },
-            ) => name1 == name2 && value1 == value2,
-            (Self::Version(a, _), Self::Version(b, _)) => a == b,
-            _ => false,
-        }
-    }
-}
-
-impl fmt::Display for CfgEntry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fn write_entries(
-            name: &str,
-            entries: &[CfgEntry],
-            f: &mut fmt::Formatter<'_>,
-        ) -> fmt::Result {
-            write!(f, "{name}(")?;
-            for (nb, entry) in entries.iter().enumerate() {
-                if nb != 0 {
-                    f.write_str(", ")?;
-                }
-                entry.fmt(f)?;
-            }
-            f.write_str(")")
-        }
-        match self {
-            Self::All(entries, _) => write_entries("all", entries, f),
-            Self::Any(entries, _) => write_entries("any", entries, f),
-            Self::Not(entry, _) => write!(f, "not({entry})"),
-            Self::Bool(value, _) => write!(f, "{value}"),
-            Self::NameValue { name, value, .. } => {
-                match value {
-                    // We use `as_str` and debug display to have characters escaped and `"`
-                    // characters surrounding the string.
-                    Some(value) => write!(f, "{name} = {:?}", value.as_str()),
-                    None => write!(f, "{name}"),
-                }
-            }
-            Self::Version(version, _) => match version {
-                Some(version) => write!(f, "{version}"),
-                None => Ok(()),
-            },
-        }
-    }
-}
-
 /// Possible values for the `#[linkage]` attribute, allowing to specify the
 /// linkage type for a `MonoItem`.
 ///
@@ -713,6 +649,12 @@ pub enum AttributeKind {
         span: Span,
     },
 
+    /// Represents the trace attribute of `#[cfg_attr]`
+    CfgAttrTrace,
+
+    /// Represents the trace attribute of `#[cfg]`
+    CfgTrace(ThinVec<(CfgEntry, Span)>),
+
     /// Represents `#[cfi_encoding]`
     CfiEncoding { encoding: Symbol },
 
@@ -938,6 +880,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_coherence_is_core]`
     RustcCoherenceIsCore(Span),
 
+    /// Represents `#[rustc_has_incoherent_inherent_impls]`
+    RustcHasIncoherentInherentImpls,
+
     /// Represents `#[rustc_layout_scalar_valid_range_end]`.
     RustcLayoutScalarValidRangeEnd(Box<u128>, Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 57d2d6c5875e..4e1e9a074e66 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -26,6 +26,8 @@ impl AttributeKind {
             AsPtr(..) => Yes,
             AutomaticallyDerived(..) => Yes,
             BodyStability { .. } => No,
+            CfgAttrTrace => Yes,
+            CfgTrace(..) => Yes,
             CfiEncoding { .. } => Yes,
             Coinductive(..) => No,
             Cold(..) => No,
@@ -93,6 +95,7 @@ impl AttributeKind {
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcCoherenceIsCore(..) => No,
+            RustcHasIncoherentInherentImpls => Yes,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcLegacyConstGenerics { .. } => Yes,
diff --git a/compiler/rustc_hir/src/attrs/pretty_printing.rs b/compiler/rustc_hir/src/attrs/pretty_printing.rs
index f8ac2a547ca8..806f5c4d3ed9 100644
--- a/compiler/rustc_hir/src/attrs/pretty_printing.rs
+++ b/compiler/rustc_hir/src/attrs/pretty_printing.rs
@@ -2,6 +2,8 @@ use std::num::NonZero;
 use std::ops::Deref;
 
 use rustc_abi::Align;
+use rustc_ast::attr::data_structures::CfgEntry;
+use rustc_ast::attr::version::RustcVersion;
 use rustc_ast::token::{CommentKind, DocFragmentKind};
 use rustc_ast::{AttrStyle, IntTy, UintTy};
 use rustc_ast_pretty::pp::Printer;
@@ -182,4 +184,6 @@ print_debug!(
     Transparency,
     SanitizerSet,
     DefId,
+    RustcVersion,
+    CfgEntry,
 );
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 95abe5c40dd4..e93deaa84944 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -563,29 +563,6 @@ pub enum Res<Id = hir::HirId> {
         /// to get the underlying type.
         alias_to: DefId,
 
-        /// Whether the `Self` type is disallowed from mentioning generics (i.e. when used in an
-        /// anonymous constant).
-        ///
-        /// HACK(min_const_generics): self types also have an optional requirement to **not**
-        /// mention any generic parameters to allow the following with `min_const_generics`:
-        /// ```
-        /// # struct Foo;
-        /// impl Foo { fn test() -> [u8; size_of::<Self>()] { todo!() } }
-        ///
-        /// struct Bar([u8; baz::<Self>()]);
-        /// const fn baz<T>() -> usize { 10 }
-        /// ```
-        /// We do however allow `Self` in repeat expression even if it is generic to not break code
-        /// which already works on stable while causing the `const_evaluatable_unchecked` future
-        /// compat lint:
-        /// ```
-        /// fn foo<T>() {
-        ///     let _bar = [1_u8; size_of::<*mut T>()];
-        /// }
-        /// ```
-        // FIXME(generic_const_exprs): Remove this bodge once that feature is stable.
-        forbid_generic: bool,
-
         /// Is this within an `impl Foo for bar`?
         is_trait_impl: bool,
     },
@@ -910,8 +887,8 @@ impl<Id> Res<Id> {
             Res::PrimTy(id) => Res::PrimTy(id),
             Res::Local(id) => Res::Local(map(id)),
             Res::SelfTyParam { trait_ } => Res::SelfTyParam { trait_ },
-            Res::SelfTyAlias { alias_to, forbid_generic, is_trait_impl } => {
-                Res::SelfTyAlias { alias_to, forbid_generic, is_trait_impl }
+            Res::SelfTyAlias { alias_to, is_trait_impl } => {
+                Res::SelfTyAlias { alias_to, is_trait_impl }
             }
             Res::ToolMod => Res::ToolMod,
             Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind),
@@ -926,8 +903,8 @@ impl<Id> Res<Id> {
             Res::PrimTy(id) => Res::PrimTy(id),
             Res::Local(id) => Res::Local(map(id)?),
             Res::SelfTyParam { trait_ } => Res::SelfTyParam { trait_ },
-            Res::SelfTyAlias { alias_to, forbid_generic, is_trait_impl } => {
-                Res::SelfTyAlias { alias_to, forbid_generic, is_trait_impl }
+            Res::SelfTyAlias { alias_to, is_trait_impl } => {
+                Res::SelfTyAlias { alias_to, is_trait_impl }
             }
             Res::ToolMod => Res::ToolMod,
             Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind),
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index da3e79efd6df..2fb6daf6469b 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -423,7 +423,7 @@ impl<'hir> ConstItemRhs<'hir> {
     pub fn span<'tcx>(&self, tcx: impl crate::intravisit::HirTyCtxt<'tcx>) -> Span {
         match self {
             ConstItemRhs::Body(body_id) => tcx.hir_body(*body_id).value.span,
-            ConstItemRhs::TypeConst(ct_arg) => ct_arg.span(),
+            ConstItemRhs::TypeConst(ct_arg) => ct_arg.span,
         }
     }
 }
@@ -440,13 +440,14 @@ impl<'hir> ConstItemRhs<'hir> {
 /// versus const args that are literals or have arbitrary computations (e.g., `{ 1 + 3 }`).
 ///
 /// For an explanation of the `Unambig` generic parameter see the dev-guide:
-/// <https://rustc-dev-guide.rust-lang.org/hir/ambig-unambig-ty-and-consts.html>
+/// <https://rustc-dev-guide.rust-lang.org/ambig-unambig-ty-and-consts.html>
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 #[repr(C)]
 pub struct ConstArg<'hir, Unambig = ()> {
     #[stable_hasher(ignore)]
     pub hir_id: HirId,
     pub kind: ConstArgKind<'hir, Unambig>,
+    pub span: Span,
 }
 
 impl<'hir> ConstArg<'hir, AmbigArg> {
@@ -475,7 +476,7 @@ impl<'hir> ConstArg<'hir> {
     /// Functions accepting ambiguous consts will not handle the [`ConstArgKind::Infer`] variant, if
     /// infer consts are relevant to you then care should be taken to handle them separately.
     pub fn try_as_ambig_ct(&self) -> Option<&ConstArg<'hir, AmbigArg>> {
-        if let ConstArgKind::Infer(_, ()) = self.kind {
+        if let ConstArgKind::Infer(()) = self.kind {
             return None;
         }
 
@@ -494,22 +495,13 @@ impl<'hir, Unambig> ConstArg<'hir, Unambig> {
             _ => None,
         }
     }
-
-    pub fn span(&self) -> Span {
-        match self.kind {
-            ConstArgKind::Struct(path, _) => path.span(),
-            ConstArgKind::Path(path) => path.span(),
-            ConstArgKind::Anon(anon) => anon.span,
-            ConstArgKind::Error(span, _) => span,
-            ConstArgKind::Infer(span, _) => span,
-        }
-    }
 }
 
 /// See [`ConstArg`].
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 #[repr(u8, C)]
 pub enum ConstArgKind<'hir, Unambig = ()> {
+    Tup(&'hir [&'hir ConstArg<'hir, Unambig>]),
     /// **Note:** Currently this is only used for bare const params
     /// (`N` where `fn foo<const N: usize>(...)`),
     /// not paths to any const (`N` where `const N: usize = ...`).
@@ -519,11 +511,14 @@ pub enum ConstArgKind<'hir, Unambig = ()> {
     Anon(&'hir AnonConst),
     /// Represents construction of struct/struct variants
     Struct(QPath<'hir>, &'hir [&'hir ConstArgExprField<'hir>]),
+    /// Tuple constructor variant
+    TupleCall(QPath<'hir>, &'hir [&'hir ConstArg<'hir>]),
     /// Error const
-    Error(Span, ErrorGuaranteed),
+    Error(ErrorGuaranteed),
     /// This variant is not always used to represent inference consts, sometimes
     /// [`GenericArg::Infer`] is used instead.
-    Infer(Span, Unambig),
+    Infer(Unambig),
+    Literal(LitKind),
 }
 
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
@@ -569,7 +564,7 @@ impl GenericArg<'_> {
         match self {
             GenericArg::Lifetime(l) => l.ident.span,
             GenericArg::Type(t) => t.span,
-            GenericArg::Const(c) => c.span(),
+            GenericArg::Const(c) => c.span,
             GenericArg::Infer(i) => i.span,
         }
     }
@@ -1196,7 +1191,7 @@ pub enum AttrArgs {
 
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable)]
 pub struct AttrPath {
-    pub segments: Box<[Ident]>,
+    pub segments: Box<[Symbol]>,
     pub span: Span,
 }
 
@@ -1212,7 +1207,7 @@ impl AttrPath {
             segments: path
                 .segments
                 .iter()
-                .map(|i| Ident { name: i.ident.name, span: lower_span(i.ident.span) })
+                .map(|i| i.ident.name)
                 .collect::<Vec<_>>()
                 .into_boxed_slice(),
             span: lower_span(path.span),
@@ -1222,7 +1217,11 @@ impl AttrPath {
 
 impl fmt::Display for AttrPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", join_path_idents(&self.segments))
+        write!(
+            f,
+            "{}",
+            join_path_idents(self.segments.iter().map(|i| Ident { name: *i, span: DUMMY_SP }))
+        )
     }
 }
 
@@ -1327,7 +1326,7 @@ impl AttributeExt for Attribute {
 
     /// For a single-segment attribute, returns its name; otherwise, returns `None`.
     #[inline]
-    fn ident(&self) -> Option<Ident> {
+    fn name(&self) -> Option<Symbol> {
         match &self {
             Attribute::Unparsed(n) => {
                 if let [ident] = n.path.segments.as_ref() {
@@ -1343,7 +1342,7 @@ impl AttributeExt for Attribute {
     #[inline]
     fn path_matches(&self, name: &[Symbol]) -> bool {
         match &self {
-            Attribute::Unparsed(n) => n.path.segments.iter().map(|ident| &ident.name).eq(name),
+            Attribute::Unparsed(n) => n.path.segments.iter().eq(name),
             _ => false,
         }
     }
@@ -1364,6 +1363,7 @@ impl AttributeExt for Attribute {
             // FIXME: should not be needed anymore when all attrs are parsed
             Attribute::Parsed(AttributeKind::DocComment { span, .. }) => *span,
             Attribute::Parsed(AttributeKind::Deprecation { span, .. }) => *span,
+            Attribute::Parsed(AttributeKind::CfgTrace(cfgs)) => cfgs[0].1,
             a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
         }
     }
@@ -1379,13 +1379,20 @@ impl AttributeExt for Attribute {
     }
 
     #[inline]
-    fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
+    fn symbol_path(&self) -> Option<SmallVec<[Symbol; 1]>> {
         match &self {
             Attribute::Unparsed(n) => Some(n.path.segments.iter().copied().collect()),
             _ => None,
         }
     }
 
+    fn path_span(&self) -> Option<Span> {
+        match &self {
+            Attribute::Unparsed(attr) => Some(attr.path.span),
+            Attribute::Parsed(_) => None,
+        }
+    }
+
     #[inline]
     fn doc_str(&self) -> Option<Symbol> {
         match &self {
@@ -1394,6 +1401,14 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
+    fn deprecation_note(&self) -> Option<Symbol> {
+        match &self {
+            Attribute::Parsed(AttributeKind::Deprecation { deprecation, .. }) => deprecation.note,
+            _ => None,
+        }
+    }
+
     fn is_automatically_derived_attr(&self) -> bool {
         matches!(self, Attribute::Parsed(AttributeKind::AutomaticallyDerived(..)))
     }
@@ -1465,11 +1480,6 @@ impl Attribute {
         AttributeExt::value_span(self)
     }
 
-    #[inline]
-    pub fn ident(&self) -> Option<Ident> {
-        AttributeExt::ident(self)
-    }
-
     #[inline]
     pub fn path_matches(&self, name: &[Symbol]) -> bool {
         AttributeExt::path_matches(self, name)
@@ -1505,11 +1515,6 @@ impl Attribute {
         AttributeExt::path(self)
     }
 
-    #[inline]
-    pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
-        AttributeExt::ident_path(self)
-    }
-
     #[inline]
     pub fn doc_str(&self) -> Option<Symbol> {
         AttributeExt::doc_str(self)
@@ -2620,6 +2625,12 @@ impl Expr<'_> {
                 // them being used only for its side-effects.
                 base.can_have_side_effects()
             }
+            ExprKind::Binary(_, lhs, rhs) => {
+                // This isn't exactly true for all `Binary`, but we are using this
+                // method exclusively for diagnostics and there's a *cultural* pressure against
+                // them being used only for its side-effects.
+                lhs.can_have_side_effects() || rhs.can_have_side_effects()
+            }
             ExprKind::Struct(_, fields, init) => {
                 let init_side_effects = match init {
                     StructTailExpr::Base(init) => init.can_have_side_effects(),
@@ -2642,13 +2653,13 @@ impl Expr<'_> {
                 },
                 args,
             ) => args.iter().any(|arg| arg.can_have_side_effects()),
+            ExprKind::Repeat(arg, _) => arg.can_have_side_effects(),
             ExprKind::If(..)
             | ExprKind::Match(..)
             | ExprKind::MethodCall(..)
             | ExprKind::Call(..)
             | ExprKind::Closure { .. }
             | ExprKind::Block(..)
-            | ExprKind::Repeat(..)
             | ExprKind::Break(..)
             | ExprKind::Continue(..)
             | ExprKind::Ret(..)
@@ -2659,7 +2670,6 @@ impl Expr<'_> {
             | ExprKind::InlineAsm(..)
             | ExprKind::AssignOp(..)
             | ExprKind::ConstBlock(..)
-            | ExprKind::Binary(..)
             | ExprKind::Yield(..)
             | ExprKind::DropTemps(..)
             | ExprKind::Err(_) => true,
@@ -3374,7 +3384,7 @@ pub enum AmbigArg {}
 /// Represents a type in the `HIR`.
 ///
 /// For an explanation of the `Unambig` generic parameter see the dev-guide:
-/// <https://rustc-dev-guide.rust-lang.org/hir/ambig-unambig-ty-and-consts.html>
+/// <https://rustc-dev-guide.rust-lang.org/ambig-unambig-ty-and-consts.html>
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 #[repr(C)]
 pub struct Ty<'hir, Unambig = ()> {
@@ -3713,7 +3723,7 @@ pub enum InferDelegationKind {
 /// The various kinds of types recognized by the compiler.
 ///
 /// For an explanation of the `Unambig` generic parameter see the dev-guide:
-/// <https://rustc-dev-guide.rust-lang.org/hir/ambig-unambig-ty-and-consts.html>
+/// <https://rustc-dev-guide.rust-lang.org/ambig-unambig-ty-and-consts.html>
 // SAFETY: `repr(u8)` is required so that `TyKind<()>` and `TyKind<!>` are layout compatible
 #[repr(u8, C)]
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
diff --git a/compiler/rustc_hir/src/hir/tests.rs b/compiler/rustc_hir/src/hir/tests.rs
index 4f9609fd360d..2ac33a369cbd 100644
--- a/compiler/rustc_hir/src/hir/tests.rs
+++ b/compiler/rustc_hir/src/hir/tests.rs
@@ -24,12 +24,16 @@ define_tests! {
     cast_ptr TyKind Ptr { 0: MutTy { ty: &Ty { span: DUMMY_SP, hir_id: HirId::INVALID, kind: TyKind::Never }, mutbl: Mutability::Not }}
     cast_array TyKind Array {
         0: &Ty { span: DUMMY_SP, hir_id: HirId::INVALID, kind: TyKind::Never },
-        1: &ConstArg { hir_id: HirId::INVALID, kind: ConstArgKind::Anon(&AnonConst {
+        1: &ConstArg {
             hir_id: HirId::INVALID,
-            def_id: LocalDefId { local_def_index: DefIndex::ZERO },
-            body: BodyId { hir_id: HirId::INVALID },
+            kind: ConstArgKind::Anon(&AnonConst {
+                hir_id: HirId::INVALID,
+                def_id: LocalDefId { local_def_index: DefIndex::ZERO },
+                body: BodyId { hir_id: HirId::INVALID },
+                span: DUMMY_SP,
+            }),
             span: DUMMY_SP,
-        })}
+        },
     }
 
     cast_anon ConstArgKind Anon {
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index e636b3fff654..e5e6fc7b1d8d 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1068,8 +1068,8 @@ pub fn walk_unambig_const_arg<'v, V: Visitor<'v>>(
     match const_arg.try_as_ambig_ct() {
         Some(ambig_ct) => visitor.visit_const_arg(ambig_ct),
         None => {
-            let ConstArg { hir_id, kind: _ } = const_arg;
-            visitor.visit_infer(*hir_id, const_arg.span(), InferKind::Const(const_arg))
+            let ConstArg { hir_id, kind: _, span } = const_arg;
+            visitor.visit_infer(*hir_id, *span, InferKind::Const(const_arg))
         }
     }
 }
@@ -1078,9 +1078,13 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
     visitor: &mut V,
     const_arg: &'v ConstArg<'v, AmbigArg>,
 ) -> V::Result {
-    let ConstArg { hir_id, kind } = const_arg;
+    let ConstArg { hir_id, kind, span: _ } = const_arg;
     try_visit!(visitor.visit_id(*hir_id));
     match kind {
+        ConstArgKind::Tup(exprs) => {
+            walk_list!(visitor, visit_const_arg, *exprs);
+            V::Result::output()
+        }
         ConstArgKind::Struct(qpath, field_exprs) => {
             try_visit!(visitor.visit_qpath(qpath, *hir_id, qpath.span()));
 
@@ -1090,9 +1094,17 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
 
             V::Result::output()
         }
+        ConstArgKind::TupleCall(qpath, args) => {
+            try_visit!(visitor.visit_qpath(qpath, *hir_id, qpath.span()));
+            for arg in *args {
+                try_visit!(visitor.visit_const_arg_unambig(*arg));
+            }
+            V::Result::output()
+        }
         ConstArgKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, qpath.span()),
         ConstArgKind::Anon(anon) => visitor.visit_anon_const(*anon),
-        ConstArgKind::Error(_, _) => V::Result::output(), // errors and spans are not important
+        ConstArgKind::Error(_) => V::Result::output(), // errors and spans are not important
+        ConstArgKind::Literal(..) => V::Result::output(), // FIXME(mcga)
     }
 }
 
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 4ac3e4e83e80..557f76208bfe 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -278,6 +278,7 @@ language_item_table! {
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
 
+    Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
     TypeId,                  sym::type_id,             type_id,                    Target::Struct,         GenericRequirement::None;
 
     // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
index 7c9c15c16df4..9c2fec867785 100644
--- a/compiler/rustc_hir/src/lib.rs
+++ b/compiler/rustc_hir/src/lib.rs
@@ -32,8 +32,7 @@ pub mod lints;
 pub mod pat_util;
 mod stability;
 mod stable_hash_impls;
-mod target;
-mod version;
+pub mod target;
 pub mod weak_lang_items;
 
 #[cfg(test)]
@@ -42,9 +41,9 @@ mod tests;
 #[doc(no_inline)]
 pub use hir::*;
 pub use lang_items::{LangItem, LanguageItems};
+pub use rustc_ast::attr::version::*;
 pub use stability::*;
 pub use stable_hash_impls::HashStableContext;
 pub use target::{MethodKind, Target};
-pub use version::*;
 
 arena_types!(rustc_arena::declare_arena);
diff --git a/compiler/rustc_hir_analysis/src/check/compare_eii.rs b/compiler/rustc_hir_analysis/src/check/compare_eii.rs
index 4e7f47a92108..d8afee9aafc9 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_eii.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_eii.rs
@@ -32,21 +32,21 @@ use crate::errors::{EiiWithGenerics, LifetimesOrBoundsMismatchOnEii};
 pub(crate) fn compare_eii_function_types<'tcx>(
     tcx: TyCtxt<'tcx>,
     external_impl: LocalDefId,
-    declaration: DefId,
+    foreign_item: DefId,
     eii_name: Symbol,
     eii_attr_span: Span,
 ) -> Result<(), ErrorGuaranteed> {
-    check_is_structurally_compatible(tcx, external_impl, declaration, eii_name, eii_attr_span)?;
+    check_is_structurally_compatible(tcx, external_impl, foreign_item, eii_name, eii_attr_span)?;
 
     let external_impl_span = tcx.def_span(external_impl);
     let cause = ObligationCause::new(
         external_impl_span,
         external_impl,
-        ObligationCauseCode::CompareEii { external_impl, declaration },
+        ObligationCauseCode::CompareEii { external_impl, declaration: foreign_item },
     );
 
     // FIXME(eii): even if we don't support generic functions, we should support explicit outlive bounds here
-    let param_env = tcx.param_env(declaration);
+    let param_env = tcx.param_env(foreign_item);
 
     let infcx = &tcx.infer_ctxt().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(infcx);
@@ -62,7 +62,7 @@ pub(crate) fn compare_eii_function_types<'tcx>(
     let mut wf_tys = FxIndexSet::default();
     let norm_cause = ObligationCause::misc(external_impl_span, external_impl);
 
-    let declaration_sig = tcx.fn_sig(declaration).instantiate_identity();
+    let declaration_sig = tcx.fn_sig(foreign_item).instantiate_identity();
     let declaration_sig = tcx.liberate_late_bound_regions(external_impl.into(), declaration_sig);
     debug!(?declaration_sig);
 
@@ -103,7 +103,7 @@ pub(crate) fn compare_eii_function_types<'tcx>(
             cause,
             param_env,
             terr,
-            (declaration, declaration_sig),
+            (foreign_item, declaration_sig),
             (external_impl, external_impl_sig),
             eii_attr_span,
             eii_name,
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 9eaf5319cb04..c84c1a8ca16d 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -213,6 +213,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::type_id
         | sym::type_id_eq
         | sym::type_name
+        | sym::type_of
         | sym::ub_checks
         | sym::variant_count
         | sym::vtable_for
@@ -308,13 +309,22 @@ pub(crate) fn check_intrinsic_type(
         sym::needs_drop => (1, 0, vec![], tcx.types.bool),
 
         sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
-        sym::type_id => {
-            (1, 0, vec![], tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity())
-        }
+        sym::type_id => (
+            1,
+            0,
+            vec![],
+            tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap(),
+        ),
         sym::type_id_eq => {
-            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity();
+            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap();
             (0, 0, vec![type_id, type_id], tcx.types.bool)
         }
+        sym::type_of => (
+            0,
+            0,
+            vec![tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap()],
+            tcx.type_of(tcx.lang_items().type_struct().unwrap()).no_bound_vars().unwrap(),
+        ),
         sym::offload => (
             3,
             0,
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 725294dfd377..7ec4110f80b9 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -6,7 +6,7 @@ use rustc_abi::{ExternAbi, ScalableElt};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_err};
-use rustc_hir::attrs::{AttributeKind, EiiDecl, EiiImpl};
+use rustc_hir::attrs::{AttributeKind, EiiDecl, EiiImpl, EiiImplResolution};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
@@ -1196,27 +1196,28 @@ fn check_item_fn(
 fn check_eiis(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     // does the function have an EiiImpl attribute? that contains the defid of a *macro*
     // that was used to mark the implementation. This is a two step process.
-    for EiiImpl { eii_macro, span, .. } in
+    for EiiImpl { resolution, span, .. } in
         find_attr!(tcx.get_all_attrs(def_id), AttributeKind::EiiImpls(impls) => impls)
             .into_iter()
             .flatten()
     {
-        // we expect this macro to have the `EiiMacroFor` attribute, that points to a function
-        // signature that we'd like to compare the function we're currently checking with
-        if let Some(eii_extern_target) = find_attr!(tcx.get_all_attrs(*eii_macro), AttributeKind::EiiExternTarget(EiiDecl {eii_extern_target, ..}) => *eii_extern_target)
-        {
-            let _ = compare_eii_function_types(
-                tcx,
-                def_id,
-                eii_extern_target,
-                tcx.item_name(*eii_macro),
-                *span,
-            );
-        } else {
-            panic!(
-                "EII impl macro {eii_macro:?} did not have an eii extern target attribute pointing to a foreign function"
-            )
-        }
+        let (foreign_item, name) = match resolution {
+            EiiImplResolution::Macro(def_id) => {
+                // we expect this macro to have the `EiiMacroFor` attribute, that points to a function
+                // signature that we'd like to compare the function we're currently checking with
+                if let Some(foreign_item) = find_attr!(tcx.get_all_attrs(*def_id), AttributeKind::EiiExternTarget(EiiDecl {eii_extern_target: t, ..}) => *t)
+                {
+                    (foreign_item, tcx.item_name(*def_id))
+                } else {
+                    tcx.dcx().span_delayed_bug(*span, "resolved to something that's not an EII");
+                    continue;
+                }
+            }
+            EiiImplResolution::Known(decl) => (decl.eii_extern_target, decl.name.name),
+            EiiImplResolution::Error(_eg) => continue,
+        };
+
+        let _ = compare_eii_function_types(tcx, def_id, foreign_item, name, *span);
     }
 }
 
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 38ae7852ca99..fe47f3258846 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -15,7 +15,7 @@ use rustc_hir::find_attr;
 use rustc_middle::bug;
 use rustc_middle::ty::fast_reject::{SimplifiedType, TreatParams, simplify_type};
 use rustc_middle::ty::{self, CrateInherentImpls, Ty, TyCtxt};
-use rustc_span::{ErrorGuaranteed, sym};
+use rustc_span::ErrorGuaranteed;
 
 use crate::errors;
 
@@ -79,13 +79,15 @@ impl<'tcx> InherentCollect<'tcx> {
         }
 
         if self.tcx.features().rustc_attrs() {
-            let items = self.tcx.associated_item_def_ids(impl_def_id);
-
-            if !self.tcx.has_attr(ty_def_id, sym::rustc_has_incoherent_inherent_impls) {
+            if !find_attr!(
+                self.tcx.get_all_attrs(ty_def_id),
+                AttributeKind::RustcHasIncoherentInherentImpls
+            ) {
                 let impl_span = self.tcx.def_span(impl_def_id);
                 return Err(self.tcx.dcx().emit_err(errors::InherentTyOutside { span: impl_span }));
             }
 
+            let items = self.tcx.associated_item_def_ids(impl_def_id);
             for &impl_item in items {
                 if !find_attr!(
                     self.tcx.get_all_attrs(impl_item),
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 9343bcd27a33..bacdf0049806 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1479,23 +1479,27 @@ fn rendered_precise_capturing_args<'tcx>(
 
 fn const_param_default<'tcx>(
     tcx: TyCtxt<'tcx>,
-    def_id: LocalDefId,
+    local_def_id: LocalDefId,
 ) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
     let hir::Node::GenericParam(hir::GenericParam {
         kind: hir::GenericParamKind::Const { default: Some(default_ct), .. },
         ..
-    }) = tcx.hir_node_by_def_id(def_id)
+    }) = tcx.hir_node_by_def_id(local_def_id)
     else {
         span_bug!(
-            tcx.def_span(def_id),
+            tcx.def_span(local_def_id),
             "`const_param_default` expected a generic parameter with a constant"
         )
     };
-    let icx = ItemCtxt::new(tcx, def_id);
-    let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
+
+    let icx = ItemCtxt::new(tcx, local_def_id);
+
+    let def_id = local_def_id.to_def_id();
+    let identity_args = ty::GenericArgs::identity_for_item(tcx, tcx.parent(def_id));
+
     let ct = icx
         .lowerer()
-        .lower_const_arg(default_ct, FeedConstTy::Param(def_id.to_def_id(), identity_args));
+        .lower_const_arg(default_ct, FeedConstTy::with_type_of(tcx, def_id, identity_args));
     ty::EarlyBinder::bind(ct)
 }
 
@@ -1553,7 +1557,7 @@ fn const_of_item<'tcx>(
     let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
     let ct = icx
         .lowerer()
-        .lower_const_arg(ct_arg, FeedConstTy::Param(def_id.to_def_id(), identity_args));
+        .lower_const_arg(ct_arg, FeedConstTy::with_type_of(tcx, def_id.to_def_id(), identity_args));
     if let Err(e) = icx.check_tainted_by_errors()
         && !ct.references_error()
     {
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index aa0e5c7fd710..910176a0689c 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -420,7 +420,22 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    let ty = tcx.typeck(def_id).node_type(hir_id);
+    // If the type is omitted on a #[type_const] we can't run
+    // type check on since that requires the const have a body
+    // which type_consts don't.
+    let ty = if tcx.is_type_const(def_id.to_def_id()) {
+        if let Some(trait_item_def_id) = tcx.trait_item_of(def_id.to_def_id()) {
+            tcx.type_of(trait_item_def_id).instantiate_identity()
+        } else {
+            Ty::new_error_with_message(
+                tcx,
+                ty_span,
+                "constant with #[type_const] requires an explicit type",
+            )
+        }
+    } else {
+        tcx.typeck(def_id).node_type(hir_id)
+    };
 
     // If this came from a free `const` or `static mut?` item,
     // then the user may have written e.g. `const A = 42;`.
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index 555ef5c45e12..9ae6a9fac504 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -610,9 +610,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                 AttributeKind::TypeConst(_)
                             )
                         {
-                            if tcx.features().min_generic_const_args()
-                                || tcx.features().associated_const_equality()
-                            {
+                            if tcx.features().min_generic_const_args() {
                                 let mut err = self.dcx().struct_span_err(
                                     constraint.span,
                                     "use of trait associated const without `#[type_const]`",
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
index 15d7da3a0070..edb79592e6c5 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -239,7 +239,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         // `trait_object_dummy_self`, so check for that.
                         let references_self = match pred.skip_binder().term.kind() {
                             ty::TermKind::Ty(ty) => ty.walk().any(|arg| arg == dummy_self.into()),
-                            // FIXME(associated_const_equality): We should walk the const instead of not doing anything
+                            // FIXME(mgca): We should walk the const instead of not doing anything
                             ty::TermKind::Const(_) => false,
                         };
 
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 5fc201db68e5..92b77a2042b1 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -359,12 +359,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             None
         };
 
-        // FIXME(associated_const_equality): This has quite a few false positives and negatives.
+        // FIXME(mgca): This has quite a few false positives and negatives.
         let wrap_in_braces_sugg = if let Some(constraint) = constraint
             && let Some(hir_ty) = constraint.ty()
             && let ty = self.lower_ty(hir_ty)
             && (ty.is_enum() || ty.references_error())
-            && tcx.features().associated_const_equality()
+            && tcx.features().min_generic_const_args()
         {
             Some(errors::AssocKindMismatchWrapInBracesSugg {
                 lo: hir_ty.span.shrink_to_lo(),
@@ -381,7 +381,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         {
             let span = match term {
                 hir::Term::Ty(ty) => ty.span,
-                hir::Term::Const(ct) => ct.span(),
+                hir::Term::Const(ct) => ct.span,
             };
             (span, Some(ident.span), assoc_item.as_tag(), assoc_tag)
         } else {
@@ -1466,7 +1466,7 @@ pub fn prohibit_assoc_item_constraint(
                     hir::AssocItemConstraintKind::Equality { term: hir::Term::Const(c) },
                     GenericParamDefKind::Const { .. },
                 ) => {
-                    suggest_direct_use(&mut err, c.span());
+                    suggest_direct_use(&mut err, c.span);
                 }
                 (hir::AssocItemConstraintKind::Bound { bounds }, _) => {
                     // Suggest `impl<T: Bound> Trait<T> for Foo` when finding
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 48b2b80c8af3..1dd9bff42575 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -22,6 +22,7 @@ pub mod generics;
 use std::assert_matches::assert_matches;
 use std::slice;
 
+use rustc_ast::LitKind;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
@@ -259,17 +260,26 @@ impl AssocItemQSelf {
 /// Use this enum with `<dyn HirTyLowerer>::lower_const_arg` to instruct it with the
 /// desired behavior.
 #[derive(Debug, Clone, Copy)]
-pub enum FeedConstTy<'a, 'tcx> {
-    /// Feed the type.
-    ///
+pub enum FeedConstTy<'tcx> {
+    /// Feed the type to the (anno) const arg.
+    WithTy(Ty<'tcx>),
+    /// Don't feed the type.
+    No,
+}
+
+impl<'tcx> FeedConstTy<'tcx> {
     /// The `DefId` belongs to the const param that we are supplying
     /// this (anon) const arg to.
     ///
     /// The list of generic args is used to instantiate the parameters
     /// used by the type of the const param specified by `DefId`.
-    Param(DefId, &'a [ty::GenericArg<'tcx>]),
-    /// Don't feed the type.
-    No,
+    pub fn with_type_of(
+        tcx: TyCtxt<'tcx>,
+        def_id: DefId,
+        generic_args: &[ty::GenericArg<'tcx>],
+    ) -> Self {
+        Self::WithTy(tcx.type_of(def_id).instantiate(tcx, generic_args))
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -314,6 +324,7 @@ pub enum PermitVariants {
 enum TypeRelativePath<'tcx> {
     AssocItem(DefId, GenericArgsRef<'tcx>),
     Variant { adt: Ty<'tcx>, variant_did: DefId },
+    Ctor { ctor_def_id: DefId, args: GenericArgsRef<'tcx> },
 }
 
 /// New-typed boolean indicating whether explicit late-bound lifetimes
@@ -722,7 +733,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         // Ambig portions of `ConstArg` are handled in the match arm below
                         .lower_const_arg(
                             ct.as_unambig_ct(),
-                            FeedConstTy::Param(param.def_id, preceding_args),
+                            FeedConstTy::with_type_of(tcx, param.def_id, preceding_args),
                         )
                         .into(),
                     (&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
@@ -1375,6 +1386,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let adt = self.check_param_uses_if_mcg(adt, span, false);
                 Ok((adt, DefKind::Variant, variant_did))
             }
+            TypeRelativePath::Ctor { .. } => {
+                let e = tcx.dcx().span_err(span, "expected type, found tuple constructor");
+                Err(e)
+            }
         }
     }
 
@@ -1410,6 +1425,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let ct = self.check_param_uses_if_mcg(ct, span, false);
                 Ok(ct)
             }
+            TypeRelativePath::Ctor { ctor_def_id, args } => match tcx.def_kind(ctor_def_id) {
+                DefKind::Ctor(_, CtorKind::Fn) => {
+                    Ok(ty::Const::zero_sized(tcx, Ty::new_fn_def(tcx, ctor_def_id, args)))
+                }
+                DefKind::Ctor(ctor_of, CtorKind::Const) => {
+                    Ok(self.construct_const_ctor_value(ctor_def_id, ctor_of, args))
+                }
+                _ => unreachable!(),
+            },
             // FIXME(mgca): implement support for this once ready to support all adt ctor expressions,
             // not just const ctors
             TypeRelativePath::Variant { .. } => {
@@ -1441,6 +1465,23 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     .iter()
                     .find(|vd| tcx.hygienic_eq(segment.ident, vd.ident(tcx), adt_def.did()));
                 if let Some(variant_def) = variant_def {
+                    // FIXME(mgca): do we want constructor resolutions to take priority over
+                    // other possible resolutions?
+                    if matches!(mode, LowerTypeRelativePathMode::Const)
+                        && let Some((_, ctor_def_id)) = variant_def.ctor
+                    {
+                        tcx.check_stability(variant_def.def_id, Some(qpath_hir_id), span, None);
+                        let _ = self.prohibit_generic_args(
+                            slice::from_ref(segment).iter(),
+                            GenericsArgsErrExtend::EnumVariant {
+                                qself: hir_self_ty,
+                                assoc_segment: segment,
+                                adt_def,
+                            },
+                        );
+                        let ty::Adt(_, enum_args) = self_ty.kind() else { unreachable!() };
+                        return Ok(TypeRelativePath::Ctor { ctor_def_id, args: enum_args });
+                    }
                     if let PermitVariants::Yes = mode.permit_variants() {
                         tcx.check_stability(variant_def.def_id, Some(qpath_hir_id), span, None);
                         let _ = self.prohibit_generic_args(
@@ -2149,7 +2190,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
                 self.check_param_uses_if_mcg(tcx.types.self_param, span, false)
             }
-            Res::SelfTyAlias { alias_to: def_id, forbid_generic: _, .. } => {
+            Res::SelfTyAlias { alias_to: def_id, .. } => {
                 // `Self` in impl (we know the concrete type).
                 assert_eq!(opt_self_ty, None);
                 // Try to evaluate any array length constants.
@@ -2272,15 +2313,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     pub fn lower_const_arg(
         &self,
         const_arg: &hir::ConstArg<'tcx>,
-        feed: FeedConstTy<'_, 'tcx>,
+        feed: FeedConstTy<'tcx>,
     ) -> Const<'tcx> {
         let tcx = self.tcx();
 
-        if let FeedConstTy::Param(param_def_id, args) = feed
+        if let FeedConstTy::WithTy(anon_const_type) = feed
             && let hir::ConstArgKind::Anon(anon) = &const_arg.kind
         {
-            let anon_const_type = tcx.type_of(param_def_id).instantiate(tcx, args);
-
             // FIXME(generic_const_parameter_types): Ideally we remove these errors below when
             // we have the ability to intermix typeck of anon const const args with the parent
             // bodies typeck.
@@ -2293,7 +2332,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 && (anon_const_type.has_free_regions() || anon_const_type.has_erased_regions())
             {
                 let e = self.dcx().span_err(
-                    const_arg.span(),
+                    const_arg.span,
                     "anonymous constants with lifetimes in their type are not yet supported",
                 );
                 tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
@@ -2304,7 +2343,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // variables otherwise we will ICE.
             if anon_const_type.has_non_region_infer() {
                 let e = self.dcx().span_err(
-                    const_arg.span(),
+                    const_arg.span,
                     "anonymous constants with inferred types are not yet supported",
                 );
                 tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
@@ -2314,21 +2353,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // give the anon const any of the generics from the parent.
             if anon_const_type.has_non_region_param() {
                 let e = self.dcx().span_err(
-                    const_arg.span(),
+                    const_arg.span,
                     "anonymous constants referencing generics are not yet supported",
                 );
                 tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
                 return ty::Const::new_error(tcx, e);
             }
 
-            tcx.feed_anon_const_type(
-                anon.def_id,
-                ty::EarlyBinder::bind(tcx.type_of(param_def_id).instantiate(tcx, args)),
-            );
+            tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(anon_const_type));
         }
 
         let hir_id = const_arg.hir_id;
         match const_arg.kind {
+            hir::ConstArgKind::Tup(exprs) => self.lower_const_arg_tup(exprs, feed, const_arg.span),
             hir::ConstArgKind::Path(hir::QPath::Resolved(maybe_qself, path)) => {
                 debug!(?maybe_qself, ?path);
                 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself));
@@ -2342,19 +2379,146 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     hir_self_ty,
                     segment,
                     hir_id,
-                    const_arg.span(),
+                    const_arg.span,
                 )
                 .unwrap_or_else(|guar| Const::new_error(tcx, guar))
             }
             hir::ConstArgKind::Struct(qpath, inits) => {
-                self.lower_const_arg_struct(hir_id, qpath, inits, const_arg.span())
+                self.lower_const_arg_struct(hir_id, qpath, inits, const_arg.span)
+            }
+            hir::ConstArgKind::TupleCall(qpath, args) => {
+                self.lower_const_arg_tuple_call(hir_id, qpath, args, const_arg.span)
             }
             hir::ConstArgKind::Anon(anon) => self.lower_const_arg_anon(anon),
-            hir::ConstArgKind::Infer(span, ()) => self.ct_infer(None, span),
-            hir::ConstArgKind::Error(_, e) => ty::Const::new_error(tcx, e),
+            hir::ConstArgKind::Infer(()) => self.ct_infer(None, const_arg.span),
+            hir::ConstArgKind::Error(e) => ty::Const::new_error(tcx, e),
+            hir::ConstArgKind::Literal(kind) if let FeedConstTy::WithTy(anon_const_type) = feed => {
+                self.lower_const_arg_literal(&kind, anon_const_type, const_arg.span)
+            }
+            hir::ConstArgKind::Literal(..) => {
+                let e = self.dcx().span_err(const_arg.span, "literal of unknown type");
+                ty::Const::new_error(tcx, e)
+            }
         }
     }
 
+    fn lower_const_arg_tuple_call(
+        &self,
+        hir_id: HirId,
+        qpath: hir::QPath<'tcx>,
+        args: &'tcx [&'tcx hir::ConstArg<'tcx>],
+        span: Span,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        let non_adt_or_variant_res = || {
+            let e = tcx.dcx().span_err(span, "tuple constructor with invalid base path");
+            ty::Const::new_error(tcx, e)
+        };
+
+        let ctor_const = match qpath {
+            hir::QPath::Resolved(maybe_qself, path) => {
+                let opt_self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself));
+                self.lower_resolved_const_path(opt_self_ty, path, hir_id)
+            }
+            hir::QPath::TypeRelative(hir_self_ty, segment) => {
+                let self_ty = self.lower_ty(hir_self_ty);
+                match self.lower_type_relative_const_path(
+                    self_ty,
+                    hir_self_ty,
+                    segment,
+                    hir_id,
+                    span,
+                ) {
+                    Ok(c) => c,
+                    Err(_) => return non_adt_or_variant_res(),
+                }
+            }
+        };
+
+        let Some(value) = ctor_const.try_to_value() else {
+            return non_adt_or_variant_res();
+        };
+
+        let (adt_def, adt_args, variant_did) = match value.ty.kind() {
+            ty::FnDef(def_id, fn_args)
+                if let DefKind::Ctor(CtorOf::Variant, _) = tcx.def_kind(*def_id) =>
+            {
+                let parent_did = tcx.parent(*def_id);
+                let enum_did = tcx.parent(parent_did);
+                (tcx.adt_def(enum_did), fn_args, parent_did)
+            }
+            ty::FnDef(def_id, fn_args)
+                if let DefKind::Ctor(CtorOf::Struct, _) = tcx.def_kind(*def_id) =>
+            {
+                let parent_did = tcx.parent(*def_id);
+                (tcx.adt_def(parent_did), fn_args, parent_did)
+            }
+            _ => return non_adt_or_variant_res(),
+        };
+
+        let variant_def = adt_def.variant_with_id(variant_did);
+        let variant_idx = adt_def.variant_index_with_id(variant_did).as_u32();
+
+        if args.len() != variant_def.fields.len() {
+            let e = tcx.dcx().span_err(
+                span,
+                format!(
+                    "tuple constructor has {} arguments but {} were provided",
+                    variant_def.fields.len(),
+                    args.len()
+                ),
+            );
+            return ty::Const::new_error(tcx, e);
+        }
+
+        let fields = variant_def
+            .fields
+            .iter()
+            .zip(args)
+            .map(|(field_def, arg)| {
+                self.lower_const_arg(arg, FeedConstTy::with_type_of(tcx, field_def.did, adt_args))
+            })
+            .collect::<Vec<_>>();
+
+        let opt_discr_const = if adt_def.is_enum() {
+            let valtree = ty::ValTree::from_scalar_int(tcx, variant_idx.into());
+            Some(ty::Const::new_value(tcx, valtree, tcx.types.u32))
+        } else {
+            None
+        };
+
+        let valtree = ty::ValTree::from_branches(tcx, opt_discr_const.into_iter().chain(fields));
+        let adt_ty = Ty::new_adt(tcx, adt_def, adt_args);
+        ty::Const::new_value(tcx, valtree, adt_ty)
+    }
+
+    fn lower_const_arg_tup(
+        &self,
+        exprs: &'tcx [&'tcx hir::ConstArg<'tcx>],
+        feed: FeedConstTy<'tcx>,
+        span: Span,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        let FeedConstTy::WithTy(ty) = feed else {
+            return Const::new_error_with_message(tcx, span, "unsupported const tuple");
+        };
+
+        let ty::Tuple(tys) = ty.kind() else {
+            return Const::new_error_with_message(tcx, span, "const tuple must have a tuple type");
+        };
+
+        let exprs = exprs
+            .iter()
+            .zip(tys.iter())
+            .map(|(expr, ty)| self.lower_const_arg(expr, FeedConstTy::WithTy(ty)))
+            .collect::<Vec<_>>();
+
+        let valtree = ty::ValTree::from_branches(tcx, exprs);
+        ty::Const::new_value(tcx, valtree, ty)
+    }
+
     fn lower_const_arg_struct(
         &self,
         hir_id: HirId,
@@ -2433,7 +2597,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             return ty::Const::new_error(tcx, e);
                         }
 
-                        self.lower_const_arg(expr.expr, FeedConstTy::Param(field_def.did, adt_args))
+                        self.lower_const_arg(
+                            expr.expr,
+                            FeedConstTy::with_type_of(tcx, field_def.did, adt_args),
+                        )
                     }
                     None => {
                         let e = tcx.dcx().span_err(
@@ -2478,7 +2645,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
                 self.lower_const_param(def_id, hir_id)
             }
-            Res::Def(DefKind::Const | DefKind::Ctor(_, CtorKind::Const), did) => {
+            Res::Def(DefKind::Const, did) => {
                 assert_eq!(opt_self_ty, None);
                 let [leading_segments @ .., segment] = path.segments else { bug!() };
                 let _ = self
@@ -2486,6 +2653,35 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let args = self.lower_generic_args_of_path_segment(span, did, segment);
                 ty::Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(did, args))
             }
+            Res::Def(DefKind::Ctor(ctor_of, CtorKind::Const), did) => {
+                assert_eq!(opt_self_ty, None);
+                let [leading_segments @ .., segment] = path.segments else { bug!() };
+                let _ = self
+                    .prohibit_generic_args(leading_segments.iter(), GenericsArgsErrExtend::None);
+
+                let parent_did = tcx.parent(did);
+                let generics_did = match ctor_of {
+                    CtorOf::Variant => tcx.parent(parent_did),
+                    CtorOf::Struct => parent_did,
+                };
+                let args = self.lower_generic_args_of_path_segment(span, generics_did, segment);
+
+                self.construct_const_ctor_value(did, ctor_of, args)
+            }
+            Res::Def(DefKind::Ctor(_, CtorKind::Fn), did) => {
+                assert_eq!(opt_self_ty, None);
+                let [leading_segments @ .., segment] = path.segments else { bug!() };
+                let _ = self
+                    .prohibit_generic_args(leading_segments.iter(), GenericsArgsErrExtend::None);
+                let parent_did = tcx.parent(did);
+                let generics_did = if let DefKind::Ctor(CtorOf::Variant, _) = tcx.def_kind(did) {
+                    tcx.parent(parent_did)
+                } else {
+                    parent_did
+                };
+                let args = self.lower_generic_args_of_path_segment(span, generics_did, segment);
+                ty::Const::zero_sized(tcx, Ty::new_fn_def(tcx, did, args))
+            }
             Res::Def(DefKind::AssocConst, did) => {
                 let trait_segment = if let [modules @ .., trait_, _item] = path.segments {
                     let _ = self.prohibit_generic_args(modules.iter(), GenericsArgsErrExtend::None);
@@ -2521,9 +2717,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 DefKind::Mod
                 | DefKind::Enum
                 | DefKind::Variant
-                | DefKind::Ctor(CtorOf::Variant, CtorKind::Fn)
                 | DefKind::Struct
-                | DefKind::Ctor(CtorOf::Struct, CtorKind::Fn)
                 | DefKind::OpaqueTy
                 | DefKind::TyAlias
                 | DefKind::TraitAlias
@@ -2587,6 +2781,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
+    #[instrument(skip(self), level = "debug")]
+    fn lower_const_arg_literal(&self, kind: &LitKind, ty: Ty<'tcx>, span: Span) -> Const<'tcx> {
+        let tcx = self.tcx();
+        let input = LitToConstInput { lit: *kind, ty, neg: false };
+        tcx.at(span).lit_to_const(input)
+    }
+
     #[instrument(skip(self), level = "debug")]
     fn try_lower_anon_const_lit(
         &self,
@@ -3043,4 +3244,31 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
         Some(r)
     }
+
+    fn construct_const_ctor_value(
+        &self,
+        ctor_def_id: DefId,
+        ctor_of: CtorOf,
+        args: GenericArgsRef<'tcx>,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+        let parent_did = tcx.parent(ctor_def_id);
+
+        let adt_def = tcx.adt_def(match ctor_of {
+            CtorOf::Variant => tcx.parent(parent_did),
+            CtorOf::Struct => parent_did,
+        });
+
+        let variant_idx = adt_def.variant_index_with_id(parent_did);
+
+        let valtree = if adt_def.is_enum() {
+            let discr = ty::ValTree::from_scalar_int(tcx, variant_idx.as_u32().into());
+            ty::ValTree::from_branches(tcx, [ty::Const::new_value(tcx, discr, tcx.types.u32)])
+        } else {
+            ty::ValTree::zst(tcx)
+        };
+
+        let adt_ty = Ty::new_adt(tcx, adt_def, args);
+        ty::Const::new_value(tcx, valtree, adt_ty)
+    }
 }
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 65f6a11e8e9b..7296ba6f964a 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -301,7 +301,7 @@ pub fn lower_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
 pub fn lower_const_arg_for_rustdoc<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_ct: &hir::ConstArg<'tcx>,
-    feed: FeedConstTy<'_, 'tcx>,
+    feed: FeedConstTy<'tcx>,
 ) -> Const<'tcx> {
     let env_def_id = tcx.hir_get_parent_item(hir_ct.hir_id);
     collect::ItemCtxt::new(tcx, env_def_id.def_id).lowerer().lower_const_arg(hir_ct, feed)
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 5c03135ee1bf..37fa18c00887 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -17,12 +17,12 @@ use rustc_ast_pretty::pprust::state::MacHeader;
 use rustc_ast_pretty::pprust::{Comments, PrintState};
 use rustc_hir::attrs::{AttributeKind, PrintAttribute};
 use rustc_hir::{
-    BindingMode, ByRef, ConstArgKind, GenericArg, GenericBound, GenericParam, GenericParamKind,
-    HirId, ImplicitSelfKind, LifetimeParamKind, Node, PatKind, PreciseCapturingArg, RangeEnd, Term,
-    TyPatKind,
+    BindingMode, ByRef, ConstArg, ConstArgExprField, ConstArgKind, GenericArg, GenericBound,
+    GenericParam, GenericParamKind, HirId, ImplicitSelfKind, LifetimeParamKind, Node, PatKind,
+    PreciseCapturingArg, RangeEnd, Term, TyPatKind,
 };
-use rustc_span::source_map::SourceMap;
-use rustc_span::{FileName, Ident, Span, Symbol, kw, sym};
+use rustc_span::source_map::{SourceMap, Spanned};
+use rustc_span::{DUMMY_SP, FileName, Ident, Span, Symbol, kw, sym};
 use {rustc_ast as ast, rustc_hir as hir};
 
 pub fn id_to_string(cx: &dyn rustc_hir::intravisit::HirTyCtxt<'_>, hir_id: HirId) -> String {
@@ -136,7 +136,11 @@ impl<'a> State<'a> {
                 .path
                 .segments
                 .iter()
-                .map(|i| ast::PathSegment { ident: *i, args: None, id: DUMMY_NODE_ID })
+                .map(|i| ast::PathSegment {
+                    ident: Ident { name: *i, span: DUMMY_SP },
+                    args: None,
+                    id: DUMMY_NODE_ID,
+                })
                 .collect(),
             tokens: None,
         };
@@ -1137,15 +1141,54 @@ impl<'a> State<'a> {
 
     fn print_const_arg(&mut self, const_arg: &hir::ConstArg<'_>) {
         match &const_arg.kind {
-            // FIXME(mgca): proper printing for struct exprs
-            ConstArgKind::Struct(..) => self.word("/* STRUCT EXPR */"),
+            ConstArgKind::Tup(exprs) => {
+                self.popen();
+                self.commasep_cmnt(
+                    Inconsistent,
+                    exprs,
+                    |s, arg| s.print_const_arg(arg),
+                    |arg| arg.span,
+                );
+                self.pclose();
+            }
+            ConstArgKind::Struct(qpath, fields) => self.print_const_struct(qpath, fields),
+            ConstArgKind::TupleCall(qpath, args) => self.print_const_ctor(qpath, args),
             ConstArgKind::Path(qpath) => self.print_qpath(qpath, true),
             ConstArgKind::Anon(anon) => self.print_anon_const(anon),
-            ConstArgKind::Error(_, _) => self.word("/*ERROR*/"),
+            ConstArgKind::Error(_) => self.word("/*ERROR*/"),
             ConstArgKind::Infer(..) => self.word("_"),
+            ConstArgKind::Literal(node) => {
+                let span = const_arg.span;
+                self.print_literal(&Spanned { span, node: *node })
+            }
         }
     }
 
+    fn print_const_struct(&mut self, qpath: &hir::QPath<'_>, fields: &&[&ConstArgExprField<'_>]) {
+        self.print_qpath(qpath, true);
+        self.word(" ");
+        self.word("{");
+        if !fields.is_empty() {
+            self.nbsp();
+        }
+        self.commasep(Inconsistent, *fields, |s, field| {
+            s.word(field.field.as_str().to_string());
+            s.word(":");
+            s.nbsp();
+            s.print_const_arg(field.expr);
+        });
+        self.word("}");
+    }
+
+    fn print_const_ctor(&mut self, qpath: &hir::QPath<'_>, args: &&[&ConstArg<'_, ()>]) {
+        self.print_qpath(qpath, true);
+        self.word("(");
+        self.commasep(Inconsistent, *args, |s, arg| {
+            s.print_const_arg(arg);
+        });
+        self.word(")");
+    }
+
     fn print_call_post(&mut self, args: &[hir::Expr<'_>]) {
         self.popen();
         self.commasep_exprs(Inconsistent, args);
diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
index 325be43a0065..0c4b1f891ead 100644
--- a/compiler/rustc_hir_typeck/messages.ftl
+++ b/compiler/rustc_hir_typeck/messages.ftl
@@ -133,6 +133,10 @@ hir_typeck_fru_suggestion =
 hir_typeck_functional_record_update_on_non_struct =
     functional record update syntax requires a struct
 
+hir_typeck_gpu_kernel_abi_cannot_be_called =
+    functions with the "gpu-kernel" ABI cannot be called
+    .note = an `extern "gpu-kernel"` function must be launched on the GPU by the runtime
+
 hir_typeck_help_set_edition_cargo = set `edition = "{$edition}"` in `Cargo.toml`
 hir_typeck_help_set_edition_standalone = pass `--edition {$edition}` to `rustc`
 
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 714c6a104a9e..b60d053957a9 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -169,27 +169,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         };
 
-        let valid = match canon_abi {
+        match canon_abi {
             // Rust doesn't know how to call functions with this ABI.
-            CanonAbi::Custom => false,
-
-            // These is an entry point for the host, and cannot be called on the GPU.
-            CanonAbi::GpuKernel => false,
-
+            CanonAbi::Custom
             // The interrupt ABIs should only be called by the CPU. They have complex
             // pre- and postconditions, and can use non-standard instructions like `iret` on x86.
-            CanonAbi::Interrupt(_) => false,
+            | CanonAbi::Interrupt(_) => {
+                let err = crate::errors::AbiCannotBeCalled { span, abi };
+                self.tcx.dcx().emit_err(err);
+            }
+
+            // This is an entry point for the host, and cannot be called directly.
+            CanonAbi::GpuKernel => {
+                let err = crate::errors::GpuKernelAbiCannotBeCalled { span };
+                self.tcx.dcx().emit_err(err);
+            }
 
             CanonAbi::C
             | CanonAbi::Rust
             | CanonAbi::RustCold
             | CanonAbi::Arm(_)
-            | CanonAbi::X86(_) => true,
-        };
-
-        if !valid {
-            let err = crate::errors::AbiCannotBeCalled { span, abi };
-            self.tcx.dcx().emit_err(err);
+            | CanonAbi::X86(_) => {}
         }
     }
 
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 5e1e567d103e..52ea6cdeaa0e 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -54,7 +54,7 @@ use rustc_middle::ty::adjustment::{
 };
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
-use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Span};
+use rustc_span::{BytePos, DUMMY_SP, Span};
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::solve::inspect::{self, InferCtxtProofTreeExt, ProofTreeVisitor};
 use rustc_trait_selection::solve::{Certainty, Goal, NoSolution};
@@ -1828,10 +1828,9 @@ impl<'tcx> CoerceMany<'tcx> {
                 // If the block is from an external macro or try (`?`) desugaring, then
                 // do not suggest adding a semicolon, because there's nowhere to put it.
                 // See issues #81943 and #87051.
-                && matches!(
-                    cond_expr.span.desugaring_kind(),
-                    None | Some(DesugaringKind::WhileLoop)
-                )
+                // Similarly, if the block is from a loop desugaring, then also do not
+                // suggest adding a semicolon. See issue #150850.
+                && cond_expr.span.desugaring_kind().is_none()
                 && !cond_expr.span.in_external_macro(fcx.tcx.sess.source_map())
                 && !matches!(
                     cond_expr.kind,
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 620002915fa8..0cf7f09e9376 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -1198,6 +1198,14 @@ pub(crate) struct AbiCannotBeCalled {
     pub abi: ExternAbi,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_typeck_gpu_kernel_abi_cannot_be_called)]
+pub(crate) struct GpuKernelAbiCannotBeCalled {
+    #[primary_span]
+    #[note]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_typeck_const_continue_bad_label)]
 pub(crate) struct ConstContinueBadLabel {
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index c4fa39c6c2c8..9d7e09b020a7 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1705,7 +1705,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return;
         };
         if let hir::TyKind::Array(_, ct) = ty.peel_refs().kind {
-            let span = ct.span();
+            let span = ct.span;
             self.dcx().try_steal_modify_and_emit_err(
                 span,
                 StashKey::UnderscoreForArrayLengths,
@@ -1746,7 +1746,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expr: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
         let tcx = self.tcx;
-        let count_span = count.span();
+        let count_span = count.span;
         let count = self.try_structurally_resolve_const(
             count_span,
             self.normalize(count_span, self.lower_const_arg(count, FeedConstTy::No)),
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 339e77ac6edd..a66ff2a23c25 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -525,7 +525,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(crate) fn lower_const_arg(
         &self,
         const_arg: &'tcx hir::ConstArg<'tcx>,
-        feed: FeedConstTy<'_, 'tcx>,
+        feed: FeedConstTy<'tcx>,
     ) -> ty::Const<'tcx> {
         let ct = self.lowerer().lower_const_arg(const_arg, feed);
         self.register_wf_obligation(
@@ -1228,7 +1228,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         // Ambiguous parts of `ConstArg` are handled in the match arms below
                         .lower_const_arg(
                             ct.as_unambig_ct(),
-                            FeedConstTy::Param(param.def_id, preceding_args),
+                            FeedConstTy::with_type_of(self.fcx.tcx, param.def_id, preceding_args),
                         )
                         .into(),
                     (&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index d51b052e0d1b..3e4c194147f9 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -10,8 +10,8 @@ use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{
     self as hir, Arm, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind,
-    GenericBound, HirId, Node, PatExpr, PatExprKind, Path, QPath, Stmt, StmtKind, TyKind,
-    WherePredicateKind, expr_needs_parens, is_range_literal,
+    GenericBound, HirId, LoopSource, Node, PatExpr, PatExprKind, Path, QPath, Stmt, StmtKind,
+    TyKind, WherePredicateKind, expr_needs_parens, is_range_literal,
 };
 use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
 use rustc_hir_analysis::suggest_impl_trait;
@@ -1170,15 +1170,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
         let found = self.resolve_vars_if_possible(found);
 
-        let in_loop = self.is_loop(id)
-            || self
-                .tcx
+        let innermost_loop = if self.is_loop(id) {
+            Some(self.tcx.hir_node(id))
+        } else {
+            self.tcx
                 .hir_parent_iter(id)
                 .take_while(|(_, node)| {
                     // look at parents until we find the first body owner
                     node.body_id().is_none()
                 })
-                .any(|(parent_id, _)| self.is_loop(parent_id));
+                .find_map(|(parent_id, node)| self.is_loop(parent_id).then_some(node))
+        };
+        let can_break_with_value = innermost_loop.is_some_and(|node| {
+            matches!(
+                node,
+                Node::Expr(Expr { kind: ExprKind::Loop(_, _, LoopSource::Loop, ..), .. })
+            )
+        });
 
         let in_local_statement = self.is_local_statement(id)
             || self
@@ -1186,7 +1194,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .hir_parent_iter(id)
                 .any(|(parent_id, _)| self.is_local_statement(parent_id));
 
-        if in_loop && in_local_statement {
+        if can_break_with_value && in_local_statement {
             err.multipart_suggestion(
                 "you might have meant to break the loop with this value",
                 vec![
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index e81537008bb5..aab4e3985555 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -447,7 +447,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                         // We handle the ambig portions of `ConstArg` in the match arms below
                         .lower_const_arg(
                             ct.as_unambig_ct(),
-                            FeedConstTy::Param(param.def_id, preceding_args),
+                            FeedConstTy::with_type_of(self.cfcx.tcx, param.def_id, preceding_args),
                         )
                         .into(),
                     (GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 1a25f6a582f2..beb0337d8c59 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -190,8 +190,8 @@ impl PickConstraintsForShadowed {
         // An item never shadows itself
         candidate.item.def_id != self.def_id
             // and we're only concerned about inherent impls doing the shadowing.
-            // Shadowing can only occur if the shadowed is further along
-            // the Receiver dereferencing chain than the shadowed.
+            // Shadowing can only occur if the impl being shadowed is further along
+            // the Receiver dereferencing chain than the impl doing the shadowing.
             && match candidate.kind {
                 CandidateKind::InherentImplCandidate { receiver_steps, .. } => match self.receiver_steps {
                     Some(shadowed_receiver_steps) => receiver_steps > shadowed_receiver_steps,
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index c07b41b56caa..23f6fee406a5 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -289,7 +289,7 @@ struct Canonicalizer<'cx, 'tcx> {
     /// Set to `None` to disable the resolution of inference variables.
     infcx: Option<&'cx InferCtxt<'tcx>>,
     tcx: TyCtxt<'tcx>,
-    variables: SmallVec<[CanonicalVarKind<'tcx>; 8]>,
+    var_kinds: SmallVec<[CanonicalVarKind<'tcx>; 8]>,
     query_state: &'cx mut OriginalQueryValues<'tcx>,
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
@@ -507,7 +507,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     {
         let base = Canonical {
             max_universe: ty::UniverseIndex::ROOT,
-            variables: List::empty(),
+            var_kinds: List::empty(),
             value: (),
         };
         Canonicalizer::canonicalize_with_base(
@@ -548,7 +548,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             tcx,
             canonicalize_mode: canonicalize_region_mode,
             needs_canonical_flags,
-            variables: SmallVec::from_slice(base.variables),
+            var_kinds: SmallVec::from_slice(base.var_kinds),
             query_state,
             indices: FxHashMap::default(),
             sub_root_lookup_table: Default::default(),
@@ -569,16 +569,16 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         // anymore.
         debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());
 
-        let canonical_variables =
-            tcx.mk_canonical_var_kinds(&canonicalizer.universe_canonicalized_variables());
+        let canonical_var_kinds =
+            tcx.mk_canonical_var_kinds(&canonicalizer.universe_canonicalized_var_kinds());
 
-        let max_universe = canonical_variables
+        let max_universe = canonical_var_kinds
             .iter()
             .map(|cvar| cvar.universe())
             .max()
             .unwrap_or(ty::UniverseIndex::ROOT);
 
-        Canonical { max_universe, variables: canonical_variables, value: (base.value, out_value) }
+        Canonical { max_universe, var_kinds: canonical_var_kinds, value: (base.value, out_value) }
     }
 
     /// Creates a canonical variable replacing `kind` from the input,
@@ -590,7 +590,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         var_kind: CanonicalVarKind<'tcx>,
         value: GenericArg<'tcx>,
     ) -> BoundVar {
-        let Canonicalizer { variables, query_state, indices, .. } = self;
+        let Canonicalizer { var_kinds, query_state, indices, .. } = self;
 
         let var_values = &mut query_state.var_values;
 
@@ -607,7 +607,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             }
         }
 
-        // This code is hot. `variables` and `var_values` are usually small
+        // This code is hot. `var_kinds` and `var_values` are usually small
         // (fewer than 8 elements ~95% of the time). They are SmallVec's to
         // avoid allocations in those cases. We also don't use `indices` to
         // determine if a kind has been seen before until the limit of 8 has
@@ -620,10 +620,10 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
                 BoundVar::new(idx)
             } else {
                 // `kind` isn't present in `var_values`. Append it. Likewise
-                // for `var_kind` and `variables`.
-                variables.push(var_kind);
+                // for `var_kind` and `var_kinds`.
+                var_kinds.push(var_kind);
                 var_values.push(value);
-                assert_eq!(variables.len(), var_values.len());
+                assert_eq!(var_kinds.len(), var_values.len());
 
                 // If `var_values` has become big enough to be heap-allocated,
                 // fill up `indices` to facilitate subsequent lookups.
@@ -641,10 +641,10 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         } else {
             // `var_values` is large. Do a hashmap search via `indices`.
             *indices.entry(value).or_insert_with(|| {
-                variables.push(var_kind);
+                var_kinds.push(var_kind);
                 var_values.push(value);
-                assert_eq!(variables.len(), var_values.len());
-                BoundVar::new(variables.len() - 1)
+                assert_eq!(var_kinds.len(), var_values.len());
+                BoundVar::new(var_kinds.len() - 1)
             })
         }
     }
@@ -652,16 +652,16 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     fn get_or_insert_sub_root(&mut self, vid: ty::TyVid) -> ty::BoundVar {
         let root_vid = self.infcx.unwrap().sub_unification_table_root_var(vid);
         let idx =
-            *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
+            *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.var_kinds.len());
         ty::BoundVar::from(idx)
     }
 
     /// Replaces the universe indexes used in `var_values` with their index in
     /// `query_state.universe_map`. This minimizes the maximum universe used in
     /// the canonicalized value.
-    fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind<'tcx>; 8]> {
+    fn universe_canonicalized_var_kinds(self) -> SmallVec<[CanonicalVarKind<'tcx>; 8]> {
         if self.query_state.universe_map.len() == 1 {
-            return self.variables;
+            return self.var_kinds;
         }
 
         let reverse_universe_map: FxHashMap<ty::UniverseIndex, ty::UniverseIndex> = self
@@ -672,7 +672,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             .map(|(idx, universe)| (*universe, ty::UniverseIndex::from_usize(idx)))
             .collect();
 
-        self.variables
+        self.var_kinds
             .iter()
             .map(|&kind| match kind {
                 CanonicalVarKind::Int | CanonicalVarKind::Float => {
diff --git a/compiler/rustc_infer/src/infer/canonical/instantiate.rs b/compiler/rustc_infer/src/infer/canonical/instantiate.rs
index c215a9db2a0a..66a7bd2fc636 100644
--- a/compiler/rustc_infer/src/infer/canonical/instantiate.rs
+++ b/compiler/rustc_infer/src/infer/canonical/instantiate.rs
@@ -43,7 +43,7 @@ impl<'tcx, V> Canonical<'tcx, V> {
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
-        assert_eq!(self.variables.len(), var_values.len());
+        assert_eq!(self.var_kinds.len(), var_values.len());
         let value = projection_fn(&self.value);
         instantiate_value(tcx, var_values, value)
     }
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 9af0e17be4e2..c6826d774216 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -68,7 +68,7 @@ impl<'tcx> InferCtxt<'tcx> {
             .collect();
 
         let var_values =
-            CanonicalVarValues::instantiate(self.tcx, &canonical.variables, |var_values, info| {
+            CanonicalVarValues::instantiate(self.tcx, &canonical.var_kinds, |var_values, info| {
                 self.instantiate_canonical_var(span, info, &var_values, |ui| universes[ui])
             });
         let result = canonical.instantiate(self.tcx, &var_values);
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index b4952e7bfe15..65b0f8211432 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -430,7 +430,7 @@ impl<'tcx> InferCtxt<'tcx> {
         // result, then we can type the corresponding value from the
         // input. See the example above.
         let mut opt_values: IndexVec<BoundVar, Option<GenericArg<'tcx>>> =
-            IndexVec::from_elem_n(None, query_response.variables.len());
+            IndexVec::from_elem_n(None, query_response.var_kinds.len());
 
         for (original_value, result_value) in iter::zip(&original_values.var_values, result_values)
         {
@@ -442,7 +442,7 @@ impl<'tcx> InferCtxt<'tcx> {
                     // more involved. They are also a lot rarer than region variables.
                     if let ty::Bound(index_kind, b) = *result_value.kind()
                         && !matches!(
-                            query_response.variables[b.var.as_usize()],
+                            query_response.var_kinds[b.var.as_usize()],
                             CanonicalVarKind::Ty { .. }
                         )
                     {
@@ -472,8 +472,8 @@ impl<'tcx> InferCtxt<'tcx> {
         // given variable in the loop above, use that. Otherwise, use
         // a fresh inference variable.
         let tcx = self.tcx;
-        let variables = query_response.variables;
-        let var_values = CanonicalVarValues::instantiate(tcx, variables, |var_values, kind| {
+        let var_kinds = query_response.var_kinds;
+        let var_values = CanonicalVarValues::instantiate(tcx, var_kinds, |var_values, kind| {
             if kind.universe() != ty::UniverseIndex::ROOT {
                 // A variable from inside a binder of the query. While ideally these shouldn't
                 // exist at all, we have to deal with them for now.
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index c0f8f33692e8..b2c4a9158197 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -55,7 +55,11 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
     cfgs.into_iter()
         .map(|s| {
             let psess = ParseSess::emitter_with_note(
-                vec![crate::DEFAULT_LOCALE_RESOURCE, rustc_parse::DEFAULT_LOCALE_RESOURCE],
+                vec![
+                    crate::DEFAULT_LOCALE_RESOURCE,
+                    rustc_parse::DEFAULT_LOCALE_RESOURCE,
+                    rustc_session::DEFAULT_LOCALE_RESOURCE,
+                ],
                 format!("this occurred on the command line: `--cfg={s}`"),
             );
             let filename = FileName::cfg_spec_source_code(&s);
@@ -129,7 +133,11 @@ pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> Ch
 
     for s in specs {
         let psess = ParseSess::emitter_with_note(
-            vec![crate::DEFAULT_LOCALE_RESOURCE, rustc_parse::DEFAULT_LOCALE_RESOURCE],
+            vec![
+                crate::DEFAULT_LOCALE_RESOURCE,
+                rustc_parse::DEFAULT_LOCALE_RESOURCE,
+                rustc_session::DEFAULT_LOCALE_RESOURCE,
+            ],
             format!("this occurred on the command line: `--check-cfg={s}`"),
         );
         let filename = FileName::cfg_spec_source_code(&s);
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 1160bd9ffa74..b49b090272d4 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -472,6 +472,9 @@ lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
 
 lint_improper_ctypes_unsafe_binder = unsafe binders are incompatible with foreign function interfaces
 
+lint_improper_gpu_kernel_arg = passing type `{$ty}` to a function with "gpu-kernel" ABI may have unexpected behavior
+    .help = use primitive types and raw pointers to get reliable behavior
+
 lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a pointer without provenance
     .note = this is dangerous because dereferencing the resulting pointer is undefined behavior
     .note_exposed_provenance = exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
@@ -599,6 +602,10 @@ lint_mismatched_lifetime_syntaxes_suggestion_mixed =
 lint_mismatched_lifetime_syntaxes_suggestion_mixed_only_paths =
     use `'_` for type paths
 
+lint_missing_gpu_kernel_export_name = function with the "gpu-kernel" ABI has a mangled name
+    .note = mangled names make it hard to find the kernel, this is usually not intended
+    .help = use `unsafe(no_mangle)` or `unsafe(export_name = "<name>")`
+
 lint_mixed_script_confusables =
     the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
     .includes_note = the usage includes {$includes}
diff --git a/compiler/rustc_lint/src/gpukernel_abi.rs b/compiler/rustc_lint/src/gpukernel_abi.rs
new file mode 100644
index 000000000000..dbdf5b6e7955
--- /dev/null
+++ b/compiler/rustc_lint/src/gpukernel_abi.rs
@@ -0,0 +1,194 @@
+use std::iter;
+
+use rustc_abi::ExternAbi;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{self as hir, find_attr};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable};
+use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::Span;
+use rustc_span::def_id::LocalDefId;
+
+use crate::lints::{ImproperGpuKernelArg, MissingGpuKernelExportName};
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `improper_gpu_kernel_arg` lint detects incorrect use of types in `gpu-kernel`
+    /// arguments.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (fails on non-GPU targets)
+    /// #[unsafe(no_mangle)]
+    /// extern "gpu-kernel" fn kernel(_: [i32; 10]) {}
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// warning: passing type `[i32; 10]` to a function with "gpu-kernel" ABI may have unexpected behavior
+    ///  --> t.rs:2:34
+    ///   |
+    /// 2 | extern "gpu-kernel" fn kernel(_: [i32; 10]) {}
+    ///   |                                  ^^^^^^^^^
+    ///   |
+    ///   = help: use primitive types and raw pointers to get reliable behavior
+    ///   = note: `#[warn(improper_gpu_kernel_arg)]` on by default
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// The compiler has several checks to verify that types used as arguments in `gpu-kernel`
+    /// functions follow certain rules to ensure proper compatibility with the foreign interfaces.
+    /// This lint is issued when it detects a probable mistake in a signature.
+    IMPROPER_GPU_KERNEL_ARG,
+    Warn,
+    "GPU kernel entry points have a limited ABI"
+}
+
+declare_lint! {
+    /// The `missing_gpu_kernel_export_name` lint detects `gpu-kernel` functions that have a mangled name.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (fails on non-GPU targets)
+    /// extern "gpu-kernel" fn kernel() { }
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// warning: function with the "gpu-kernel" ABI has a mangled name
+    ///  --> t.rs:1:1
+    ///   |
+    /// 1 | extern "gpu-kernel" fn kernel() {}
+    ///   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    ///   |
+    ///   = help: use `unsafe(no_mangle)` or `unsafe(export_name = "<name>")`
+    ///   = note: mangled names make it hard to find the kernel, this is usually not intended
+    ///   = note: `#[warn(missing_gpu_kernel_export_name)]` on by default
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// `gpu-kernel` functions are usually searched by name in the compiled file.
+    /// A mangled name is usually unintentional as it would need to be searched by the mangled name.
+    ///
+    /// To use an unmangled name for the kernel, either `no_mangle` or `export_name` can be used.
+    /// ```rust,ignore (fails on non-GPU targets)
+    /// // Can be found by the name "kernel"
+    /// #[unsafe(no_mangle)]
+    /// extern "gpu-kernel" fn kernel() { }
+    ///
+    /// // Can be found by the name "new_name"
+    /// #[unsafe(export_name = "new_name")]
+    /// extern "gpu-kernel" fn other_kernel() { }
+    /// ```
+    MISSING_GPU_KERNEL_EXPORT_NAME,
+    Warn,
+    "mangled gpu-kernel function"
+}
+
+declare_lint_pass!(ImproperGpuKernelLint => [
+    IMPROPER_GPU_KERNEL_ARG,
+    MISSING_GPU_KERNEL_EXPORT_NAME,
+]);
+
+/// Check for valid and invalid types.
+struct CheckGpuKernelTypes<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    // If one or more invalid types were encountered while folding.
+    has_invalid: bool,
+}
+
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CheckGpuKernelTypes<'tcx> {
+    fn cx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+        match ty.kind() {
+            ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => {}
+            // Thin pointers are allowed but fat pointers with metadata are not
+            ty::RawPtr(_, _) => {
+                if !ty.pointee_metadata_ty_or_projection(self.tcx).is_unit() {
+                    self.has_invalid = true;
+                }
+            }
+
+            ty::Adt(_, _)
+            | ty::Alias(_, _)
+            | ty::Array(_, _)
+            | ty::Bound(_, _)
+            | ty::Closure(_, _)
+            | ty::Coroutine(_, _)
+            | ty::CoroutineClosure(_, _)
+            | ty::CoroutineWitness(..)
+            | ty::Dynamic(_, _)
+            | ty::FnDef(_, _)
+            | ty::FnPtr(..)
+            | ty::Foreign(_)
+            | ty::Never
+            | ty::Pat(_, _)
+            | ty::Placeholder(_)
+            | ty::Ref(_, _, _)
+            | ty::Slice(_)
+            | ty::Str
+            | ty::Tuple(_) => self.has_invalid = true,
+
+            _ => return ty.super_fold_with(self),
+        }
+        ty
+    }
+}
+
+/// `ImproperGpuKernelLint` checks `gpu-kernel` function definitions:
+///
+/// - `extern "gpu-kernel" fn` arguments should be primitive types.
+/// - `extern "gpu-kernel" fn` should have an unmangled name.
+impl<'tcx> LateLintPass<'tcx> for ImproperGpuKernelLint {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: hir::intravisit::FnKind<'tcx>,
+        decl: &'tcx hir::FnDecl<'_>,
+        _: &'tcx hir::Body<'_>,
+        span: Span,
+        id: LocalDefId,
+    ) {
+        use hir::intravisit::FnKind;
+
+        let abi = match kind {
+            FnKind::ItemFn(_, _, header, ..) => header.abi,
+            FnKind::Method(_, sig, ..) => sig.header.abi,
+            _ => return,
+        };
+
+        if abi != ExternAbi::GpuKernel {
+            return;
+        }
+
+        let sig = cx.tcx.fn_sig(id).instantiate_identity();
+        let sig = cx.tcx.instantiate_bound_regions_with_erased(sig);
+
+        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
+            let mut checker = CheckGpuKernelTypes { tcx: cx.tcx, has_invalid: false };
+            input_ty.fold_with(&mut checker);
+            if checker.has_invalid {
+                cx.tcx.emit_node_span_lint(
+                    IMPROPER_GPU_KERNEL_ARG,
+                    input_hir.hir_id,
+                    input_hir.span,
+                    ImproperGpuKernelArg { ty: *input_ty },
+                );
+            }
+        }
+
+        // Check for no_mangle/export_name, so the kernel can be found when querying the compiled object for the kernel function by name
+        if !find_attr!(
+            cx.tcx.get_all_attrs(id),
+            AttributeKind::NoMangle(..) | AttributeKind::ExportName { .. }
+        ) {
+            cx.emit_span_lint(MISSING_GPU_KERNEL_EXPORT_NAME, span, MissingGpuKernelExportName);
+        }
+    }
+}
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 4e7a3e405176..ec7ce1ade929 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -46,6 +46,7 @@ mod expect;
 mod for_loops_over_fallibles;
 mod foreign_modules;
 mod function_cast_as_integer;
+mod gpukernel_abi;
 mod if_let_rescope;
 mod impl_trait_overcaptures;
 mod interior_mutable_consts;
@@ -92,6 +93,7 @@ use drop_forget_useless::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
 use for_loops_over_fallibles::*;
 use function_cast_as_integer::*;
+use gpukernel_abi::*;
 use if_let_rescope::IfLetRescope;
 use impl_trait_overcaptures::ImplTraitOvercaptures;
 use interior_mutable_consts::*;
@@ -196,6 +198,7 @@ late_lint_methods!(
             DerefIntoDynSupertrait: DerefIntoDynSupertrait,
             DropForgetUseless: DropForgetUseless,
             ImproperCTypesLint: ImproperCTypesLint,
+            ImproperGpuKernelLint: ImproperGpuKernelLint,
             InvalidFromUtf8: InvalidFromUtf8,
             VariantSizeDifferences: VariantSizeDifferences,
             PathStatements: PathStatements,
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index fde9546bd1c7..841b11c99687 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2009,6 +2009,19 @@ impl<'a> LintDiagnostic<'a, ()> for ImproperCTypes<'_> {
     }
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_improper_gpu_kernel_arg)]
+#[help]
+pub(crate) struct ImproperGpuKernelArg<'a> {
+    pub ty: Ty<'a>,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_missing_gpu_kernel_export_name)]
+#[help]
+#[note]
+pub(crate) struct MissingGpuKernelExportName;
+
 #[derive(LintDiagnostic)]
 #[diag(lint_variant_size_differences)]
 pub(crate) struct VariantSizeDifferencesDiag {
diff --git a/compiler/rustc_lint/src/pass_by_value.rs b/compiler/rustc_lint/src/pass_by_value.rs
index 29006732aade..f4a506d50a41 100644
--- a/compiler/rustc_lint/src/pass_by_value.rs
+++ b/compiler/rustc_lint/src/pass_by_value.rs
@@ -74,12 +74,9 @@ fn gen_args(cx: &LateContext<'_>, segment: &PathSegment<'_>) -> String {
                 GenericArg::Type(ty) => {
                     cx.tcx.sess.source_map().span_to_snippet(ty.span).unwrap_or_else(|_| "_".into())
                 }
-                GenericArg::Const(c) => cx
-                    .tcx
-                    .sess
-                    .source_map()
-                    .span_to_snippet(c.span())
-                    .unwrap_or_else(|_| "_".into()),
+                GenericArg::Const(c) => {
+                    cx.tcx.sess.source_map().span_to_snippet(c.span).unwrap_or_else(|_| "_".into())
+                }
                 GenericArg::Infer(_) => String::from("_"),
             })
             .collect::<Vec<_>>();
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 0ba54e3829f5..506a16355e22 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -1190,6 +1190,8 @@ impl UnusedParens {
                 // `&(a..=b)`, there is a recursive `check_pat` on `a` and `b`, but we will assume
                 // that if there are unnecessary parens they serve a purpose of readability.
                 PatKind::Range(..) => return,
+                // Parentheses may be necessary to disambiguate precedence in guard patterns.
+                PatKind::Guard(..) => return,
                 // Avoid `p0 | .. | pn` if we should.
                 PatKind::Or(..) if avoid_or => return,
                 // Avoid `mut x` and `mut x @ p` if we should:
diff --git a/compiler/rustc_metadata/src/eii.rs b/compiler/rustc_metadata/src/eii.rs
index 5558ff930851..b06ac8481397 100644
--- a/compiler/rustc_metadata/src/eii.rs
+++ b/compiler/rustc_metadata/src/eii.rs
@@ -1,5 +1,5 @@
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_hir::attrs::{AttributeKind, EiiDecl, EiiImpl};
+use rustc_hir::attrs::{AttributeKind, EiiDecl, EiiImpl, EiiImplResolution};
 use rustc_hir::def_id::DefId;
 use rustc_hir::find_attr;
 use rustc_middle::query::LocalCrate;
@@ -9,7 +9,7 @@ use rustc_middle::ty::TyCtxt;
 pub(crate) type EiiMapEncodedKeyValue = (DefId, (EiiDecl, Vec<(DefId, EiiImpl)>));
 
 pub(crate) type EiiMap = FxIndexMap<
-    DefId, // the defid of the macro that declared the eii
+    DefId, // the defid of the foreign item associated with the eii
     (
         // the corresponding declaration
         EiiDecl,
@@ -28,18 +28,34 @@ pub(crate) fn collect<'tcx>(tcx: TyCtxt<'tcx>, LocalCrate: LocalCrate) -> EiiMap
         for i in
             find_attr!(tcx.get_all_attrs(id), AttributeKind::EiiImpls(e) => e).into_iter().flatten()
         {
-            eiis.entry(i.eii_macro)
-                .or_insert_with(|| {
+            let decl = match i.resolution {
+                EiiImplResolution::Macro(macro_defid) => {
                     // find the decl for this one if it wasn't in yet (maybe it's from the local crate? not very useful but not illegal)
-                    (find_attr!(tcx.get_all_attrs(i.eii_macro), AttributeKind::EiiExternTarget(d) => *d).unwrap(), Default::default())
-                }).1.insert(id.into(), *i);
+                    let Some(decl) = find_attr!(tcx.get_all_attrs(macro_defid), AttributeKind::EiiExternTarget(d) => *d)
+                    else {
+                        // skip if it doesn't have eii_extern_target (if we resolved to another macro that's not an EII)
+                        tcx.dcx()
+                            .span_delayed_bug(i.span, "resolved to something that's not an EII");
+                        continue;
+                    };
+                    decl
+                }
+                EiiImplResolution::Known(decl) => decl,
+                EiiImplResolution::Error(_eg) => continue,
+            };
+
+            // FIXME(eii) remove extern target from encoded decl
+            eiis.entry(decl.eii_extern_target)
+                .or_insert_with(|| (decl, Default::default()))
+                .1
+                .insert(id.into(), *i);
         }
 
         // if we find a new declaration, add it to the list without a known implementation
         if let Some(decl) =
             find_attr!(tcx.get_all_attrs(id), AttributeKind::EiiExternTarget(d) => *d)
         {
-            eiis.entry(id.into()).or_insert((decl, Default::default()));
+            eiis.entry(decl.eii_extern_target).or_insert((decl, Default::default()));
         }
     }
 
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index 36fe7f380069..7bd3f7db55f9 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -559,6 +559,15 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
                     .filter_map(|(cnum, data)| data.used().then_some(cnum)),
             )
         },
+        duplicate_crate_names: |tcx, c: CrateNum| {
+            let name = tcx.crate_name(c);
+            tcx.arena.alloc_from_iter(
+                tcx.crates(())
+                    .into_iter()
+                    .filter(|k| tcx.crate_name(**k) == name && **k != c)
+                    .map(|c| *c),
+            )
+        },
         ..providers.queries
     };
     provide_extern(&mut providers.extern_queries);
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 920c896d5a47..eedb88783ec0 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1441,7 +1441,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                         // Skip encoding defs for these as they should not have had a `DefId` created
                         hir::ConstArgKind::Error(..)
                         | hir::ConstArgKind::Struct(..)
+                        | hir::ConstArgKind::TupleCall(..)
+                        | hir::ConstArgKind::Tup(..)
                         | hir::ConstArgKind::Path(..)
+                        | hir::ConstArgKind::Literal(..)
                         | hir::ConstArgKind::Infer(..) => true,
                         hir::ConstArgKind::Anon(..) => false,
                     },
@@ -1654,9 +1657,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         empty_proc_macro!(self);
         let externally_implementable_items = self.tcx.externally_implementable_items(LOCAL_CRATE);
 
-        self.lazy_array(externally_implementable_items.iter().map(|(decl_did, (decl, impls))| {
-            (*decl_did, (decl.clone(), impls.iter().map(|(impl_did, i)| (*impl_did, *i)).collect()))
-        }))
+        self.lazy_array(externally_implementable_items.iter().map(
+            |(foreign_item, (decl, impls))| {
+                (
+                    *foreign_item,
+                    (decl.clone(), impls.iter().map(|(impl_did, i)| (*impl_did, *i)).collect()),
+                )
+            },
+        ))
     }
 
     #[instrument(level = "trace", skip(self))]
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 8cc66802e435..ca783311586f 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -1003,7 +1003,7 @@ impl<'tcx> TyCtxt<'tcx> {
             Node::Field(field) => field.span,
             Node::AnonConst(constant) => constant.span,
             Node::ConstBlock(constant) => self.hir_body(constant.body).value.span,
-            Node::ConstArg(const_arg) => const_arg.span(),
+            Node::ConstArg(const_arg) => const_arg.span,
             Node::Expr(expr) => expr.span,
             Node::ExprField(field) => field.span,
             Node::ConstArgExprField(field) => field.span,
diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 153605ee7f81..32c6b6e9c0ba 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -169,7 +169,7 @@ impl<'tcx> CanonicalParamEnvCache<'tcx> {
         ) {
             return Canonical {
                 max_universe: ty::UniverseIndex::ROOT,
-                variables: List::empty(),
+                var_kinds: List::empty(),
                 value: key,
             };
         }
diff --git a/compiler/rustc_middle/src/metadata.rs b/compiler/rustc_middle/src/metadata.rs
index 2b0be9865799..9e5b3ef61905 100644
--- a/compiler/rustc_middle/src/metadata.rs
+++ b/compiler/rustc_middle/src/metadata.rs
@@ -26,7 +26,7 @@ impl Reexport {
     }
 }
 
-/// This structure is supposed to keep enough data to re-create `NameBinding`s for other crates
+/// This structure is supposed to keep enough data to re-create `Decl`s for other crates
 /// during name resolution. Right now the bindings are not recreated entirely precisely so we may
 /// need to add more data in the future to correctly support macros 2.0, for example.
 /// Module child can be either a proper item or a reexport (including private imports).
@@ -45,16 +45,9 @@ pub struct ModChild {
     pub reexport_chain: SmallVec<[Reexport; 2]>,
 }
 
-#[derive(Debug, TyEncodable, TyDecodable, HashStable)]
-pub enum AmbigModChildKind {
-    GlobVsGlob,
-    GlobVsExpanded,
-}
-
 /// Same as `ModChild`, however, it includes ambiguity error.
 #[derive(Debug, TyEncodable, TyDecodable, HashStable)]
 pub struct AmbigModChild {
     pub main: ModChild,
     pub second: ModChild,
-    pub kind: AmbigModChildKind,
 }
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 9033d9c46d54..4f600af0cbfc 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use rustc_abi::Align;
 use rustc_hir::attrs::{InlineAttr, InstructionSetAttr, Linkage, OptimizeAttr, RtsanSetting};
+use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
@@ -72,7 +73,7 @@ pub struct CodegenFnAttrs {
     /// generate this function under its real name,
     /// but *also* under the same name as this foreign function so that the foreign function has an implementation.
     // FIXME: make "SymbolName<'tcx>"
-    pub foreign_item_symbol_aliases: Vec<(Symbol, Linkage, Visibility)>,
+    pub foreign_item_symbol_aliases: Vec<(DefId, Linkage, Visibility)>,
     /// The `#[link_ordinal = "..."]` attribute, indicating an ordinal an
     /// imported function has in the dynamic library. Note that this must not
     /// be set when `link_name` is set. This is for foreign items with the
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 08db16ba8ecb..5f40c36423b3 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -2334,6 +2334,7 @@ rustc_queries! {
         eval_always
         desc { "fetching all foreign CrateNum instances" }
     }
+
     // Crates that are loaded non-speculatively (not for diagnostics or doc links).
     // FIXME: This is currently only used for collecting lang items, but should be used instead of
     // `crates` in most other cases too.
@@ -2342,6 +2343,14 @@ rustc_queries! {
         desc { "fetching `CrateNum`s for all crates loaded non-speculatively" }
     }
 
+    /// All crates that share the same name as crate `c`.
+    ///
+    /// This normally occurs when multiple versions of the same dependency are present in the
+    /// dependency tree.
+    query duplicate_crate_names(c: CrateNum) -> &'tcx [CrateNum] {
+        desc { "fetching `CrateNum`s with same name as `{c:?}`" }
+    }
+
     /// A list of all traits in a crate, used by rustdoc and error reporting.
     query traits(_: CrateNum) -> &'tcx [DefId] {
         desc { "fetching all traits in a crate" }
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index c882d5d499bd..29cceb708850 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -20,8 +20,8 @@ use rustc_span::hygiene::{
 };
 use rustc_span::source_map::Spanned;
 use rustc_span::{
-    BlobDecoder, BytePos, ByteSymbol, CachingSourceMapView, ExpnData, ExpnHash, Pos,
-    RelativeBytePos, SourceFile, Span, SpanDecoder, SpanEncoder, StableSourceFileId, Symbol,
+    BlobDecoder, BytePos, ByteSymbol, CachingSourceMapView, ExpnData, ExpnHash, RelativeBytePos,
+    SourceFile, Span, SpanDecoder, SpanEncoder, StableSourceFileId, Symbol,
 };
 
 use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
@@ -652,7 +652,10 @@ impl<'a, 'tcx> SpanDecoder for CacheDecoder<'a, 'tcx> {
                 let dto = u32::decode(self);
 
                 let enclosing = self.tcx.source_span_untracked(parent.unwrap()).data_untracked();
-                (enclosing.lo + BytePos::from_u32(dlo), enclosing.lo + BytePos::from_u32(dto))
+                (
+                    BytePos(enclosing.lo.0.wrapping_add(dlo)),
+                    BytePos(enclosing.lo.0.wrapping_add(dto)),
+                )
             }
             TAG_FULL_SPAN => {
                 let file_lo_index = SourceFileIndex::decode(self);
@@ -894,30 +897,33 @@ impl<'a, 'tcx> SpanEncoder for CacheEncoder<'a, 'tcx> {
             return TAG_PARTIAL_SPAN.encode(self);
         }
 
-        if let Some(parent) = span_data.parent {
-            let enclosing = self.tcx.source_span_untracked(parent).data_untracked();
-            if enclosing.contains(span_data) {
-                TAG_RELATIVE_SPAN.encode(self);
-                (span_data.lo - enclosing.lo).to_u32().encode(self);
-                (span_data.hi - enclosing.lo).to_u32().encode(self);
-                return;
-            }
+        let parent =
+            span_data.parent.map(|parent| self.tcx.source_span_untracked(parent).data_untracked());
+        if let Some(parent) = parent
+            && parent.contains(span_data)
+        {
+            TAG_RELATIVE_SPAN.encode(self);
+            (span_data.lo.0.wrapping_sub(parent.lo.0)).encode(self);
+            (span_data.hi.0.wrapping_sub(parent.lo.0)).encode(self);
+            return;
         }
 
-        let pos = self.source_map.byte_pos_to_line_and_col(span_data.lo);
-        let partial_span = match &pos {
-            Some((file_lo, _, _)) => !file_lo.contains(span_data.hi),
-            None => true,
+        let Some((file_lo, line_lo, col_lo)) =
+            self.source_map.byte_pos_to_line_and_col(span_data.lo)
+        else {
+            return TAG_PARTIAL_SPAN.encode(self);
         };
 
-        if partial_span {
-            return TAG_PARTIAL_SPAN.encode(self);
+        if let Some(parent) = parent
+            && file_lo.contains(parent.lo)
+        {
+            TAG_RELATIVE_SPAN.encode(self);
+            (span_data.lo.0.wrapping_sub(parent.lo.0)).encode(self);
+            (span_data.hi.0.wrapping_sub(parent.lo.0)).encode(self);
+            return;
         }
 
-        let (file_lo, line_lo, col_lo) = pos.unwrap();
-
         let len = span_data.hi - span_data.lo;
-
         let source_file_index = self.source_file_index(file_lo);
 
         TAG_FULL_SPAN.encode(self);
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 3683c1cfb7dd..e538c2182924 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -643,10 +643,26 @@ pub struct FieldPat<'tcx> {
     pub pattern: Pat<'tcx>,
 }
 
+/// Additional per-node data that is not present on most THIR pattern nodes.
+#[derive(Clone, Debug, Default, HashStable, TypeVisitable)]
+pub struct PatExtra<'tcx> {
+    /// If present, this node represents a named constant that was lowered to
+    /// a pattern using `const_to_pat`.
+    ///
+    /// This is used by some diagnostics for non-exhaustive matches, to map
+    /// the pattern node back to the `DefId` of its original constant.
+    pub expanded_const: Option<DefId>,
+
+    /// User-written types that must be preserved into MIR so that they can be
+    /// checked.
+    pub ascriptions: Vec<Ascription<'tcx>>,
+}
+
 #[derive(Clone, Debug, HashStable, TypeVisitable)]
 pub struct Pat<'tcx> {
     pub ty: Ty<'tcx>,
     pub span: Span,
+    pub extra: Option<Box<PatExtra<'tcx>>>,
     pub kind: PatKind<'tcx>,
 }
 
@@ -762,11 +778,6 @@ pub enum PatKind<'tcx> {
     /// A wildcard pattern: `_`.
     Wild,
 
-    AscribeUserType {
-        ascription: Ascription<'tcx>,
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     /// `x`, `ref x`, `x @ P`, etc.
     Binding {
         name: Symbol,
@@ -831,21 +842,6 @@ pub enum PatKind<'tcx> {
         value: ty::Value<'tcx>,
     },
 
-    /// Wrapper node representing a named constant that was lowered to a pattern
-    /// using `const_to_pat`.
-    ///
-    /// This is used by some diagnostics for non-exhaustive matches, to map
-    /// the pattern node back to the `DefId` of its original constant.
-    ///
-    /// FIXME(#150498): Can we make this an `Option<DefId>` field on `Pat`
-    /// instead, so that non-diagnostic code can ignore it more easily?
-    ExpandedConstant {
-        /// [DefId] of the constant item.
-        def_id: DefId,
-        /// The pattern that the constant lowered to.
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     Range(Arc<PatRange<'tcx>>),
 
     /// Matches against a slice, checking the length and extracting elements.
@@ -1119,7 +1115,7 @@ mod size_asserts {
     static_assert_size!(Block, 48);
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 40);
-    static_assert_size!(Pat<'_>, 64);
+    static_assert_size!(Pat<'_>, 72);
     static_assert_size!(PatKind<'_>, 48);
     static_assert_size!(Stmt<'_>, 48);
     static_assert_size!(StmtKind<'_>, 48);
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index d792bbe60c88..b611b23e5261 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -259,7 +259,7 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
     pat: &'a Pat<'tcx>,
     mut callback: impl FnMut(&'a Pat<'tcx>),
 ) {
-    let Pat { kind, ty: _, span: _ } = pat;
+    let Pat { kind, ty: _, span: _, extra: _ } = pat;
     match kind {
         PatKind::Missing
         | PatKind::Wild
@@ -269,11 +269,9 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
         | PatKind::Never
         | PatKind::Error(_) => {}
 
-        PatKind::AscribeUserType { subpattern, .. }
-        | PatKind::Binding { subpattern: Some(subpattern), .. }
+        PatKind::Binding { subpattern: Some(subpattern), .. }
         | PatKind::Deref { subpattern }
-        | PatKind::DerefPattern { subpattern, .. }
-        | PatKind::ExpandedConstant { subpattern, .. } => callback(subpattern),
+        | PatKind::DerefPattern { subpattern, .. } => callback(subpattern),
 
         PatKind::Variant { subpatterns, .. } | PatKind::Leaf { subpatterns } => {
             for field_pat in subpatterns {
diff --git a/compiler/rustc_middle/src/ty/consts/valtree.rs b/compiler/rustc_middle/src/ty/consts/valtree.rs
index 6501ddeed6fa..5a5bf7d38ea4 100644
--- a/compiler/rustc_middle/src/ty/consts/valtree.rs
+++ b/compiler/rustc_middle/src/ty/consts/valtree.rs
@@ -191,8 +191,7 @@ impl<'tcx> Value<'tcx> {
         }
     }
 
-    /// Destructures array, ADT or tuple constants into the constants
-    /// of their fields.
+    /// Destructures ADT constants into the constants of their fields.
     pub fn destructure_adt_const(&self) -> ty::DestructuredAdtConst<'tcx> {
         let fields = self.to_branch();
 
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 25cc739f5ff9..a3eec72214c0 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -907,10 +907,6 @@ impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_featu
         self.coroutine_clone()
     }
 
-    fn associated_const_equality(self) -> bool {
-        self.associated_const_equality()
-    }
-
     fn feature_bound_holds_in_crate(self, symbol: Symbol) -> bool {
         // We don't consider feature bounds to hold in the crate when `staged_api` feature is
         // enabled, even if it is enabled through `#[feature]`.
@@ -1895,6 +1891,12 @@ impl<'tcx> TyCtxt<'tcx> {
         self.is_lang_item(self.parent(def_id), LangItem::AsyncDropInPlace)
     }
 
+    /// Check if the given `def_id` is a const with the `#[type_const]` attribute.
+    pub fn is_type_const(self, def_id: DefId) -> bool {
+        matches!(self.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
+            && find_attr!(self.get_all_attrs(def_id), AttributeKind::TypeConst(_))
+    }
+
     /// Returns the movability of the coroutine of `def_id`, or panics
     /// if given a `def_id` that is not a coroutine.
     pub fn coroutine_movability(self, def_id: DefId) -> hir::Movability {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 1a5a3f3965fa..314d2ba39632 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -586,11 +586,18 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
         self,
         folder: &mut F,
     ) -> Result<Self, F::Error> {
+        // This method looks different to `Ty::try_super_fold_with` and `Const::super_fold_with`.
+        // Why is that? `PredicateKind` provides little scope for optimized folding, unlike
+        // `TyKind` and `ConstKind` (which have common variants that don't require recursive
+        // `fold_with` calls on their fields). So we just derive the `TypeFoldable` impl for
+        // `PredicateKind` and call it here because the derived code is as fast as hand-written
+        // code would be.
         let new = self.kind().try_fold_with(folder)?;
         Ok(folder.cx().reuse_or_mk_predicate(self, new))
     }
 
     fn super_fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
+        // See comment in `Predicate::try_super_fold_with`.
         let new = self.kind().fold_with(folder);
         folder.cx().reuse_or_mk_predicate(self, new)
     }
@@ -598,6 +605,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
 
 impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
     fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
+        // See comment in `Predicate::try_super_fold_with`.
         self.kind().visit_with(visitor)
     }
 }
diff --git a/compiler/rustc_middle/src/ty/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs
index 691cb43b724a..2f6b38a619d2 100644
--- a/compiler/rustc_middle/src/ty/trait_def.rs
+++ b/compiler/rustc_middle/src/ty/trait_def.rs
@@ -2,11 +2,11 @@ use std::iter;
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir as hir;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::{self as hir, find_attr};
 use rustc_macros::{Decodable, Encodable, HashStable};
-use rustc_span::symbol::sym;
 use tracing::debug;
 
 use crate::query::LocalCrate;
@@ -241,7 +241,7 @@ pub(super) fn trait_impls_of_provider(tcx: TyCtxt<'_>, trait_id: DefId) -> Trait
 /// Query provider for `incoherent_impls`.
 pub(super) fn incoherent_impls_provider(tcx: TyCtxt<'_>, simp: SimplifiedType) -> &[DefId] {
     if let Some(def_id) = simp.def()
-        && !tcx.has_attr(def_id, sym::rustc_has_incoherent_inherent_impls)
+        && !find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcHasIncoherentInherentImpls)
     {
         return &[];
     }
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse.rs b/compiler/rustc_mir_build/src/builder/custom/parse.rs
index c6ef362c6ea5..3ae4b1fadee9 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse.rs
@@ -287,22 +287,14 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
         self.parse_var(pattern)
     }
 
-    fn parse_var(&mut self, mut pat: &Pat<'tcx>) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
-        // Make sure we throw out any `AscribeUserType` we find
-        loop {
-            match &pat.kind {
-                PatKind::Binding { var, ty, .. } => break Ok((*var, *ty, pat.span)),
-                PatKind::AscribeUserType { subpattern, .. } => {
-                    pat = subpattern;
-                }
-                _ => {
-                    break Err(ParseError {
-                        span: pat.span,
-                        item_description: format!("{:?}", pat.kind),
-                        expected: "local".to_string(),
-                    });
-                }
-            }
+    fn parse_var(&mut self, pat: &Pat<'tcx>) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
+        match &pat.kind {
+            PatKind::Binding { var, ty, .. } => Ok((*var, *ty, pat.span)),
+            _ => Err(ParseError {
+                span: pat.span,
+                item_description: format!("{:?}", pat.kind),
+                expected: "local".to_string(),
+            }),
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index ddaa61c6cc91..13082d408ec0 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -144,11 +144,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
             let arm = &self.thir[*arm];
             let value = match arm.pattern.kind {
                 PatKind::Constant { value } => value,
-                PatKind::ExpandedConstant { ref subpattern, def_id: _ }
-                    if let PatKind::Constant { value } = subpattern.kind =>
-                {
-                    value
-                }
                 _ => {
                     return Err(ParseError {
                         span: arm.pattern.span,
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
index 186fde4883df..1772d66f5285 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
@@ -1,7 +1,7 @@
 //! See docs in build/expr/mod.rs
 
 use rustc_abi::Size;
-use rustc_ast as ast;
+use rustc_ast::{self as ast};
 use rustc_hir::LangItem;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, LitToConstInput, Scalar};
 use rustc_middle::mir::*;
@@ -47,6 +47,7 @@ pub(crate) fn as_constant_inner<'tcx>(
     tcx: TyCtxt<'tcx>,
 ) -> ConstOperand<'tcx> {
     let Expr { ty, temp_scope_id: _, span, ref kind } = *expr;
+
     match *kind {
         ExprKind::Literal { lit, neg } => {
             let const_ = lit_to_mir_constant(tcx, LitToConstInput { lit: lit.node, ty, neg });
@@ -69,6 +70,13 @@ pub(crate) fn as_constant_inner<'tcx>(
         }
         ExprKind::NamedConst { def_id, args, ref user_ty } => {
             let user_ty = user_ty.as_ref().and_then(push_cuta);
+            if tcx.is_type_const(def_id) {
+                let uneval = ty::UnevaluatedConst::new(def_id, args);
+                let ct = ty::Const::new_unevaluated(tcx, uneval);
+
+                let const_ = Const::Ty(ty, ct);
+                return ConstOperand { span, user_ty, const_ };
+            }
 
             let uneval = mir::UnevaluatedConst::new(def_id, args);
             let const_ = Const::Unevaluated(uneval, ty);
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index f0114c2193c3..8cee3ff27e8f 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -133,6 +133,20 @@ impl<'tcx> MatchPairTree<'tcx> {
         }
 
         let place = place_builder.try_to_place(cx);
+
+        // Apply any type ascriptions to the value at `match_pair.place`.
+        if let Some(place) = place
+            && let Some(extra) = &pattern.extra
+        {
+            for &Ascription { ref annotation, variance } in &extra.ascriptions {
+                extra_data.ascriptions.push(super::Ascription {
+                    source: place,
+                    annotation: annotation.clone(),
+                    variance,
+                });
+            }
+        }
+
         let mut subpairs = Vec::new();
         let testable_case = match pattern.kind {
             PatKind::Missing | PatKind::Wild | PatKind::Error(_) => None,
@@ -195,28 +209,6 @@ impl<'tcx> MatchPairTree<'tcx> {
                 Some(TestableCase::Constant { value, kind: const_kind })
             }
 
-            PatKind::AscribeUserType {
-                ascription: Ascription { ref annotation, variance },
-                ref subpattern,
-                ..
-            } => {
-                MatchPairTree::for_pattern(
-                    place_builder,
-                    subpattern,
-                    cx,
-                    &mut subpairs,
-                    extra_data,
-                );
-
-                // Apply the type ascription to the value at `match_pair.place`
-                if let Some(source) = place {
-                    let annotation = annotation.clone();
-                    extra_data.ascriptions.push(super::Ascription { source, annotation, variance });
-                }
-
-                None
-            }
-
             PatKind::Binding { mode, var, is_shorthand, ref subpattern, .. } => {
                 // In order to please the borrow checker, when lowering a pattern
                 // like `x @ subpat` we must establish any bindings in `subpat`
@@ -263,11 +255,6 @@ impl<'tcx> MatchPairTree<'tcx> {
                 None
             }
 
-            PatKind::ExpandedConstant { subpattern: ref pattern, .. } => {
-                MatchPairTree::for_pattern(place_builder, pattern, cx, &mut subpairs, extra_data);
-                None
-            }
-
             PatKind::Array { ref prefix, ref slice, ref suffix } => {
                 cx.prefix_slice_suffix(
                     &mut subpairs,
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 9080e2ba801b..590316a47554 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -576,7 +576,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         initializer_id: ExprId,
     ) -> BlockAnd<()> {
         match irrefutable_pat.kind {
-            // Optimize the case of `let x = ...` to write directly into `x`
+            // Optimize `let x = ...` and `let x: T = ...` to write directly into `x`,
+            // and then require that `T == typeof(x)` if present.
             PatKind::Binding { mode: BindingMode(ByRef::No, _), var, subpattern: None, .. } => {
                 let place = self.storage_live_binding(
                     block,
@@ -592,43 +593,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let source_info = self.source_info(irrefutable_pat.span);
                 self.cfg.push_fake_read(block, source_info, FakeReadCause::ForLet(None), place);
 
-                self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
-                block.unit()
-            }
+                let ascriptions: &[_] =
+                    try { irrefutable_pat.extra.as_deref()?.ascriptions.as_slice() }
+                        .unwrap_or_default();
+                for thir::Ascription { annotation, variance: _ } in ascriptions {
+                    let ty_source_info = self.source_info(annotation.span);
 
-            // Optimize the case of `let x: T = ...` to write directly
-            // into `x` and then require that `T == typeof(x)`.
-            PatKind::AscribeUserType {
-                ref subpattern,
-                ascription: thir::Ascription { ref annotation, variance: _ },
-            } if let PatKind::Binding {
-                mode: BindingMode(ByRef::No, _),
-                var,
-                subpattern: None,
-                ..
-            } = subpattern.kind =>
-            {
-                let place = self.storage_live_binding(
-                    block,
-                    var,
-                    irrefutable_pat.span,
-                    false,
-                    OutsideGuard,
-                    ScheduleDrops::Yes,
-                );
-                block = self.expr_into_dest(place, block, initializer_id).into_block();
-
-                // Inject a fake read, see comments on `FakeReadCause::ForLet`.
-                let pattern_source_info = self.source_info(irrefutable_pat.span);
-                let cause_let = FakeReadCause::ForLet(None);
-                self.cfg.push_fake_read(block, pattern_source_info, cause_let, place);
-
-                let ty_source_info = self.source_info(annotation.span);
-
-                let base = self.canonical_user_type_annotations.push(annotation.clone());
-                self.cfg.push(
-                    block,
-                    Statement::new(
+                    let base = self.canonical_user_type_annotations.push(annotation.clone());
+                    let stmt = Statement::new(
                         ty_source_info,
                         StatementKind::AscribeUserType(
                             Box::new((place, UserTypeProjection { base, projs: Vec::new() })),
@@ -648,8 +620,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             // `<expr>`.
                             ty::Invariant,
                         ),
-                    ),
-                );
+                    );
+                    self.cfg.push(block, stmt);
+                }
 
                 self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
                 block.unit()
@@ -879,6 +852,26 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             &ProjectedUserTypesNode<'_>,
         ),
     ) {
+        // Ascriptions correspond to user-written types like `let A::<'a>(_): A<'static> = ...;`.
+        //
+        // Caution: Pushing user types here is load-bearing even for
+        // patterns containing no bindings, to ensure that the type ends
+        // up represented in MIR _somewhere_.
+        let user_tys = match pattern.extra.as_deref() {
+            Some(PatExtra { ascriptions, .. }) if !ascriptions.is_empty() => {
+                let base_user_tys = ascriptions
+                    .iter()
+                    .map(|thir::Ascription { annotation, variance: _ }| {
+                        // Note that the variance doesn't apply here, as we are tracking the effect
+                        // of user types on any bindings contained with subpattern.
+                        self.canonical_user_type_annotations.push(annotation.clone())
+                    })
+                    .collect();
+                &user_tys.push_user_types(base_user_tys)
+            }
+            _ => user_tys,
+        };
+
         // Avoid having to write the full method name at each recursive call.
         let visit_subpat = |this: &mut Self, subpat, user_tys: &_, f: &mut _| {
             this.visit_primary_bindings_special(subpat, user_tys, f)
@@ -924,31 +917,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 visit_subpat(self, subpattern, &ProjectedUserTypesNode::None, f);
             }
 
-            PatKind::AscribeUserType {
-                ref subpattern,
-                ascription: thir::Ascription { ref annotation, variance: _ },
-            } => {
-                // This corresponds to something like
-                //
-                // ```
-                // let A::<'a>(_): A<'static> = ...;
-                // ```
-                //
-                // Note that the variance doesn't apply here, as we are tracking the effect
-                // of `user_ty` on any bindings contained with subpattern.
-
-                // Caution: Pushing this user type here is load-bearing even for
-                // patterns containing no bindings, to ensure that the type ends
-                // up represented in MIR _somewhere_.
-                let base_user_ty = self.canonical_user_type_annotations.push(annotation.clone());
-                let subpattern_user_tys = user_tys.push_user_type(base_user_ty);
-                visit_subpat(self, subpattern, &subpattern_user_tys, f)
-            }
-
-            PatKind::ExpandedConstant { ref subpattern, .. } => {
-                visit_subpat(self, subpattern, user_tys, f)
-            }
-
             PatKind::Leaf { ref subpatterns } => {
                 for subpattern in subpatterns {
                     let subpattern_user_tys = user_tys.leaf(subpattern.field);
diff --git a/compiler/rustc_mir_build/src/builder/matches/user_ty.rs b/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
index df9f93ac328a..2dcfd3772902 100644
--- a/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
@@ -8,15 +8,20 @@ use std::assert_matches::assert_matches;
 use std::iter;
 
 use rustc_abi::{FieldIdx, VariantIdx};
+use rustc_data_structures::smallvec::SmallVec;
 use rustc_middle::mir::{ProjectionElem, UserTypeProjection, UserTypeProjections};
 use rustc_middle::ty::{AdtDef, UserTypeAnnotationIndex};
 use rustc_span::Symbol;
 
+/// A single `thir::Pat` node should almost never have more than 0-2 user types.
+/// We can store up to 4 inline in the same size as an ordinary `Vec`.
+pub(crate) type UserTypeIndices = SmallVec<[UserTypeAnnotationIndex; 4]>;
+
 /// One of a list of "operations" that can be used to lazily build projections
 /// of user-specified types.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub(crate) enum ProjectedUserTypesOp {
-    PushUserType { base: UserTypeAnnotationIndex },
+    PushUserTypes { base_types: UserTypeIndices },
 
     Index,
     Subslice { from: u64, to: u64 },
@@ -32,9 +37,10 @@ pub(crate) enum ProjectedUserTypesNode<'a> {
 }
 
 impl<'a> ProjectedUserTypesNode<'a> {
-    pub(crate) fn push_user_type(&'a self, base: UserTypeAnnotationIndex) -> Self {
-        // Pushing a base user type always causes the chain to become non-empty.
-        Self::Chain { parent: self, op: ProjectedUserTypesOp::PushUserType { base } }
+    pub(crate) fn push_user_types(&'a self, base_types: UserTypeIndices) -> Self {
+        assert!(!base_types.is_empty());
+        // Pushing one or more base user types always causes the chain to become non-empty.
+        Self::Chain { parent: self, op: ProjectedUserTypesOp::PushUserTypes { base_types } }
     }
 
     /// Push another projection op onto the chain, but only if it is already non-empty.
@@ -94,16 +100,19 @@ impl<'a> ProjectedUserTypesNode<'a> {
             return None;
         }
 
-        let ops_reversed = self.iter_ops_reversed().cloned().collect::<Vec<_>>();
+        let ops_reversed = self.iter_ops_reversed().collect::<Vec<_>>();
         // The "first" op should always be `PushUserType`.
         // Other projections are only added if there is at least one user type.
-        assert_matches!(ops_reversed.last(), Some(ProjectedUserTypesOp::PushUserType { .. }));
+        assert_matches!(ops_reversed.last(), Some(ProjectedUserTypesOp::PushUserTypes { .. }));
 
         let mut projections = vec![];
         for op in ops_reversed.into_iter().rev() {
-            match op {
-                ProjectedUserTypesOp::PushUserType { base } => {
-                    projections.push(UserTypeProjection { base, projs: vec![] })
+            match *op {
+                ProjectedUserTypesOp::PushUserTypes { ref base_types } => {
+                    assert!(!base_types.is_empty());
+                    for &base in base_types {
+                        projections.push(UserTypeProjection { base, projs: vec![] })
+                    }
                 }
 
                 ProjectedUserTypesOp::Index => {
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index 4f03e3d965c6..68b8a842a2a6 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -342,8 +342,6 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 PatKind::Wild |
                 // these just wrap other patterns, which we recurse on below.
                 PatKind::Or { .. } |
-                PatKind::ExpandedConstant { .. } |
-                PatKind::AscribeUserType { .. } |
                 PatKind::Error(_) => {}
             }
         };
diff --git a/compiler/rustc_mir_build/src/thir/cx/block.rs b/compiler/rustc_mir_build/src/thir/cx/block.rs
index 57ddb8eddb8e..7cdd70a7fc27 100644
--- a/compiler/rustc_mir_build/src/thir/cx/block.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/block.rs
@@ -2,8 +2,6 @@ use rustc_hir as hir;
 use rustc_index::Idx;
 use rustc_middle::middle::region;
 use rustc_middle::thir::*;
-use rustc_middle::ty;
-use rustc_middle::ty::CanonicalUserTypeAnnotation;
 use tracing::debug;
 
 use crate::thir::cx::ThirBuildCx;
@@ -73,29 +71,9 @@ impl<'tcx> ThirBuildCx<'tcx> {
 
                         let else_block = local.els.map(|els| self.mirror_block(els));
 
-                        let mut pattern = self.pattern_from_hir(local.pat);
+                        let pattern = self.pattern_from_hir_with_annotation(local.pat, local.ty);
                         debug!(?pattern);
 
-                        if let Some(ty) = &local.ty
-                            && let Some(&user_ty) =
-                                self.typeck_results.user_provided_types().get(ty.hir_id)
-                        {
-                            debug!("mirror_stmts: user_ty={:?}", user_ty);
-                            let annotation = CanonicalUserTypeAnnotation {
-                                user_ty: Box::new(user_ty),
-                                span: ty.span,
-                                inferred_ty: self.typeck_results.node_type(ty.hir_id),
-                            };
-                            pattern = Box::new(Pat {
-                                ty: pattern.ty,
-                                span: pattern.span,
-                                kind: PatKind::AscribeUserType {
-                                    ascription: Ascription { annotation, variance: ty::Covariant },
-                                    subpattern: pattern,
-                                },
-                            });
-                        }
-
                         let span = match local.init {
                             Some(init) => local.span.with_hi(init.span.hi()),
                             None => local.span,
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index d26dfac0c2ab..79e85a243f40 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -12,9 +12,6 @@ use rustc_hir::{self as hir, HirId, find_attr};
 use rustc_middle::bug;
 use rustc_middle::thir::*;
 use rustc_middle::ty::{self, TyCtxt};
-use tracing::instrument;
-
-use crate::thir::pattern::pat_from_hir;
 
 /// Query implementation for [`TyCtxt::thir_body`].
 pub(crate) fn thir_body(
@@ -111,9 +108,22 @@ impl<'tcx> ThirBuildCx<'tcx> {
         }
     }
 
-    #[instrument(level = "debug", skip(self))]
-    fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        pat_from_hir(self.tcx, self.typing_env, self.typeck_results, p)
+    fn pattern_from_hir(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
+        self.pattern_from_hir_with_annotation(pat, None)
+    }
+
+    fn pattern_from_hir_with_annotation(
+        &mut self,
+        pat: &'tcx hir::Pat<'tcx>,
+        let_stmt_type: Option<&hir::Ty<'tcx>>,
+    ) -> Box<Pat<'tcx>> {
+        crate::thir::pattern::pat_from_hir(
+            self.tcx,
+            self.typing_env,
+            self.typeck_results,
+            pat,
+            let_stmt_type,
+        )
     }
 
     fn closure_env_param(&self, owner_def: LocalDefId, expr_id: HirId) -> Option<Param<'tcx>> {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index bf480cf601ee..d9a06de32bb0 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -680,20 +680,13 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         let mut interpreted_as_const = None;
         let mut interpreted_as_const_sugg = None;
 
-        // These next few matches want to peek through `AscribeUserType` to see
-        // the underlying pattern.
-        let mut unpeeled_pat = pat;
-        while let PatKind::AscribeUserType { ref subpattern, .. } = unpeeled_pat.kind {
-            unpeeled_pat = subpattern;
-        }
-
-        if let Some(def_id) = is_const_pat_that_looks_like_binding(self.tcx, unpeeled_pat) {
+        if let Some(def_id) = is_const_pat_that_looks_like_binding(self.tcx, pat) {
             let span = self.tcx.def_span(def_id);
             let variable = self.tcx.item_name(def_id).to_string();
             // When we encounter a constant as the binding name, point at the `const` definition.
             interpreted_as_const = Some(InterpretedAsConst { span, variable: variable.clone() });
             interpreted_as_const_sugg = Some(InterpretedAsConstSugg { span: pat.span, variable });
-        } else if let PatKind::Constant { .. } = unpeeled_pat.kind
+        } else if let PatKind::Constant { .. } = pat.kind
             && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(pat.span)
         {
             // If the pattern to match is an integer literal:
@@ -1213,7 +1206,7 @@ fn is_const_pat_that_looks_like_binding<'tcx>(tcx: TyCtxt<'tcx>, pat: &Pat<'tcx>
     // The pattern must be a named constant, and the name that appears in
     // the pattern's source text must resemble a plain identifier without any
     // `::` namespace separators or other non-identifier characters.
-    if let PatKind::ExpandedConstant { def_id, .. } = pat.kind
+    if let Some(def_id) = try { pat.extra.as_deref()?.expanded_const? }
         && matches!(tcx.def_kind(def_id), DefKind::Const)
         && let Ok(snippet) = tcx.sess.source_map().span_to_snippet(pat.span)
         && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 2da9a43f71d8..02409d2bae9f 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -90,7 +90,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 );
             }
         }
-        Box::new(Pat { span: self.span, ty, kind: PatKind::Error(err.emit()) })
+        Box::new(Pat { span: self.span, ty, kind: PatKind::Error(err.emit()), extra: None })
     }
 
     fn unevaluated_to_pat(
@@ -174,10 +174,10 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         };
 
-        // Convert the valtree to a const.
-        let inlined_const_as_pat = self.valtree_to_pat(valtree, ty);
+        // Lower the valtree to a THIR pattern.
+        let mut thir_pat = self.valtree_to_pat(valtree, ty);
 
-        if !inlined_const_as_pat.references_error() {
+        if !thir_pat.references_error() {
             // Always check for `PartialEq` if we had no other errors yet.
             if !type_has_partial_eq_impl(self.tcx, typing_env, ty).has_impl {
                 let mut err = self.tcx.dcx().create_err(TypeNotPartialEq { span: self.span, ty });
@@ -186,10 +186,10 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         }
 
-        // Wrap the pattern in a marker node to indicate that it is the result of lowering a
+        // Mark the pattern to indicate that it is the result of lowering a named
         // constant. This is used for diagnostics.
-        let kind = PatKind::ExpandedConstant { subpattern: inlined_const_as_pat, def_id: uv.def };
-        Box::new(Pat { kind, ty, span: self.span })
+        thir_pat.extra.get_or_insert_default().expanded_const = Some(uv.def);
+        thir_pat
     }
 
     fn field_pats(
@@ -351,7 +351,7 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         };
 
-        Box::new(Pat { span, ty, kind })
+        Box::new(Pat { span, ty, kind, extra: None })
     }
 }
 
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 0310003e7d58..650650cbaac9 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -4,6 +4,7 @@ mod check_match;
 mod const_to_pat;
 mod migration;
 
+use std::assert_matches::assert_matches;
 use std::cmp::Ordering;
 use std::sync::Arc;
 
@@ -21,7 +22,7 @@ use rustc_middle::ty::adjustment::{PatAdjust, PatAdjustment};
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_span::{ErrorGuaranteed, Span};
+use rustc_span::ErrorGuaranteed;
 use tracing::{debug, instrument};
 
 pub(crate) use self::check_match::check_match;
@@ -38,11 +39,14 @@ struct PatCtxt<'tcx> {
     rust_2024_migration: Option<PatMigration<'tcx>>,
 }
 
+#[instrument(level = "debug", skip(tcx, typing_env, typeck_results), ret)]
 pub(super) fn pat_from_hir<'tcx>(
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
     pat: &'tcx hir::Pat<'tcx>,
+    // Present if `pat` came from a let statement with an explicit type annotation
+    let_stmt_type: Option<&hir::Ty<'tcx>>,
 ) -> Box<Pat<'tcx>> {
     let mut pcx = PatCtxt {
         tcx,
@@ -53,12 +57,32 @@ pub(super) fn pat_from_hir<'tcx>(
             .get(pat.hir_id)
             .map(PatMigration::new),
     };
-    let result = pcx.lower_pattern(pat);
-    debug!("pat_from_hir({:?}) = {:?}", pat, result);
+
+    let mut thir_pat = pcx.lower_pattern(pat);
+
+    // If this pattern came from a let statement with an explicit type annotation
+    // (e.g. `let x: Foo = ...`), retain that user type information in the THIR pattern.
+    if let Some(let_stmt_type) = let_stmt_type
+        && let Some(&user_ty) = typeck_results.user_provided_types().get(let_stmt_type.hir_id)
+    {
+        debug!(?user_ty);
+        let annotation = CanonicalUserTypeAnnotation {
+            user_ty: Box::new(user_ty),
+            span: let_stmt_type.span,
+            inferred_ty: typeck_results.node_type(let_stmt_type.hir_id),
+        };
+        thir_pat
+            .extra
+            .get_or_insert_default()
+            .ascriptions
+            .push(Ascription { annotation, variance: ty::Covariant });
+    }
+
     if let Some(m) = pcx.rust_2024_migration {
         m.emit(tcx, pat.hir_id);
     }
-    result
+
+    thir_pat
 }
 
 impl<'tcx> PatCtxt<'tcx> {
@@ -115,7 +139,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 }
                 PatAdjust::PinDeref => PatKind::Deref { subpattern: thir_pat },
             };
-            Box::new(Pat { span, ty: adjust.source, kind })
+            Box::new(Pat { span, ty: adjust.source, kind, extra: None })
         });
 
         if let Some(s) = &mut self.rust_2024_migration
@@ -129,31 +153,25 @@ impl<'tcx> PatCtxt<'tcx> {
 
     fn lower_pattern_range_endpoint(
         &mut self,
+        pat: &'tcx hir::Pat<'tcx>, // Range pattern containing the endpoint
         expr: Option<&'tcx hir::PatExpr<'tcx>>,
         // Out-parameter collecting extra data to be reapplied by the caller
         ascriptions: &mut Vec<Ascription<'tcx>>,
     ) -> Result<Option<PatRangeBoundary<'tcx>>, ErrorGuaranteed> {
+        assert_matches!(pat.kind, hir::PatKind::Range(..));
+
+        // For partly-bounded ranges like `X..` or `..X`, an endpoint will be absent.
+        // Return None in that case; the caller will use NegInfinity or PosInfinity instead.
         let Some(expr) = expr else { return Ok(None) };
 
-        // Lower the endpoint into a temporary `PatKind` that will then be
+        // Lower the endpoint into a temporary `thir::Pat` that will then be
         // deconstructed to obtain the constant value and other data.
-        let mut kind: PatKind<'tcx> = self.lower_pat_expr(expr, None);
+        let endpoint_pat: Box<Pat<'tcx>> = self.lower_pat_expr(pat, expr);
+        let box Pat { ref kind, extra, .. } = endpoint_pat;
 
-        // Unpeel any ascription or inline-const wrapper nodes.
-        loop {
-            match kind {
-                PatKind::AscribeUserType { ascription, subpattern } => {
-                    ascriptions.push(ascription);
-                    kind = subpattern.kind;
-                }
-                PatKind::ExpandedConstant { def_id: _, subpattern } => {
-                    // Expanded-constant nodes are currently only needed by
-                    // diagnostics that don't apply to range patterns, so we
-                    // can just discard them here.
-                    kind = subpattern.kind;
-                }
-                _ => break,
-            }
+        // Preserve any ascriptions from endpoint constants.
+        if let Some(extra) = extra {
+            ascriptions.extend(extra.ascriptions);
         }
 
         // The unpeeled kind should now be a constant, giving us the endpoint value.
@@ -214,12 +232,14 @@ impl<'tcx> PatCtxt<'tcx> {
 
     fn lower_pattern_range(
         &mut self,
+        pat: &'tcx hir::Pat<'tcx>,
         lo_expr: Option<&'tcx hir::PatExpr<'tcx>>,
         hi_expr: Option<&'tcx hir::PatExpr<'tcx>>,
         end: RangeEnd,
-        ty: Ty<'tcx>,
-        span: Span,
-    ) -> Result<PatKind<'tcx>, ErrorGuaranteed> {
+    ) -> Result<Box<Pat<'tcx>>, ErrorGuaranteed> {
+        let ty = self.typeck_results.node_type(pat.hir_id);
+        let span = pat.span;
+
         if lo_expr.is_none() && hi_expr.is_none() {
             let msg = "found twice-open range pattern (`..`) outside of error recovery";
             self.tcx.dcx().span_bug(span, msg);
@@ -227,7 +247,8 @@ impl<'tcx> PatCtxt<'tcx> {
 
         // Collect extra data while lowering the endpoints, to be reapplied later.
         let mut ascriptions = vec![];
-        let mut lower_endpoint = |expr| self.lower_pattern_range_endpoint(expr, &mut ascriptions);
+        let mut lower_endpoint =
+            |expr| self.lower_pattern_range_endpoint(pat, expr, &mut ascriptions);
 
         let lo = lower_endpoint(lo_expr)?.unwrap_or(PatRangeBoundary::NegInfinity);
         let hi = lower_endpoint(hi_expr)?.unwrap_or(PatRangeBoundary::PosInfinity);
@@ -271,27 +292,28 @@ impl<'tcx> PatCtxt<'tcx> {
                 return Err(e);
             }
         }
+        let mut thir_pat = Box::new(Pat { ty, span, kind, extra: None });
 
         // If we are handling a range with associated constants (e.g.
         // `Foo::<'a>::A..=Foo::B`), we need to put the ascriptions for the associated
         // constants somewhere. Have them on the range pattern.
-        for ascription in ascriptions {
-            let subpattern = Box::new(Pat { span, ty, kind });
-            kind = PatKind::AscribeUserType { ascription, subpattern };
-        }
-        // `PatKind::ExpandedConstant` wrappers from range endpoints used to
+        thir_pat.extra.get_or_insert_default().ascriptions.extend(ascriptions);
+        // IDs of expanded constants from range endpoints used to
         // also be preserved here, but that was only needed for unsafeck of
         // inline `const { .. }` patterns, which were removed by
         // <https://github.com/rust-lang/rust/pull/138492>.
 
-        Ok(kind)
+        Ok(thir_pat)
     }
 
     #[instrument(skip(self), level = "debug")]
     fn lower_pattern_unadjusted(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        let mut ty = self.typeck_results.node_type(pat.hir_id);
-        let mut span = pat.span;
+        let ty = self.typeck_results.node_type(pat.hir_id);
+        let span = pat.span;
 
+        // Some of these match arms return a `Box<Pat>` early, while others
+        // evaluate to a `PatKind` that will become a `Box<Pat>` at the end of
+        // this function.
         let kind = match pat.kind {
             hir::PatKind::Missing => PatKind::Missing,
 
@@ -299,12 +321,13 @@ impl<'tcx> PatCtxt<'tcx> {
 
             hir::PatKind::Never => PatKind::Never,
 
-            hir::PatKind::Expr(value) => self.lower_pat_expr(value, Some(ty)),
+            hir::PatKind::Expr(value) => return self.lower_pat_expr(pat, value),
 
-            hir::PatKind::Range(ref lo_expr, ref hi_expr, end) => {
-                let (lo_expr, hi_expr) = (lo_expr.as_deref(), hi_expr.as_deref());
-                self.lower_pattern_range(lo_expr, hi_expr, end, ty, span)
-                    .unwrap_or_else(PatKind::Error)
+            hir::PatKind::Range(lo_expr, hi_expr, end) => {
+                match self.lower_pattern_range(pat, lo_expr, hi_expr, end) {
+                    Ok(thir_pat) => return thir_pat,
+                    Err(e) => PatKind::Error(e),
+                }
             }
 
             hir::PatKind::Deref(subpattern) => {
@@ -327,7 +350,7 @@ impl<'tcx> PatCtxt<'tcx> {
             },
 
             hir::PatKind::Slice(prefix, slice, suffix) => {
-                self.slice_or_array_pattern(pat.span, ty, prefix, slice, suffix)
+                return self.slice_or_array_pattern(pat, prefix, slice, suffix);
             }
 
             hir::PatKind::Tuple(pats, ddpos) => {
@@ -339,8 +362,9 @@ impl<'tcx> PatCtxt<'tcx> {
             }
 
             hir::PatKind::Binding(explicit_ba, id, ident, sub) => {
+                let mut thir_pat_span = span;
                 if let Some(ident_span) = ident.span.find_ancestor_inside(span) {
-                    span = span.with_hi(ident_span.hi());
+                    thir_pat_span = span.with_hi(ident_span.hi());
                 }
 
                 let mode = *self
@@ -356,22 +380,23 @@ impl<'tcx> PatCtxt<'tcx> {
                 // A ref x pattern is the same node used for x, and as such it has
                 // x's type, which is &T, where we want T (the type being matched).
                 let var_ty = ty;
+                let mut thir_pat_ty = ty;
                 if let hir::ByRef::Yes(pinnedness, _) = mode.0 {
                     match pinnedness {
                         hir::Pinnedness::Pinned
                             if let Some(pty) = ty.pinned_ty()
                                 && let &ty::Ref(_, rty, _) = pty.kind() =>
                         {
-                            ty = rty;
+                            thir_pat_ty = rty;
                         }
                         hir::Pinnedness::Not if let &ty::Ref(_, rty, _) = ty.kind() => {
-                            ty = rty;
+                            thir_pat_ty = rty;
                         }
                         _ => bug!("`ref {}` has wrong type {}", ident, ty),
                     }
                 };
 
-                PatKind::Binding {
+                let kind = PatKind::Binding {
                     mode,
                     name: ident.name,
                     var: LocalVarId(id),
@@ -379,7 +404,10 @@ impl<'tcx> PatCtxt<'tcx> {
                     subpattern: self.lower_opt_pattern(sub),
                     is_primary: id == pat.hir_id,
                     is_shorthand: false,
-                }
+                };
+                // We might have modified the type or span, so use the modified
+                // values in the THIR pattern node.
+                return Box::new(Pat { ty: thir_pat_ty, span: thir_pat_span, kind, extra: None });
             }
 
             hir::PatKind::TupleStruct(ref qpath, pats, ddpos) => {
@@ -389,7 +417,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 };
                 let variant_def = adt_def.variant_of_res(res);
                 let subpatterns = self.lower_tuple_subpats(pats, variant_def.fields.len(), ddpos);
-                self.lower_variant_or_leaf(res, pat.hir_id, pat.span, ty, subpatterns)
+                return self.lower_variant_or_leaf(pat, None, res, subpatterns);
             }
 
             hir::PatKind::Struct(ref qpath, fields, _) => {
@@ -406,7 +434,7 @@ impl<'tcx> PatCtxt<'tcx> {
                     })
                     .collect();
 
-                self.lower_variant_or_leaf(res, pat.hir_id, pat.span, ty, subpatterns)
+                return self.lower_variant_or_leaf(pat, None, res, subpatterns);
             }
 
             hir::PatKind::Or(pats) => PatKind::Or { pats: self.lower_patterns(pats) },
@@ -417,7 +445,9 @@ impl<'tcx> PatCtxt<'tcx> {
             hir::PatKind::Err(guar) => PatKind::Error(guar),
         };
 
-        Box::new(Pat { span, ty, kind })
+        // For pattern kinds that haven't already returned, create a `thir::Pat`
+        // with the HIR pattern node's type and span.
+        Box::new(Pat { span, ty, kind, extra: None })
     }
 
     fn lower_tuple_subpats(
@@ -445,16 +475,18 @@ impl<'tcx> PatCtxt<'tcx> {
 
     fn slice_or_array_pattern(
         &mut self,
-        span: Span,
-        ty: Ty<'tcx>,
+        pat: &'tcx hir::Pat<'tcx>,
         prefix: &'tcx [hir::Pat<'tcx>],
         slice: Option<&'tcx hir::Pat<'tcx>>,
         suffix: &'tcx [hir::Pat<'tcx>],
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
+        let ty = self.typeck_results.node_type(pat.hir_id);
+        let span = pat.span;
+
         let prefix = self.lower_patterns(prefix);
         let slice = self.lower_opt_pattern(slice);
         let suffix = self.lower_patterns(suffix);
-        match ty.kind() {
+        let kind = match ty.kind() {
             // Matching a slice, `[T]`.
             ty::Slice(..) => PatKind::Slice { prefix, slice, suffix },
             // Fixed-length array, `[T; len]`.
@@ -465,18 +497,33 @@ impl<'tcx> PatCtxt<'tcx> {
                 assert!(len >= prefix.len() as u64 + suffix.len() as u64);
                 PatKind::Array { prefix, slice, suffix }
             }
-            _ => span_bug!(span, "bad slice pattern type {:?}", ty),
-        }
+            _ => span_bug!(span, "bad slice pattern type {ty:?}"),
+        };
+        Box::new(Pat { ty, span, kind, extra: None })
     }
 
     fn lower_variant_or_leaf(
         &mut self,
+        pat: &'tcx hir::Pat<'tcx>,
+        expr: Option<&'tcx hir::PatExpr<'tcx>>,
         res: Res,
-        hir_id: hir::HirId,
-        span: Span,
-        ty: Ty<'tcx>,
         subpatterns: Vec<FieldPat<'tcx>>,
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
+        // Check whether the caller should have provided an `expr` for this pattern kind.
+        assert_matches!(
+            (pat.kind, expr),
+            (hir::PatKind::Expr(..) | hir::PatKind::Range(..), Some(_))
+                | (hir::PatKind::Struct(..) | hir::PatKind::TupleStruct(..), None)
+        );
+
+        // Use the id/span of the `hir::PatExpr`, if provided.
+        // Otherwise, use the id/span of the `hir::Pat`.
+        let (hir_id, span) = match expr {
+            Some(expr) => (expr.hir_id, expr.span),
+            None => (pat.hir_id, pat.span),
+        };
+        let ty = self.typeck_results.node_type(hir_id);
+
         let res = match res {
             Res::Def(DefKind::Ctor(CtorOf::Variant, ..), variant_ctor_id) => {
                 let variant_id = self.tcx.parent(variant_ctor_id);
@@ -485,7 +532,7 @@ impl<'tcx> PatCtxt<'tcx> {
             res => res,
         };
 
-        let mut kind = match res {
+        let kind = match res {
             Res::Def(DefKind::Variant, variant_id) => {
                 let enum_id = self.tcx.parent(variant_id);
                 let adt_def = self.tcx.adt_def(enum_id);
@@ -494,7 +541,12 @@ impl<'tcx> PatCtxt<'tcx> {
                         ty::Adt(_, args) | ty::FnDef(_, args) => args,
                         ty::Error(e) => {
                             // Avoid ICE (#50585)
-                            return PatKind::Error(*e);
+                            return Box::new(Pat {
+                                ty,
+                                span,
+                                kind: PatKind::Error(*e),
+                                extra: None,
+                            });
                         }
                         _ => bug!("inappropriate type for def: {:?}", ty),
                     };
@@ -535,21 +587,23 @@ impl<'tcx> PatCtxt<'tcx> {
                 PatKind::Error(e)
             }
         };
+        let mut thir_pat = Box::new(Pat { ty, span, kind, extra: None });
 
         if let Some(user_ty) = self.user_args_applied_to_ty_of_hir_id(hir_id) {
-            debug!("lower_variant_or_leaf: kind={:?} user_ty={:?} span={:?}", kind, user_ty, span);
+            debug!(?thir_pat, ?user_ty, ?span, "lower_variant_or_leaf: applying ascription");
             let annotation = CanonicalUserTypeAnnotation {
                 user_ty: Box::new(user_ty),
                 span,
                 inferred_ty: self.typeck_results.node_type(hir_id),
             };
-            kind = PatKind::AscribeUserType {
-                subpattern: Box::new(Pat { span, ty, kind }),
-                ascription: Ascription { annotation, variance: ty::Covariant },
-            };
+            thir_pat
+                .extra
+                .get_or_insert_default()
+                .ascriptions
+                .push(Ascription { annotation, variance: ty::Covariant });
         }
 
-        kind
+        thir_pat
     }
 
     fn user_args_applied_to_ty_of_hir_id(
@@ -563,7 +617,16 @@ impl<'tcx> PatCtxt<'tcx> {
     /// it to `const_to_pat`. Any other path (like enum variants without fields)
     /// is converted to the corresponding pattern via `lower_variant_or_leaf`.
     #[instrument(skip(self), level = "debug")]
-    fn lower_path(&mut self, qpath: &hir::QPath<'_>, id: hir::HirId, span: Span) -> Box<Pat<'tcx>> {
+    fn lower_path(
+        &mut self,
+        pat: &'tcx hir::Pat<'tcx>, // Pattern that directly contains `expr`
+        expr: &'tcx hir::PatExpr<'tcx>,
+        qpath: &hir::QPath<'_>,
+    ) -> Box<Pat<'tcx>> {
+        assert_matches!(pat.kind, hir::PatKind::Expr(..) | hir::PatKind::Range(..));
+
+        let id = expr.hir_id;
+        let span = expr.span;
         let ty = self.typeck_results.node_type(id);
         let res = self.typeck_results.qpath_res(qpath, id);
 
@@ -575,8 +638,7 @@ impl<'tcx> PatCtxt<'tcx> {
             _ => {
                 // The path isn't the name of a constant, so it must actually
                 // be a unit struct or unit variant (e.g. `Option::None`).
-                let kind = self.lower_variant_or_leaf(res, id, span, ty, vec![]);
-                return Box::new(Pat { span, ty, kind });
+                return self.lower_variant_or_leaf(pat, Some(expr), res, vec![]);
             }
         };
 
@@ -595,16 +657,13 @@ impl<'tcx> PatCtxt<'tcx> {
                 span,
                 inferred_ty: self.typeck_results.node_type(id),
             };
-            let kind = PatKind::AscribeUserType {
-                subpattern: pattern,
-                ascription: Ascription {
-                    annotation,
-                    // Note that we use `Contravariant` here. See the
-                    // `variance` field documentation for details.
-                    variance: ty::Contravariant,
-                },
-            };
-            pattern = Box::new(Pat { span, kind, ty });
+            // Note that we use `Contravariant` here. See the
+            // `variance` field documentation for details.
+            pattern
+                .extra
+                .get_or_insert_default()
+                .ascriptions
+                .push(Ascription { annotation, variance: ty::Contravariant });
         }
 
         pattern
@@ -615,24 +674,26 @@ impl<'tcx> PatCtxt<'tcx> {
     /// - Literals, possibly negated (e.g. `-128u8`, `"hello"`)
     fn lower_pat_expr(
         &mut self,
+        pat: &'tcx hir::Pat<'tcx>, // Pattern that directly contains `expr`
         expr: &'tcx hir::PatExpr<'tcx>,
-        pat_ty: Option<Ty<'tcx>>,
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
+        assert_matches!(pat.kind, hir::PatKind::Expr(..) | hir::PatKind::Range(..));
         match &expr.kind {
-            hir::PatExprKind::Path(qpath) => self.lower_path(qpath, expr.hir_id, expr.span).kind,
+            hir::PatExprKind::Path(qpath) => self.lower_path(pat, expr, qpath),
             hir::PatExprKind::Lit { lit, negated } => {
                 // We handle byte string literal patterns by using the pattern's type instead of the
                 // literal's type in `const_to_pat`: if the literal `b"..."` matches on a slice reference,
                 // the pattern's type will be `&[u8]` whereas the literal's type is `&[u8; 3]`; using the
                 // pattern's type means we'll properly translate it to a slice reference pattern. This works
                 // because slices and arrays have the same valtree representation.
-                let ct_ty = match pat_ty {
-                    Some(pat_ty) => pat_ty,
-                    None => self.typeck_results.node_type(expr.hir_id),
-                };
-                let lit_input = LitToConstInput { lit: lit.node, ty: ct_ty, neg: *negated };
+                //
+                // Under `feature(deref_patterns)`, this adjustment can also convert string literal
+                // patterns to `str`, and byte-string literal patterns to `[u8; N]` or `[u8]`.
+
+                let pat_ty = self.typeck_results.node_type(pat.hir_id);
+                let lit_input = LitToConstInput { lit: lit.node, ty: pat_ty, neg: *negated };
                 let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
-                self.const_to_pat(constant, ct_ty, expr.hir_id, lit.span).kind
+                self.const_to_pat(constant, pat_ty, expr.hir_id, lit.span)
             }
         }
     }
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 5a2d6cfef1cc..e12909305961 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -73,6 +73,24 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
         self.fmt
     }
 
+    fn print_list<T>(
+        &mut self,
+        label: &str,
+        list: &[T],
+        depth_lvl: usize,
+        print_fn: impl Fn(&mut Self, &T, usize),
+    ) {
+        if list.is_empty() {
+            print_indented!(self, format_args!("{label}: []"), depth_lvl);
+        } else {
+            print_indented!(self, format_args!("{label}: ["), depth_lvl);
+            for item in list {
+                print_fn(self, item, depth_lvl + 1)
+            }
+            print_indented!(self, "]", depth_lvl);
+        }
+    }
+
     fn print_param(&mut self, param: &Param<'tcx>, depth_lvl: usize) {
         let Param { pat, ty, ty_span, self_kind, hir_id } = param;
 
@@ -663,15 +681,37 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
     }
 
     fn print_pat(&mut self, pat: &Pat<'tcx>, depth_lvl: usize) {
-        let &Pat { ty, span, ref kind } = pat;
+        let &Pat { ty, span, ref kind, ref extra } = pat;
 
         print_indented!(self, "Pat: {", depth_lvl);
         print_indented!(self, format!("ty: {:?}", ty), depth_lvl + 1);
         print_indented!(self, format!("span: {:?}", span), depth_lvl + 1);
+        self.print_pat_extra(extra.as_deref(), depth_lvl + 1);
         self.print_pat_kind(kind, depth_lvl + 1);
         print_indented!(self, "}", depth_lvl);
     }
 
+    fn print_pat_extra(&mut self, extra: Option<&PatExtra<'tcx>>, depth_lvl: usize) {
+        let Some(extra) = extra else {
+            // Skip printing in the common case of a pattern node with no extra data.
+            return;
+        };
+
+        let PatExtra { expanded_const, ascriptions } = extra;
+
+        print_indented!(self, "extra: PatExtra {", depth_lvl);
+        print_indented!(self, format_args!("expanded_const: {expanded_const:?}"), depth_lvl + 1);
+        self.print_list(
+            "ascriptions",
+            ascriptions,
+            depth_lvl + 1,
+            |this, ascription, depth_lvl| {
+                print_indented!(this, format_args!("{ascription:?}"), depth_lvl);
+            },
+        );
+        print_indented!(self, "}", depth_lvl);
+    }
+
     fn print_pat_kind(&mut self, pat_kind: &PatKind<'tcx>, depth_lvl: usize) {
         print_indented!(self, "kind: PatKind {", depth_lvl);
 
@@ -685,13 +725,6 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
             PatKind::Never => {
                 print_indented!(self, "Never", depth_lvl + 1);
             }
-            PatKind::AscribeUserType { ascription, subpattern } => {
-                print_indented!(self, "AscribeUserType: {", depth_lvl + 1);
-                print_indented!(self, format!("ascription: {:?}", ascription), depth_lvl + 2);
-                print_indented!(self, "subpattern: ", depth_lvl + 2);
-                self.print_pat(subpattern, depth_lvl + 3);
-                print_indented!(self, "}", depth_lvl + 1);
-            }
             PatKind::Binding { name, mode, var, ty, subpattern, is_primary, is_shorthand } => {
                 print_indented!(self, "Binding {", depth_lvl + 1);
                 print_indented!(self, format!("name: {:?}", name), depth_lvl + 2);
@@ -756,13 +789,6 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 print_indented!(self, format!("value: {}", value), depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
-            PatKind::ExpandedConstant { def_id, subpattern } => {
-                print_indented!(self, "ExpandedConstant {", depth_lvl + 1);
-                print_indented!(self, format!("def_id: {def_id:?}"), depth_lvl + 2);
-                print_indented!(self, "subpattern:", depth_lvl + 2);
-                self.print_pat(subpattern, depth_lvl + 2);
-                print_indented!(self, "}", depth_lvl + 1);
-            }
             PatKind::Range(pat_range) => {
                 print_indented!(self, format!("Range ( {:?} )", pat_range), depth_lvl + 1);
             }
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/mod.rs b/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
index 800d4e406cf0..8be7d210f8df 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
@@ -177,8 +177,9 @@ pub struct MoveData<'tcx> {
     pub rev_lookup: MovePathLookup<'tcx>,
     pub inits: IndexVec<InitIndex, Init>,
     /// Each Location `l` is mapped to the Inits that are effects
-    /// of executing the code at `l`.
-    pub init_loc_map: LocationMap<SmallVec<[InitIndex; 4]>>,
+    /// of executing the code at `l`. Only very rarely (e.g. inline asm)
+    /// is there more than one Init at any `l`.
+    pub init_loc_map: LocationMap<SmallVec<[InitIndex; 1]>>,
     pub init_path_map: IndexVec<MovePathIndex, SmallVec<[InitIndex; 4]>>,
 }
 
diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index ee21d4fbcead..21a6c4d653bc 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -19,14 +19,14 @@ pub(crate) fn emit_inline_always_target_feature_diagnostic<'a, 'tcx>(
     caller_def_id: DefId,
     callee_only: &[&'a str],
 ) {
-    let callee = tcx.def_path_str(callee_def_id);
-    let caller = tcx.def_path_str(caller_def_id);
-
     tcx.node_span_lint(
         lint::builtin::INLINE_ALWAYS_MISMATCHING_TARGET_FEATURES,
         tcx.local_def_id_to_hir_id(caller_def_id.as_local().unwrap()),
         call_span,
         |lint| {
+            let callee = tcx.def_path_str(callee_def_id);
+            let caller = tcx.def_path_str(caller_def_id);
+
             lint.primary_message(format!(
                 "call to `#[inline(always)]`-annotated `{callee}` \
                 requires the same target features to be inlined"
diff --git a/compiler/rustc_monomorphize/Cargo.toml b/compiler/rustc_monomorphize/Cargo.toml
index 09a55f0b5f8d..0829d52283ab 100644
--- a/compiler/rustc_monomorphize/Cargo.toml
+++ b/compiler/rustc_monomorphize/Cargo.toml
@@ -10,6 +10,7 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
+rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_session = { path = "../rustc_session" }
diff --git a/compiler/rustc_monomorphize/messages.ftl b/compiler/rustc_monomorphize/messages.ftl
index edb91d8f2eda..09500ba73359 100644
--- a/compiler/rustc_monomorphize/messages.ftl
+++ b/compiler/rustc_monomorphize/messages.ftl
@@ -75,4 +75,8 @@ monomorphize_recursion_limit =
 monomorphize_start_not_found = using `fn main` requires the standard library
     .help = use `#![no_main]` to bypass the Rust generated entrypoint and declare a platform specific entrypoint yourself, usually with `#[no_mangle]`
 
+monomorphize_static_initializer_cyclic =  static initializer forms a cycle involving `{$head}`
+    .label = part of this cycle
+    .note = cyclic static initializers are not supported for target `{$target}`
+
 monomorphize_symbol_already_defined = symbol `{$symbol}` is already defined
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 4b2f8e03afc1..070db1ae6b5e 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -267,7 +267,8 @@ pub(crate) struct UsageMap<'tcx> {
     // Maps every mono item to the mono items used by it.
     pub used_map: UnordMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,
 
-    // Maps every mono item to the mono items that use it.
+    // Maps each mono item with users to the mono items that use it.
+    // Be careful: subsets `used_map`, so unused items are vacant.
     user_map: UnordMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,
 }
 
diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs
index 4949d9ae3922..723649f22117 100644
--- a/compiler/rustc_monomorphize/src/errors.rs
+++ b/compiler/rustc_monomorphize/src/errors.rs
@@ -117,3 +117,15 @@ pub(crate) struct AbiRequiredTargetFeature<'a> {
     /// Whether this is a problem at a call site or at a declaration.
     pub is_call: bool,
 }
+
+#[derive(Diagnostic)]
+#[diag(monomorphize_static_initializer_cyclic)]
+#[note]
+pub(crate) struct StaticInitializerCyclic<'a> {
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub labels: Vec<Span>,
+    pub head: &'a str,
+    pub target: &'a str,
+}
diff --git a/compiler/rustc_monomorphize/src/graph_checks/mod.rs b/compiler/rustc_monomorphize/src/graph_checks/mod.rs
new file mode 100644
index 000000000000..2b9b7cfff0b2
--- /dev/null
+++ b/compiler/rustc_monomorphize/src/graph_checks/mod.rs
@@ -0,0 +1,18 @@
+//! Checks that need to operate on the entire mono item graph
+use rustc_middle::mir::mono::MonoItem;
+use rustc_middle::ty::TyCtxt;
+
+use crate::collector::UsageMap;
+use crate::graph_checks::statics::check_static_initializers_are_acyclic;
+
+mod statics;
+
+pub(super) fn target_specific_checks<'tcx, 'a, 'b>(
+    tcx: TyCtxt<'tcx>,
+    mono_items: &'a [MonoItem<'tcx>],
+    usage_map: &'b UsageMap<'tcx>,
+) {
+    if tcx.sess.target.options.static_initializer_must_be_acyclic {
+        check_static_initializers_are_acyclic(tcx, mono_items, usage_map);
+    }
+}
diff --git a/compiler/rustc_monomorphize/src/graph_checks/statics.rs b/compiler/rustc_monomorphize/src/graph_checks/statics.rs
new file mode 100644
index 000000000000..a764d307b3d4
--- /dev/null
+++ b/compiler/rustc_monomorphize/src/graph_checks/statics.rs
@@ -0,0 +1,115 @@
+use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::graph::scc::Sccs;
+use rustc_data_structures::graph::{DirectedGraph, Successors};
+use rustc_data_structures::unord::UnordMap;
+use rustc_hir::def_id::DefId;
+use rustc_index::{Idx, IndexVec, newtype_index};
+use rustc_middle::mir::mono::MonoItem;
+use rustc_middle::ty::TyCtxt;
+
+use crate::collector::UsageMap;
+use crate::errors;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct StaticNodeIdx(usize);
+
+impl Idx for StaticNodeIdx {
+    fn new(idx: usize) -> Self {
+        Self(idx)
+    }
+
+    fn index(self) -> usize {
+        self.0
+    }
+}
+
+impl From<usize> for StaticNodeIdx {
+    fn from(value: usize) -> Self {
+        StaticNodeIdx(value)
+    }
+}
+
+newtype_index! {
+    #[derive(Ord, PartialOrd)]
+    struct StaticSccIdx {}
+}
+
+// Adjacency-list graph for statics using `StaticNodeIdx` as node type.
+// We cannot use `DefId` as the node type directly because each node must be
+// represented by an index in the range `0..num_nodes`.
+struct StaticRefGraph<'a, 'b, 'tcx> {
+    // maps from `StaticNodeIdx` to `DefId` and vice versa
+    statics: &'a FxIndexSet<DefId>,
+    // contains for each `MonoItem` the `MonoItem`s it uses
+    used_map: &'b UnordMap<MonoItem<'tcx>, Vec<MonoItem<'tcx>>>,
+}
+
+impl<'a, 'b, 'tcx> DirectedGraph for StaticRefGraph<'a, 'b, 'tcx> {
+    type Node = StaticNodeIdx;
+
+    fn num_nodes(&self) -> usize {
+        self.statics.len()
+    }
+}
+
+impl<'a, 'b, 'tcx> Successors for StaticRefGraph<'a, 'b, 'tcx> {
+    fn successors(&self, node_idx: StaticNodeIdx) -> impl Iterator<Item = StaticNodeIdx> {
+        let def_id = self.statics[node_idx.index()];
+        self.used_map[&MonoItem::Static(def_id)].iter().filter_map(|&mono_item| match mono_item {
+            MonoItem::Static(def_id) => self.statics.get_index_of(&def_id).map(|idx| idx.into()),
+            _ => None,
+        })
+    }
+}
+
+pub(super) fn check_static_initializers_are_acyclic<'tcx, 'a, 'b>(
+    tcx: TyCtxt<'tcx>,
+    mono_items: &'a [MonoItem<'tcx>],
+    usage_map: &'b UsageMap<'tcx>,
+) {
+    // Collect statics
+    let statics: FxIndexSet<DefId> = mono_items
+        .iter()
+        .filter_map(|&mono_item| match mono_item {
+            MonoItem::Static(def_id) => Some(def_id),
+            _ => None,
+        })
+        .collect();
+
+    // If we don't have any statics the check is not necessary
+    if statics.is_empty() {
+        return;
+    }
+    // Create a subgraph from the mono item graph, which only contains statics
+    let graph = StaticRefGraph { statics: &statics, used_map: &usage_map.used_map };
+    // Calculate its SCCs
+    let sccs: Sccs<StaticNodeIdx, StaticSccIdx> = Sccs::new(&graph);
+    // Group statics by SCCs
+    let mut nodes_of_sccs: IndexVec<StaticSccIdx, Vec<StaticNodeIdx>> =
+        IndexVec::from_elem_n(Vec::new(), sccs.num_sccs());
+    for i in graph.iter_nodes() {
+        nodes_of_sccs[sccs.scc(i)].push(i);
+    }
+    let is_cyclic = |nodes_of_scc: &[StaticNodeIdx]| -> bool {
+        match nodes_of_scc.len() {
+            0 => false,
+            1 => graph.successors(nodes_of_scc[0]).any(|x| x == nodes_of_scc[0]),
+            2.. => true,
+        }
+    };
+    // Emit errors for all cycles
+    for nodes in nodes_of_sccs.iter_mut().filter(|nodes| is_cyclic(nodes)) {
+        // We sort the nodes by their Span to have consistent error line numbers
+        nodes.sort_by_key(|node| tcx.def_span(statics[node.index()]));
+
+        let head_def = statics[nodes[0].index()];
+        let head_span = tcx.def_span(head_def);
+
+        tcx.dcx().emit_err(errors::StaticInitializerCyclic {
+            span: head_span,
+            labels: nodes.iter().map(|&n| tcx.def_span(statics[n.index()])).collect(),
+            head: &tcx.def_path_str(head_def),
+            target: &tcx.sess.target.llvm_target,
+        });
+    }
+}
diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs
index 8b48cf5a6501..5b4f74ca6a70 100644
--- a/compiler/rustc_monomorphize/src/lib.rs
+++ b/compiler/rustc_monomorphize/src/lib.rs
@@ -16,6 +16,7 @@ use rustc_span::ErrorGuaranteed;
 
 mod collector;
 mod errors;
+mod graph_checks;
 mod mono_checks;
 mod partitioning;
 mod util;
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 1c8d6db08c31..13d7f6a25f76 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -124,6 +124,7 @@ use tracing::debug;
 
 use crate::collector::{self, MonoItemCollectionStrategy, UsageMap};
 use crate::errors::{CouldntDumpMonoStats, SymbolAlreadyDefined};
+use crate::graph_checks::target_specific_checks;
 
 struct PartitioningCx<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -580,6 +581,16 @@ fn internalize_symbols<'tcx>(
                 }
             }
 
+            // When LTO inlines the caller of a naked function, it will attempt but fail to make the
+            // naked function symbol visible. To ensure that LTO works correctly, do not default
+            // naked functions to internal linkage and default visibility.
+            if let MonoItem::Fn(instance) = item {
+                let flags = cx.tcx.codegen_instance_attrs(instance.def).flags;
+                if flags.contains(CodegenFnAttrFlags::NAKED) {
+                    continue;
+                }
+            }
+
             // If we got here, we did not find any uses from other CGUs, so
             // it's fine to make this monomorphization internal.
             data.linkage = Linkage::Internal;
@@ -1125,6 +1136,8 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> MonoItemPartitio
     };
 
     let (items, usage_map) = collector::collect_crate_mono_items(tcx, collection_strategy);
+    // Perform checks that need to operate on the entire mono item graph
+    target_specific_checks(tcx, &items, &usage_map);
 
     // If there was an error during collection (e.g. from one of the constants we evaluated),
     // then we stop here. This way codegen does not have to worry about failing constants.
diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
index 9162284422d0..8dfa875ca6f9 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
@@ -64,7 +64,7 @@ pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner
     canonicalize_mode: CanonicalizeMode,
 
     // Mutable fields.
-    variables: &'a mut Vec<I::GenericArg>,
+    variables: Vec<I::GenericArg>,
     var_kinds: Vec<CanonicalVarKind<I>>,
     variable_lookup_table: HashMap<I::GenericArg, usize>,
     /// Maps each `sub_unification_table_root_var` to the index of the first
@@ -84,14 +84,13 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     pub(super) fn canonicalize_response<T: TypeFoldable<I>>(
         delegate: &'a D,
         max_input_universe: ty::UniverseIndex,
-        variables: &'a mut Vec<I::GenericArg>,
         value: T,
     ) -> ty::Canonical<I, T> {
         let mut canonicalizer = Canonicalizer {
             delegate,
             canonicalize_mode: CanonicalizeMode::Response { max_input_universe },
 
-            variables,
+            variables: Vec::new(),
             variable_lookup_table: Default::default(),
             sub_root_lookup_table: Default::default(),
             var_kinds: Vec::new(),
@@ -106,16 +105,17 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         };
         debug_assert!(!value.has_infer(), "unexpected infer in {value:?}");
         debug_assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
-        let (max_universe, variables) = canonicalizer.finalize();
-        Canonical { max_universe, variables, value }
+        let (max_universe, _variables, var_kinds) = canonicalizer.finalize();
+        Canonical { max_universe, var_kinds, value }
     }
+
     fn canonicalize_param_env(
         delegate: &'a D,
-        variables: &'a mut Vec<I::GenericArg>,
         param_env: I::ParamEnv,
-    ) -> (I::ParamEnv, HashMap<I::GenericArg, usize>, Vec<CanonicalVarKind<I>>) {
+    ) -> (I::ParamEnv, Vec<I::GenericArg>, Vec<CanonicalVarKind<I>>, HashMap<I::GenericArg, usize>)
+    {
         if !param_env.has_type_flags(NEEDS_CANONICAL) {
-            return (param_env, Default::default(), Vec::new());
+            return (param_env, Vec::new(), Vec::new(), Default::default());
         }
 
         // Check whether we can use the global cache for this param_env. As we only use
@@ -129,12 +129,11 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             delegate.cx().canonical_param_env_cache_get_or_insert(
                 param_env,
                 || {
-                    let mut variables = Vec::new();
                     let mut env_canonicalizer = Canonicalizer {
                         delegate,
                         canonicalize_mode: CanonicalizeMode::Input(CanonicalizeInputKind::ParamEnv),
 
-                        variables: &mut variables,
+                        variables: Vec::new(),
                         variable_lookup_table: Default::default(),
                         sub_root_lookup_table: Default::default(),
                         var_kinds: Vec::new(),
@@ -147,7 +146,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                         param_env,
                         variable_lookup_table: env_canonicalizer.variable_lookup_table,
                         var_kinds: env_canonicalizer.var_kinds,
-                        variables,
+                        variables: env_canonicalizer.variables,
                     }
                 },
                 |&CanonicalParamEnvCacheEntry {
@@ -156,9 +155,12 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                      ref variable_lookup_table,
                      ref var_kinds,
                  }| {
-                    debug_assert!(variables.is_empty());
+                    // FIXME(nnethercote): for reasons I don't understand, this `new`+`extend`
+                    // combination is faster than `variables.clone()`, because it somehow avoids
+                    // some allocations.
+                    let mut variables = Vec::new();
                     variables.extend(cache_variables.iter().copied());
-                    (param_env, variable_lookup_table.clone(), var_kinds.clone())
+                    (param_env, variables, var_kinds.clone(), variable_lookup_table.clone())
                 },
             )
         } else {
@@ -166,7 +168,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                 delegate,
                 canonicalize_mode: CanonicalizeMode::Input(CanonicalizeInputKind::ParamEnv),
 
-                variables,
+                variables: Vec::new(),
                 variable_lookup_table: Default::default(),
                 sub_root_lookup_table: Default::default(),
                 var_kinds: Vec::new(),
@@ -175,7 +177,12 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
             debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
-            (param_env, env_canonicalizer.variable_lookup_table, env_canonicalizer.var_kinds)
+            (
+                param_env,
+                env_canonicalizer.variables,
+                env_canonicalizer.var_kinds,
+                env_canonicalizer.variable_lookup_table,
+            )
         }
     }
 
@@ -189,12 +196,11 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     /// variable in the future by changing the way we detect global where-bounds.
     pub(super) fn canonicalize_input<P: TypeFoldable<I>>(
         delegate: &'a D,
-        variables: &'a mut Vec<I::GenericArg>,
         input: QueryInput<I, P>,
-    ) -> ty::Canonical<I, QueryInput<I, P>> {
+    ) -> (Vec<I::GenericArg>, ty::Canonical<I, QueryInput<I, P>>) {
         // First canonicalize the `param_env` while keeping `'static`
-        let (param_env, variable_lookup_table, var_kinds) =
-            Canonicalizer::canonicalize_param_env(delegate, variables, input.goal.param_env);
+        let (param_env, variables, var_kinds, variable_lookup_table) =
+            Canonicalizer::canonicalize_param_env(delegate, input.goal.param_env);
         // Then canonicalize the rest of the input without keeping `'static`
         // while *mostly* reusing the canonicalizer from above.
         let mut rest_canonicalizer = Canonicalizer {
@@ -234,8 +240,8 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
         debug_assert!(!value.has_infer(), "unexpected infer in {value:?}");
         debug_assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
-        let (max_universe, variables) = rest_canonicalizer.finalize();
-        Canonical { max_universe, variables, value }
+        let (max_universe, variables, var_kinds) = rest_canonicalizer.finalize();
+        (variables, Canonical { max_universe, var_kinds, value })
     }
 
     fn get_or_insert_bound_var(
@@ -243,8 +249,9 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         arg: impl Into<I::GenericArg>,
         kind: CanonicalVarKind<I>,
     ) -> ty::BoundVar {
-        // FIXME: 16 is made up and arbitrary. We should look at some
-        // perf data here.
+        // The exact value of 16 here doesn't matter that much (8 and 32 give extremely similar
+        // results). So long as we have protection against the rare cases where the length reaches
+        // 1000+ (e.g. `wg-grammar`).
         let arg = arg.into();
         let idx = if self.variables.len() > 16 {
             if self.variable_lookup_table.is_empty() {
@@ -276,19 +283,18 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         ty::BoundVar::from(idx)
     }
 
-    fn finalize(self) -> (ty::UniverseIndex, I::CanonicalVarKinds) {
+    fn finalize(self) -> (ty::UniverseIndex, Vec<I::GenericArg>, I::CanonicalVarKinds) {
         let mut var_kinds = self.var_kinds;
         // See the rustc-dev-guide section about how we deal with universes
         // during canonicalization in the new solver.
-        match self.canonicalize_mode {
+        let max_universe = match self.canonicalize_mode {
             // All placeholders and vars are canonicalized in the root universe.
             CanonicalizeMode::Input { .. } => {
                 debug_assert!(
                     var_kinds.iter().all(|var| var.universe() == ty::UniverseIndex::ROOT),
                     "expected all vars to be canonicalized in root universe: {var_kinds:#?}"
                 );
-                let var_kinds = self.delegate.cx().mk_canonical_var_kinds(&var_kinds);
-                (ty::UniverseIndex::ROOT, var_kinds)
+                ty::UniverseIndex::ROOT
             }
             // When canonicalizing a response we map a universes already entered
             // by the caller to the root universe and only return useful universe
@@ -302,15 +308,15 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                     );
                     *var = var.with_updated_universe(new_uv);
                 }
-                let max_universe = var_kinds
+                var_kinds
                     .iter()
                     .map(|kind| kind.universe())
                     .max()
-                    .unwrap_or(ty::UniverseIndex::ROOT);
-                let var_kinds = self.delegate.cx().mk_canonical_var_kinds(&var_kinds);
-                (max_universe, var_kinds)
+                    .unwrap_or(ty::UniverseIndex::ROOT)
             }
-        }
+        };
+        let var_kinds = self.delegate.cx().mk_canonical_var_kinds(&var_kinds);
+        (max_universe, self.variables, var_kinds)
     }
 
     fn inner_fold_ty(&mut self, t: I::Ty) -> I::Ty {
@@ -417,7 +423,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
             // We don't canonicalize `ReStatic` in the `param_env` as we use it
             // when checking whether a `ParamEnv` candidate is global.
             ty::ReStatic => match self.canonicalize_mode {
-                CanonicalizeMode::Input(CanonicalizeInputKind::Predicate { .. }) => {
+                CanonicalizeMode::Input(CanonicalizeInputKind::Predicate) => {
                     CanonicalVarKind::Region(ty::UniverseIndex::ROOT)
                 }
                 CanonicalizeMode::Input(CanonicalizeInputKind::ParamEnv)
@@ -545,7 +551,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
         match self.canonicalize_mode {
             CanonicalizeMode::Input(CanonicalizeInputKind::ParamEnv)
             | CanonicalizeMode::Response { max_input_universe: _ } => {}
-            CanonicalizeMode::Input(CanonicalizeInputKind::Predicate { .. }) => {
+            CanonicalizeMode::Input(CanonicalizeInputKind::Predicate) => {
                 panic!("erasing 'static in env")
             }
         }
diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
index b4cea8701d82..96fea09013a1 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -59,10 +59,8 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    let mut orig_values = Default::default();
-    let canonical = Canonicalizer::canonicalize_input(
+    let (orig_values, canonical) = Canonicalizer::canonicalize_input(
         delegate,
-        &mut orig_values,
         QueryInput {
             goal,
             predefined_opaques_in_body: delegate.cx().mk_predefined_opaques_in_body(opaque_types),
@@ -82,10 +80,7 @@ where
     I: Interner,
     T: TypeFoldable<I>,
 {
-    let mut orig_values = Default::default();
-    let canonical =
-        Canonicalizer::canonicalize_response(delegate, max_input_universe, &mut orig_values, value);
-    canonical
+    Canonicalizer::canonicalize_response(delegate, max_input_universe, value)
 }
 
 /// After calling a canonical query, we apply the constraints returned
@@ -157,7 +152,7 @@ where
     //
     // We therefore instantiate the existential variable in the canonical response with the
     // inference variable of the input right away, which is more performant.
-    let mut opt_values = IndexVec::from_elem_n(None, response.variables.len());
+    let mut opt_values = IndexVec::from_elem_n(None, response.var_kinds.len());
     for (original_value, result_value) in iter::zip(original_values, var_values.var_values.iter()) {
         match result_value.kind() {
             ty::GenericArgKind::Type(t) => {
@@ -167,7 +162,7 @@ where
                 // more involved. They are also a lot rarer than region variables.
                 if let ty::Bound(index_kind, b) = t.kind()
                     && !matches!(
-                        response.variables.get(b.var().as_usize()).unwrap(),
+                        response.var_kinds.get(b.var().as_usize()).unwrap(),
                         CanonicalVarKind::Ty { .. }
                     )
                 {
@@ -189,7 +184,7 @@ where
             }
         }
     }
-    CanonicalVarValues::instantiate(delegate.cx(), response.variables, |var_values, kind| {
+    CanonicalVarValues::instantiate(delegate.cx(), response.var_kinds, |var_values, kind| {
         if kind.universe() != ty::UniverseIndex::ROOT {
             // A variable from inside a binder of the query. While ideally these shouldn't
             // exist at all (see the FIXME at the start of this method), we have to deal with
@@ -308,7 +303,7 @@ where
     let var_values = CanonicalVarValues { var_values: delegate.cx().mk_args(var_values) };
     let state = inspect::State { var_values, data };
     let state = eager_resolve_vars(delegate, state);
-    Canonicalizer::canonicalize_response(delegate, max_input_universe, &mut vec![], state)
+    Canonicalizer::canonicalize_response(delegate, max_input_universe, state)
 }
 
 // FIXME: needs to be pub to be accessed by downstream
@@ -345,14 +340,14 @@ where
 pub fn response_no_constraints_raw<I: Interner>(
     cx: I,
     max_universe: ty::UniverseIndex,
-    variables: I::CanonicalVarKinds,
+    var_kinds: I::CanonicalVarKinds,
     certainty: Certainty,
 ) -> CanonicalResponse<I> {
     ty::Canonical {
         max_universe,
-        variables,
+        var_kinds,
         value: Response {
-            var_values: ty::CanonicalVarValues::make_identity(cx, variables),
+            var_values: ty::CanonicalVarValues::make_identity(cx, var_kinds),
             // FIXME: maybe we should store the "no response" version in cx, like
             // we do for cx.types and stuff.
             external_constraints: cx.mk_external_constraints(ExternalConstraintsData::default()),
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 2f6ff12e1e8d..05ea217c1de0 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -868,7 +868,7 @@ where
             .map(|(pred, _)| pred),
     ));
 
-    // FIXME(associated_const_equality): Also add associated consts to
+    // FIXME(mgca): Also add associated consts to
     // the requirements here.
     for associated_type_def_id in cx.associated_type_def_ids(trait_ref.def_id) {
         // associated types that require `Self: Sized` do not show up in the built-in
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 8d0a3ac94d5a..2fd79f593a5f 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -97,7 +97,7 @@ where
 
     /// The variable info for the `var_values`, only used to make an ambiguous response
     /// with no constraints.
-    variables: I::CanonicalVarKinds,
+    var_kinds: I::CanonicalVarKinds,
 
     /// What kind of goal we're currently computing, see the enum definition
     /// for more info.
@@ -325,7 +325,7 @@ where
             // which we don't do within this evaluation context.
             max_input_universe: ty::UniverseIndex::ROOT,
             initial_opaque_types_storage_num_entries: Default::default(),
-            variables: Default::default(),
+            var_kinds: Default::default(),
             var_values: CanonicalVarValues::dummy(),
             current_goal_kind: CurrentGoalKind::Misc,
             origin_span,
@@ -376,7 +376,7 @@ where
         let initial_opaque_types_storage_num_entries = delegate.opaque_types_storage_num_entries();
         let mut ecx = EvalCtxt {
             delegate,
-            variables: canonical_input.canonical.variables,
+            var_kinds: canonical_input.canonical.var_kinds,
             var_values,
             current_goal_kind: CurrentGoalKind::from_query_input(cx, input),
             max_input_universe: canonical_input.canonical.max_universe,
@@ -1323,7 +1323,7 @@ where
         response_no_constraints_raw(
             self.cx(),
             self.max_input_universe,
-            self.variables,
+            self.var_kinds,
             Certainty::Maybe { cause, opaque_types_jank },
         )
     }
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
index e5658ba32ff6..edf2a5d1ba8d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
@@ -47,7 +47,7 @@ where
         let max_input_universe = outer.max_input_universe;
         let mut nested = EvalCtxt {
             delegate,
-            variables: outer.variables,
+            var_kinds: outer.var_kinds,
             var_values: outer.var_values,
             current_goal_kind: outer.current_goal_kind,
             max_input_universe,
diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
index ea45d5096990..73044b7943ae 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -143,7 +143,7 @@ fn response_no_constraints<I: Interner>(
     Ok(response_no_constraints_raw(
         cx,
         input.canonical.max_universe,
-        input.canonical.variables,
+        input.canonical.var_kinds,
         certainty,
     ))
 }
diff --git a/compiler/rustc_parse/Cargo.toml b/compiler/rustc_parse/Cargo.toml
index 04a51c905661..f0c84e07a56f 100644
--- a/compiler/rustc_parse/Cargo.toml
+++ b/compiler/rustc_parse/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 bitflags = "2.4.1"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 63109c7ba5cb..1cb9a1b65d65 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -1,7 +1,7 @@
 use rustc_ast as ast;
 use rustc_ast::token::{self, MetaVarKind};
 use rustc_ast::tokenstream::ParserRange;
-use rustc_ast::{Attribute, attr};
+use rustc_ast::{AttrItemKind, Attribute, attr};
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, PResult};
 use rustc_span::{BytePos, Span};
@@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
                 this.expect(exp!(CloseParen))?;
             }
             Ok((
-                ast::AttrItem { unsafety, path, args, tokens: None },
+                ast::AttrItem { unsafety, path, args: AttrItemKind::Unparsed(args), tokens: None },
                 Trailing::No,
                 UsePreAttrPos::No,
             ))
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 44fdf146f9c7..e04178645fdd 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -86,9 +86,9 @@ fn has_cfg_or_cfg_attr(attrs: &[Attribute]) -> bool {
     // NOTE: Builtin attributes like `cfg` and `cfg_attr` cannot be renamed via imports.
     // Therefore, the absence of a literal `cfg` or `cfg_attr` guarantees that
     // we don't need to do any eager expansion.
-    attrs.iter().any(|attr| {
-        attr.ident().is_some_and(|ident| ident.name == sym::cfg || ident.name == sym::cfg_attr)
-    })
+    attrs
+        .iter()
+        .any(|attr| attr.name().is_some_and(|ident| ident == sym::cfg || ident == sym::cfg_attr))
 }
 
 impl<'a> Parser<'a> {
@@ -398,10 +398,8 @@ impl<'a> Parser<'a> {
 /// - any single-segment, non-builtin attributes are present, e.g. `derive`,
 ///   `test`, `global_allocator`.
 fn needs_tokens(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| match attr.ident() {
+    attrs.iter().any(|attr| match attr.name() {
         None => !attr.is_doc_comment(),
-        Some(ident) => {
-            ident.name == sym::cfg_attr || !rustc_feature::is_builtin_attr_name(ident.name)
-        }
+        Some(name) => name == sym::cfg_attr || !rustc_feature::is_builtin_attr_name(name),
     })
 }
diff --git a/compiler/rustc_parse/src/parser/tests.rs b/compiler/rustc_parse/src/parser/tests.rs
index a46fcd30fef4..62e97c0c308c 100644
--- a/compiler/rustc_parse/src/parser/tests.rs
+++ b/compiler/rustc_parse/src/parser/tests.rs
@@ -2666,7 +2666,6 @@ fn look_ahead_non_outermost_stream() {
     });
 }
 
-// FIXME(nnethercote) All the output is currently wrong.
 #[test]
 fn debug_lookahead() {
     create_default_session_globals_then(|| {
diff --git a/compiler/rustc_parse_format/Cargo.toml b/compiler/rustc_parse_format/Cargo.toml
index d178fcda1fb9..10b41a39c3bf 100644
--- a/compiler/rustc_parse_format/Cargo.toml
+++ b/compiler/rustc_parse_format/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_lexer = { path = "../rustc_lexer" }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_parse_format/src/lib.rs b/compiler/rustc_parse_format/src/lib.rs
index 86326fc6536c..143fd0c4436c 100644
--- a/compiler/rustc_parse_format/src/lib.rs
+++ b/compiler/rustc_parse_format/src/lib.rs
@@ -184,6 +184,9 @@ pub enum Suggestion {
     /// `format!("{foo:?x}")` -> `format!("{foo:x?}")`
     /// `format!("{foo:?X}")` -> `format!("{foo:X?}")`
     ReorderFormatParameter(Range<usize>, String),
+    /// Add missing colon:
+    /// `format!("{foo?}")` -> `format!("{foo:?}")`
+    AddMissingColon(Range<usize>),
 }
 
 /// The parser structure for interpreting the input format string. This is
@@ -453,10 +456,11 @@ impl<'input> Parser<'input> {
             suggestion: Suggestion::None,
         });
 
-        if let Some((_, _, c)) = self.peek() {
-            match c {
-                '?' => self.suggest_format_debug(),
-                '<' | '^' | '>' => self.suggest_format_align(c),
+        if let (Some((_, _, c)), Some((_, _, nc))) = (self.peek(), self.peek_ahead()) {
+            match (c, nc) {
+                ('?', '}') => self.missing_colon_before_debug_formatter(),
+                ('?', _) => self.suggest_format_debug(),
+                ('<' | '^' | '>', _) => self.suggest_format_align(c),
                 _ => self.suggest_positional_arg_instead_of_captured_arg(arg),
             }
         }
@@ -849,6 +853,23 @@ impl<'input> Parser<'input> {
         }
     }
 
+    fn missing_colon_before_debug_formatter(&mut self) {
+        if let Some((range, _)) = self.consume_pos('?') {
+            let span = range.clone();
+            self.errors.insert(
+                0,
+                ParseError {
+                    description: "expected `}`, found `?`".to_owned(),
+                    note: Some(format!("to print `{{`, you can escape it using `{{{{`",)),
+                    label: "expected `:` before `?` to format with `Debug`".to_owned(),
+                    span: range,
+                    secondary_label: None,
+                    suggestion: Suggestion::AddMissingColon(span),
+                },
+            );
+        }
+    }
+
     fn suggest_format_align(&mut self, alignment: char) {
         if let Some((range, _)) = self.consume_pos(alignment) {
             self.errors.insert(
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 94996c0adb47..ba44aa3a35ab 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -244,10 +244,6 @@ passes_function_not_have_default_implementation = function doesn't have a defaul
 passes_functions_names_duplicated = functions names are duplicated
     .note = all `#[rustc_must_implement_one_of]` arguments must be unique
 
-passes_has_incoherent_inherent_impl =
-    `rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits
-    .label = only adts, extern types and traits are supported
-
 passes_ignored_derived_impls =
     `{$name}` has {$trait_list_len ->
       [one] a derived impl
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2370a7d1dd5c..360feacac0e9 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -21,8 +21,8 @@ use rustc_feature::{
     BuiltinAttribute,
 };
 use rustc_hir::attrs::{
-    AttributeKind, DocAttribute, DocInline, EiiDecl, EiiImpl, InlineAttr, MirDialect, MirPhase,
-    ReprAttr, SanitizerSet,
+    AttributeKind, DocAttribute, DocInline, EiiDecl, EiiImpl, EiiImplResolution, InlineAttr,
+    MirDialect, MirPhase, ReprAttr, SanitizerSet,
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
@@ -229,6 +229,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
                     | AttributeKind::MacroTransparency(_)
+                    | AttributeKind::CfgTrace(..)
                     | AttributeKind::Pointee(..)
                     | AttributeKind::Dummy
                     | AttributeKind::RustcBuiltinMacro { .. }
@@ -302,8 +303,10 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcPassIndirectlyInNonRusticAbis(..)
                     | AttributeKind::PinV2(..)
                     | AttributeKind::WindowsSubsystem(..)
+                    | AttributeKind::CfgAttrTrace
                     | AttributeKind::ThreadLocal
                     | AttributeKind::CfiEncoding { .. }
+                    | AttributeKind::RustcHasIncoherentInherentImpls
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
@@ -323,9 +326,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                         [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
-                        [sym::rustc_has_incoherent_inherent_impls, ..] => {
-                            self.check_has_incoherent_inherent_impls(attr, span, target)
-                        }
                         [sym::autodiff_forward, ..] | [sym::autodiff_reverse, ..] => {
                             self.check_autodiff(hir_id, attr, span, target)
                         }
@@ -338,8 +338,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::forbid
                             | sym::cfg
                             | sym::cfg_attr
-                            | sym::cfg_trace
-                            | sym::cfg_attr_trace
                             // need to be fixed
                             | sym::patchable_function_entry // FIXME(patchable_function_entry)
                             | sym::deprecated_safe // FIXME(deprecated_safe)
@@ -391,7 +389,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             attr.path
                                 .segments
                                 .first()
-                                .and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name))
+                                .and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name))
                         {
                             match attr.style {
                                 ast::AttrStyle::Outer => {
@@ -428,7 +426,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
             if let Attribute::Unparsed(unparsed_attr) = attr
                 && let Some(BuiltinAttribute { duplicates, .. }) =
-                    attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name))
+                    attr.name().and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name))
             {
                 check_duplicates(
                     self.tcx,
@@ -506,7 +504,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     fn check_eii_impl(&self, impls: &[EiiImpl], target: Target) {
-        for EiiImpl { span, inner_span, eii_macro, impl_marked_unsafe, is_default: _ } in impls {
+        for EiiImpl { span, inner_span, resolution, impl_marked_unsafe, is_default: _ } in impls {
             match target {
                 Target::Fn => {}
                 _ => {
@@ -514,7 +512,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 }
             }
 
-            if find_attr!(self.tcx.get_all_attrs(*eii_macro), AttributeKind::EiiExternTarget(EiiDecl { impl_unsafe, .. }) if *impl_unsafe)
+            if let EiiImplResolution::Macro(eii_macro) = resolution
+                && find_attr!(self.tcx.get_all_attrs(*eii_macro), AttributeKind::EiiExternTarget(EiiDecl { impl_unsafe, .. }) if *impl_unsafe)
                 && !impl_marked_unsafe
             {
                 self.dcx().emit_err(errors::EiiImplRequiresUnsafe {
@@ -758,9 +757,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 if let Some(impls) = find_attr!(attrs, AttributeKind::EiiImpls(impls) => impls) {
                     let sig = self.tcx.hir_node(hir_id).fn_sig().unwrap();
                     for i in impls {
+                        let name = match i.resolution {
+                            EiiImplResolution::Macro(def_id) => self.tcx.item_name(def_id),
+                            EiiImplResolution::Known(decl) => decl.name.name,
+                            EiiImplResolution::Error(_eg) => continue,
+                        };
                         self.dcx().emit_err(errors::EiiWithTrackCaller {
                             attr_span,
-                            name: self.tcx.item_name(i.eii_macro),
+                            name,
                             sig_span: sig.span,
                         });
                     }
@@ -1158,17 +1162,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_has_incoherent_inherent_impls(&self, attr: &Attribute, span: Span, target: Target) {
-        match target {
-            Target::Trait | Target::Struct | Target::Enum | Target::Union | Target::ForeignTy => {}
-            _ => {
-                self.tcx
-                    .dcx()
-                    .emit_err(errors::HasIncoherentInherentImpl { attr_span: attr.span(), span });
-            }
-        }
-    }
-
     fn check_ffi_pure(&self, attr_span: Span, attrs: &[Attribute]) {
         if find_attr!(attrs, AttributeKind::FfiConst(_)) {
             // `#[ffi_const]` functions cannot be `#[ffi_pure]`
@@ -1950,12 +1943,10 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
         // only `#[cfg]` and `#[cfg_attr]` are allowed, but it should be removed
         // if we allow more attributes (e.g., tool attributes and `allow/deny/warn`)
         // in where clauses. After that, only `self.check_attributes` should be enough.
-        const ATTRS_ALLOWED: &[Symbol] = &[sym::cfg_trace, sym::cfg_attr_trace];
         let spans = self
             .tcx
             .hir_attrs(where_predicate.hir_id)
             .iter()
-            .filter(|attr| !ATTRS_ALLOWED.iter().any(|&sym| attr.has_name(sym)))
             // FIXME: We shouldn't need to special-case `doc`!
             .filter(|attr| {
                 matches!(
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 0563e9619419..3294b6802a71 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -778,6 +778,15 @@ fn maybe_record_as_seed<'tcx>(
                 match tcx.def_kind(parent) {
                     DefKind::Impl { of_trait: false } | DefKind::Trait => {}
                     DefKind::Impl { of_trait: true } => {
+                        if let Some(trait_item_def_id) =
+                            tcx.associated_item(owner_id.def_id).trait_item_def_id()
+                            && let Some(trait_item_local_def_id) = trait_item_def_id.as_local()
+                            && let Some(comes_from_allow) =
+                                has_allow_dead_code_or_lang_attr(tcx, trait_item_local_def_id)
+                        {
+                            worklist.push((owner_id.def_id, comes_from_allow));
+                        }
+
                         // We only care about associated items of traits,
                         // because they cannot be visited directly,
                         // so we later mark them as live if their corresponding traits
@@ -791,6 +800,14 @@ fn maybe_record_as_seed<'tcx>(
         }
         DefKind::Impl { of_trait: true } => {
             if allow_dead_code.is_none() {
+                if let Some(trait_def_id) =
+                    tcx.impl_trait_ref(owner_id.def_id).skip_binder().def_id.as_local()
+                    && let Some(comes_from_allow) =
+                        has_allow_dead_code_or_lang_attr(tcx, trait_def_id)
+                {
+                    worklist.push((owner_id.def_id, comes_from_allow));
+                }
+
                 unsolved_items.push(owner_id.def_id);
             }
         }
diff --git a/compiler/rustc_passes/src/eii.rs b/compiler/rustc_passes/src/eii.rs
index ab3f9f0d2182..f3e84665f21d 100644
--- a/compiler/rustc_passes/src/eii.rs
+++ b/compiler/rustc_passes/src/eii.rs
@@ -81,7 +81,7 @@ pub(crate) fn check_externally_implementable_items<'tcx>(tcx: TyCtxt<'tcx>, ():
     }
 
     // now we have all eiis! For each of them, choose one we want to actually generate.
-    for (decl_did, FoundEii { decl, decl_crate, impls }) in eiis {
+    for (foreign_item, FoundEii { decl, decl_crate, impls }) in eiis {
         let mut default_impls = Vec::new();
         let mut explicit_impls = Vec::new();
 
@@ -97,7 +97,7 @@ pub(crate) fn check_externally_implementable_items<'tcx>(tcx: TyCtxt<'tcx>, ():
         // is instantly an error.
         if explicit_impls.len() > 1 {
             tcx.dcx().emit_err(DuplicateEiiImpls {
-                name: tcx.item_name(decl_did),
+                name: decl.name.name,
                 first_span: tcx.def_span(explicit_impls[0].0),
                 first_crate: tcx.crate_name(explicit_impls[0].1),
                 second_span: tcx.def_span(explicit_impls[1].0),
@@ -116,7 +116,7 @@ pub(crate) fn check_externally_implementable_items<'tcx>(tcx: TyCtxt<'tcx>, ():
         }
 
         if default_impls.len() > 1 {
-            let decl_span = tcx.def_ident_span(decl_did).unwrap();
+            let decl_span = tcx.def_ident_span(foreign_item).unwrap();
             tcx.dcx().span_delayed_bug(decl_span, "multiple not supported right now");
         }
 
@@ -139,8 +139,9 @@ pub(crate) fn check_externally_implementable_items<'tcx>(tcx: TyCtxt<'tcx>, ():
                     tcx.dcx().emit_err(EiiWithoutImpl {
                         current_crate_name: tcx.crate_name(LOCAL_CRATE),
                         decl_crate_name: tcx.crate_name(decl_crate),
-                        name: tcx.item_name(decl_did),
-                        span: decl.span,
+                        // FIXME: shouldn't call `item_name`
+                        name: decl.name.name,
+                        span: decl.name.span,
                         help: (),
                     });
 
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index af5cb29b83d0..14555765e423 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -187,15 +187,6 @@ pub(crate) struct DocAttrNotCrateLevel<'a> {
     pub attr_name: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_has_incoherent_inherent_impl)]
-pub(crate) struct HasIncoherentInherentImpl {
-    #[primary_span]
-    pub attr_span: Span,
-    #[label]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_both_ffi_const_and_pure, code = E0757)]
 pub(crate) struct BothFfiConstAndPure {
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index d66c303b1726..721635ed48ff 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -462,8 +462,6 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         let arity;
         let fields: Vec<_>;
         match &pat.kind {
-            PatKind::AscribeUserType { subpattern, .. }
-            | PatKind::ExpandedConstant { subpattern, .. } => return self.lower_pat(subpattern),
             PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
             PatKind::Missing | PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
                 ctor = Wildcard;
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
index 971616b18914..bf236b7737d9 100644
--- a/compiler/rustc_pattern_analysis/src/usefulness.rs
+++ b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -169,7 +169,7 @@
 //! on pattern-tuples.
 //!
 //! Let `pt_1, .., pt_n` and `qt` be length-m tuples of patterns for the same type `(T_1, .., T_m)`.
-//! We compute `usefulness(tp_1, .., tp_n, tq)` as follows:
+//! We compute `usefulness(pt_1, .., pt_n, qt)` as follows:
 //!
 //! - Base case: `m == 0`.
 //!     The pattern-tuples are all empty, i.e. they're all `()`. Thus `tq` is useful iff there are
diff --git a/compiler/rustc_proc_macro/Cargo.toml b/compiler/rustc_proc_macro/Cargo.toml
index beb95aa3b52f..54c765075113 100644
--- a/compiler/rustc_proc_macro/Cargo.toml
+++ b/compiler/rustc_proc_macro/Cargo.toml
@@ -16,7 +16,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_query_system/src/ich/hcx.rs b/compiler/rustc_query_system/src/ich/hcx.rs
index be838f689e53..840f0b35266d 100644
--- a/compiler/rustc_query_system/src/ich/hcx.rs
+++ b/compiler/rustc_query_system/src/ich/hcx.rs
@@ -5,9 +5,7 @@ use rustc_hir::definitions::DefPathHash;
 use rustc_session::Session;
 use rustc_session::cstore::Untracked;
 use rustc_span::source_map::SourceMap;
-use rustc_span::{
-    BytePos, CachingSourceMapView, DUMMY_SP, Span, SpanData, StableSourceFileId, Symbol,
-};
+use rustc_span::{BytePos, CachingSourceMapView, DUMMY_SP, SourceFile, Span, SpanData, Symbol};
 
 use crate::ich;
 
@@ -118,7 +116,7 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
     fn span_data_to_lines_and_cols(
         &mut self,
         span: &SpanData,
-    ) -> Option<(StableSourceFileId, usize, BytePos, usize, BytePos)> {
+    ) -> Option<(&SourceFile, usize, BytePos, usize, BytePos)> {
         self.source_map().span_data_to_lines_and_cols(span)
     }
 
diff --git a/compiler/rustc_query_system/src/ich/impls_syntax.rs b/compiler/rustc_query_system/src/ich/impls_syntax.rs
index 118229ffc990..fe6fb3d65194 100644
--- a/compiler/rustc_query_system/src/ich/impls_syntax.rs
+++ b/compiler/rustc_query_system/src/ich/impls_syntax.rs
@@ -24,7 +24,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for [hir::Attribute] {
             .filter(|attr| {
                 attr.is_doc_comment().is_none()
                     // FIXME(jdonszelmann) have a better way to handle ignored attrs
-                    && !attr.ident().is_some_and(|ident| hcx.is_ignored_attr(ident.name))
+                    && !attr.name().is_some_and(|ident| hcx.is_ignored_attr(ident))
             })
             .collect();
 
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index b9c945a440f8..752d8c46beb4 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -22,7 +22,7 @@ use rustc_hir::def::{self, *};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_metadata::creader::LoadedMacro;
-use rustc_middle::metadata::{AmbigModChildKind, ModChild, Reexport};
+use rustc_middle::metadata::{ModChild, Reexport};
 use rustc_middle::ty::{Feed, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
@@ -33,31 +33,33 @@ use tracing::debug;
 use crate::Namespace::{MacroNS, TypeNS, ValueNS};
 use crate::def_collector::collect_definitions;
 use crate::imports::{ImportData, ImportKind};
-use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
+use crate::macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
 use crate::ref_mut::CmCell;
 use crate::{
-    AmbiguityKind, BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind,
-    ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
-    ResolutionError, Resolver, Segment, Used, VisResolutionError, errors,
+    BindingKey, Decl, DeclData, DeclKind, ExternPreludeEntry, Finalize, MacroData, Module,
+    ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, ResolutionError, Resolver, Segment,
+    Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
 
 impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
-    /// Defines `name` in namespace `ns` of module `parent` to be `def` if it is not yet defined;
-    /// otherwise, reports an error.
-    pub(crate) fn define_binding_local(
+    /// Attempt to put the declaration with the given name and namespace into the module,
+    /// and report an error in case of a collision.
+    pub(crate) fn plant_decl_into_local_module(
         &mut self,
         parent: Module<'ra>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
-        binding: NameBinding<'ra>,
+        decl: Decl<'ra>,
     ) {
-        if let Err(old_binding) = self.try_define_local(parent, ident, ns, binding, false) {
-            self.report_conflict(parent, ident, ns, old_binding, binding);
+        if let Err(old_decl) = self.try_plant_decl_into_local_module(parent, ident, ns, decl, false)
+        {
+            self.report_conflict(parent, ident.0, ns, old_decl, decl);
         }
     }
 
+    /// Create a name definitinon from the given components, and put it into the local module.
     fn define_local(
         &mut self,
         parent: Module<'ra>,
@@ -68,28 +70,30 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         span: Span,
         expn_id: LocalExpnId,
     ) {
-        let binding = self.arenas.new_res_binding(res, vis.to_def_id(), span, expn_id);
-        self.define_binding_local(parent, ident, ns, binding);
+        let decl = self.arenas.new_def_decl(res, vis.to_def_id(), span, expn_id);
+        let ident = Macros20NormalizedIdent::new(ident);
+        self.plant_decl_into_local_module(parent, ident, ns, decl);
     }
 
+    /// Create a name definitinon from the given components, and put it into the extern module.
     fn define_extern(
         &self,
         parent: Module<'ra>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
         child_index: usize,
         res: Res,
         vis: Visibility<DefId>,
         span: Span,
         expansion: LocalExpnId,
-        ambiguity: Option<(NameBinding<'ra>, AmbiguityKind)>,
+        ambiguity: Option<Decl<'ra>>,
     ) {
-        let binding = self.arenas.alloc_name_binding(NameBindingData {
-            kind: NameBindingKind::Res(res),
-            ambiguity,
+        let decl = self.arenas.alloc_decl(DeclData {
+            kind: DeclKind::Def(res),
+            ambiguity: CmCell::new(ambiguity),
             // External ambiguities always report the `AMBIGUOUS_GLOB_IMPORTS` lint at the moment.
-            warn_ambiguity: true,
-            vis,
+            warn_ambiguity: CmCell::new(true),
+            vis: CmCell::new(vis),
             span,
             expansion,
         });
@@ -101,8 +105,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         if self
             .resolution_or_default(parent, key)
             .borrow_mut_unchecked()
-            .non_glob_binding
-            .replace(binding)
+            .non_glob_decl
+            .replace(decl)
             .is_some()
         {
             span_bug!(span, "an external binding was already defined");
@@ -254,7 +258,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 &child.main,
                 parent_scope,
                 children.len() + i,
-                Some((&child.second, child.kind)),
+                Some(&child.second),
             )
         }
     }
@@ -265,7 +269,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         child: &ModChild,
         parent_scope: ParentScope<'ra>,
         child_index: usize,
-        ambig_child: Option<(&ModChild, AmbigModChildKind)>,
+        ambig_child: Option<&ModChild>,
     ) {
         let parent = parent_scope.module;
         let child_span = |this: &Self, reexport_chain: &[Reexport], res: def::Res<_>| {
@@ -277,18 +281,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             )
         };
         let ModChild { ident, res, vis, ref reexport_chain } = *child;
+        let ident = Macros20NormalizedIdent::new(ident);
         let span = child_span(self, reexport_chain, res);
         let res = res.expect_non_local();
         let expansion = parent_scope.expansion;
-        let ambig = ambig_child.map(|(ambig_child, ambig_kind)| {
+        let ambig = ambig_child.map(|ambig_child| {
             let ModChild { ident: _, res, vis, ref reexport_chain } = *ambig_child;
             let span = child_span(self, reexport_chain, res);
             let res = res.expect_non_local();
-            let ambig_kind = match ambig_kind {
-                AmbigModChildKind::GlobVsGlob => AmbiguityKind::GlobVsGlob,
-                AmbigModChildKind::GlobVsExpanded => AmbiguityKind::GlobVsExpanded,
-            };
-            (self.arenas.new_res_binding(res, vis, span, expansion), ambig_kind)
+            self.arenas.new_def_decl(res, vis, span, expansion)
         });
 
         // Record primary definitions.
@@ -533,7 +534,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 if target.name != kw::Underscore {
                     self.r.per_ns(|this, ns| {
                         if !type_ns_only || ns == TypeNS {
-                            let key = BindingKey::new(target, ns);
+                            let key = BindingKey::new(Macros20NormalizedIdent::new(target), ns);
                             this.resolution_or_default(current_module, key)
                                 .borrow_mut(this)
                                 .single_imports
@@ -695,7 +696,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 let kind = ImportKind::Single {
                     source: source.ident,
                     target: ident,
-                    bindings: Default::default(),
+                    decls: Default::default(),
                     type_ns_only,
                     nested,
                     id,
@@ -981,7 +982,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let parent_scope = self.parent_scope;
         let expansion = parent_scope.expansion;
 
-        let (used, module, binding) = if orig_name.is_none() && ident.name == kw::SelfLower {
+        let (used, module, decl) = if orig_name.is_none() && ident.name == kw::SelfLower {
             self.r.dcx().emit_err(errors::ExternCrateSelfRequiresRenaming { span: sp });
             return;
         } else if orig_name == Some(kw::SelfLower) {
@@ -1001,10 +1002,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
         .map(|module| {
             let used = self.process_macro_use_imports(item, module);
-            let binding = self.r.arenas.new_pub_res_binding(module.res().unwrap(), sp, expansion);
-            (used, Some(ModuleOrUniformRoot::Module(module)), binding)
+            let decl = self.r.arenas.new_pub_def_decl(module.res().unwrap(), sp, expansion);
+            (used, Some(ModuleOrUniformRoot::Module(module)), decl)
         })
-        .unwrap_or((true, None, self.r.dummy_binding));
+        .unwrap_or((true, None, self.r.dummy_decl));
         let import = self.r.arenas.alloc_import(ImportData {
             kind: ImportKind::ExternCrate { source: orig_name, target: ident, id: item.id },
             root_id: item.id,
@@ -1023,15 +1024,15 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             self.r.import_use_map.insert(import, Used::Other);
         }
         self.r.potentially_unused_imports.push(import);
-        let imported_binding = self.r.import(binding, import);
+        let import_decl = self.r.new_import_decl(decl, import);
+        let ident = Macros20NormalizedIdent::new(ident);
         if ident.name != kw::Underscore && parent == self.r.graph_root {
-            let norm_ident = Macros20NormalizedIdent::new(ident);
             // FIXME: this error is technically unnecessary now when extern prelude is split into
             // two scopes, remove it with lang team approval.
-            if let Some(entry) = self.r.extern_prelude.get(&norm_ident)
+            if let Some(entry) = self.r.extern_prelude.get(&ident)
                 && expansion != LocalExpnId::ROOT
                 && orig_name.is_some()
-                && entry.item_binding.is_none()
+                && entry.item_decl.is_none()
             {
                 self.r.dcx().emit_err(
                     errors::MacroExpandedExternCrateCannotShadowExternArguments { span: item.span },
@@ -1039,24 +1040,24 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             }
 
             use indexmap::map::Entry;
-            match self.r.extern_prelude.entry(norm_ident) {
+            match self.r.extern_prelude.entry(ident) {
                 Entry::Occupied(mut occupied) => {
                     let entry = occupied.get_mut();
-                    if entry.item_binding.is_some() {
+                    if entry.item_decl.is_some() {
                         let msg = format!("extern crate `{ident}` already in extern prelude");
                         self.r.tcx.dcx().span_delayed_bug(item.span, msg);
                     } else {
-                        entry.item_binding = Some((imported_binding, orig_name.is_some()));
+                        entry.item_decl = Some((import_decl, orig_name.is_some()));
                     }
                     entry
                 }
                 Entry::Vacant(vacant) => vacant.insert(ExternPreludeEntry {
-                    item_binding: Some((imported_binding, true)),
-                    flag_binding: None,
+                    item_decl: Some((import_decl, true)),
+                    flag_decl: None,
                 }),
             };
         }
-        self.r.define_binding_local(parent, ident, TypeNS, imported_binding);
+        self.r.plant_decl_into_local_module(parent, ident, TypeNS, import_decl);
     }
 
     /// Constructs the reduced graph for one foreign item.
@@ -1093,14 +1094,14 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
     }
 
-    fn add_macro_use_binding(
+    fn add_macro_use_decl(
         &mut self,
         name: Symbol,
-        binding: NameBinding<'ra>,
+        decl: Decl<'ra>,
         span: Span,
         allow_shadowing: bool,
     ) {
-        if self.r.macro_use_prelude.insert(name, binding).is_some() && !allow_shadowing {
+        if self.r.macro_use_prelude.insert(name, decl).is_some() && !allow_shadowing {
             self.r.dcx().emit_err(errors::MacroUseNameAlreadyInUse { span, name });
         }
     }
@@ -1159,20 +1160,20 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             self.r.potentially_unused_imports.push(import);
             module.for_each_child_mut(self, |this, ident, ns, binding| {
                 if ns == MacroNS {
-                    let import = if this.r.is_accessible_from(binding.vis, this.parent_scope.module)
-                    {
-                        import
-                    } else {
-                        // FIXME: This branch is used for reporting the `private_macro_use` lint
-                        // and should eventually be removed.
-                        if this.r.macro_use_prelude.contains_key(&ident.name) {
-                            // Do not override already existing entries with compatibility entries.
-                            return;
-                        }
-                        macro_use_import(this, span, true)
-                    };
-                    let import_binding = this.r.import(binding, import);
-                    this.add_macro_use_binding(ident.name, import_binding, span, allow_shadowing);
+                    let import =
+                        if this.r.is_accessible_from(binding.vis(), this.parent_scope.module) {
+                            import
+                        } else {
+                            // FIXME: This branch is used for reporting the `private_macro_use` lint
+                            // and should eventually be removed.
+                            if this.r.macro_use_prelude.contains_key(&ident.name) {
+                                // Do not override already existing entries with compatibility entries.
+                                return;
+                            }
+                            macro_use_import(this, span, true)
+                        };
+                    let import_decl = this.r.new_import_decl(binding, import);
+                    this.add_macro_use_decl(ident.name, import_decl, span, allow_shadowing);
                 }
             });
         } else {
@@ -1187,13 +1188,8 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 if let Ok(binding) = result {
                     let import = macro_use_import(self, ident.span, false);
                     self.r.potentially_unused_imports.push(import);
-                    let imported_binding = self.r.import(binding, import);
-                    self.add_macro_use_binding(
-                        ident.name,
-                        imported_binding,
-                        ident.span,
-                        allow_shadowing,
-                    );
+                    let import_decl = self.r.new_import_decl(binding, import);
+                    self.add_macro_use_decl(ident.name, import_decl, ident.span, allow_shadowing);
                 } else {
                     self.r.dcx().emit_err(errors::ImportedMacroNotFound { span: ident.span });
                 }
@@ -1296,16 +1292,16 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.r.local_macro_def_scopes.insert(def_id, parent_scope.module);
 
         if macro_rules {
-            let ident = ident.normalize_to_macros_2_0();
-            self.r.macro_names.insert(ident);
+            let ident = Macros20NormalizedIdent::new(ident);
+            self.r.macro_names.insert(ident.0);
             let is_macro_export = ast::attr::contains_name(&item.attrs, sym::macro_export);
             let vis = if is_macro_export {
                 Visibility::Public
             } else {
                 Visibility::Restricted(CRATE_DEF_ID)
             };
-            let binding = self.r.arenas.new_res_binding(res, vis.to_def_id(), span, expansion);
-            self.r.set_binding_parent_module(binding, parent_scope.module);
+            let decl = self.r.arenas.new_def_decl(res, vis.to_def_id(), span, expansion);
+            self.r.set_decl_parent_module(decl, parent_scope.module);
             self.r.all_macro_rules.insert(ident.name);
             if is_macro_export {
                 let import = self.r.arenas.alloc_import(ImportData {
@@ -1323,17 +1319,17 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     vis_span: item.vis.span,
                 });
                 self.r.import_use_map.insert(import, Used::Other);
-                let import_binding = self.r.import(binding, import);
-                self.r.define_binding_local(self.r.graph_root, ident, MacroNS, import_binding);
+                let import_decl = self.r.new_import_decl(decl, import);
+                self.r.plant_decl_into_local_module(self.r.graph_root, ident, MacroNS, import_decl);
             } else {
-                self.r.check_reserved_macro_name(ident, res);
-                self.insert_unused_macro(ident, def_id, item.id);
+                self.r.check_reserved_macro_name(ident.0, res);
+                self.insert_unused_macro(ident.0, def_id, item.id);
             }
             self.r.feed_visibility(feed, vis);
-            let scope = self.r.arenas.alloc_macro_rules_scope(MacroRulesScope::Binding(
-                self.r.arenas.alloc_macro_rules_binding(MacroRulesBinding {
+            let scope = self.r.arenas.alloc_macro_rules_scope(MacroRulesScope::Def(
+                self.r.arenas.alloc_macro_rules_decl(MacroRulesDecl {
                     parent_macro_rules_scope: parent_scope.macro_rules,
-                    binding,
+                    decl,
                     ident,
                 }),
             ));
@@ -1494,7 +1490,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         {
             // Don't add underscore names, they cannot be looked up anyway.
             let impl_def_id = self.r.tcx.local_parent(local_def_id);
-            let key = BindingKey::new(ident, ns);
+            let key = BindingKey::new(Macros20NormalizedIdent::new(ident), ns);
             self.r.impl_binding_keys.entry(impl_def_id).or_default().insert(key);
         }
 
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 5349cf6d7dbe..3724fcfce40f 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -36,7 +36,7 @@ use rustc_session::lint::builtin::{
 use rustc_span::{DUMMY_SP, Ident, Macros20NormalizedIdent, Span, kw};
 
 use crate::imports::{Import, ImportKind};
-use crate::{LexicalScopeBinding, NameBindingKind, Resolver, module_to_string};
+use crate::{DeclKind, LateDecl, Resolver, module_to_string};
 
 struct UnusedImport {
     use_tree: ast::UseTree,
@@ -514,8 +514,8 @@ impl Resolver<'_, '_> {
         let mut check_redundant_imports = FxIndexSet::default();
         for module in &self.local_modules {
             for (_key, resolution) in self.resolutions(*module).borrow().iter() {
-                if let Some(binding) = resolution.borrow().best_binding()
-                    && let NameBindingKind::Import { import, .. } = binding.kind
+                if let Some(decl) = resolution.borrow().best_decl()
+                    && let DeclKind::Import { import, .. } = decl.kind
                     && let ImportKind::Single { id, .. } = import.kind
                 {
                     if let Some(unused_import) = unused_imports.get(&import.root_id)
@@ -542,8 +542,8 @@ impl Resolver<'_, '_> {
         // Deleting both unused imports and unnecessary segments of an item may result
         // in the item not being found.
         for unn_qua in &self.potentially_unnecessary_qualifications {
-            if let LexicalScopeBinding::Item(name_binding) = unn_qua.binding
-                && let NameBindingKind::Import { import, .. } = name_binding.kind
+            if let LateDecl::Decl(decl) = unn_qua.decl
+                && let DeclKind::Import { import, .. } = decl.kind
                 && (is_unused_import(import, &unused_imports)
                     || is_redundant_import(import, &redundant_imports))
             {
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index b50fc201bdb8..b392b7747b55 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -419,7 +419,9 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
 
             // Avoid overwriting `const_arg_context` as we may want to treat const blocks
             // as being anon consts if we are inside a const argument.
-            ExprKind::Struct(_) => return visit::walk_expr(self, expr),
+            ExprKind::Struct(_) | ExprKind::Call(..) | ExprKind::Tup(..) => {
+                return visit::walk_expr(self, expr);
+            }
             // FIXME(mgca): we may want to handle block labels in some manner
             ExprKind::Block(block, _) if let [stmt] = block.stmts.as_slice() => match stmt.kind {
                 // FIXME(mgca): this probably means that mac calls that expand
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 8f20b5fe5745..9781a77871f6 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -44,11 +44,10 @@ use crate::errors::{
 use crate::imports::{Import, ImportKind};
 use crate::late::{DiagMetadata, PatternSource, Rib};
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingError, BindingKey, Finalize,
-    ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope, Module,
-    ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
-    PrivacyError, ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used,
-    VisResolutionError, errors as errs, path_names_to_string,
+    AmbiguityError, AmbiguityKind, BindingError, BindingKey, Decl, DeclKind, Finalize,
+    ForwardGenericParamBanReason, HasGenericParams, LateDecl, MacroRulesScope, Module, ModuleKind,
+    ModuleOrUniformRoot, ParentScope, PathResult, PrivacyError, ResolutionError, Resolver, Scope,
+    ScopeSet, Segment, UseError, Used, VisResolutionError, errors as errs, path_names_to_string,
 };
 
 type Res = def::Res<ast::NodeId>;
@@ -149,8 +148,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             if ambiguity_error.warning {
                 let node_id = match ambiguity_error.b1.0.kind {
-                    NameBindingKind::Import { import, .. } => import.root_id,
-                    NameBindingKind::Res(_) => CRATE_NODE_ID,
+                    DeclKind::Import { import, .. } => import.root_id,
+                    DeclKind::Def(_) => CRATE_NODE_ID,
                 };
                 self.lint_buffer.buffer_lint(
                     AMBIGUOUS_GLOB_IMPORTS,
@@ -212,8 +211,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         parent: Module<'_>,
         ident: Ident,
         ns: Namespace,
-        new_binding: NameBinding<'ra>,
-        old_binding: NameBinding<'ra>,
+        new_binding: Decl<'ra>,
+        old_binding: Decl<'ra>,
     ) {
         // Error on the second of two conflicting names
         if old_binding.span.lo() > new_binding.span.lo() {
@@ -288,8 +287,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .with_code(code);
 
         // See https://github.com/rust-lang/rust/issues/32354
-        use NameBindingKind::Import;
-        let can_suggest = |binding: NameBinding<'_>, import: self::Import<'_>| {
+        use DeclKind::Import;
+        let can_suggest = |binding: Decl<'_>, import: self::Import<'_>| {
             !binding.span.is_dummy()
                 && !matches!(import.kind, ImportKind::MacroUse { .. } | ImportKind::MacroExport)
         };
@@ -473,7 +472,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         &mut self,
         finalize: Finalize,
         path: &[Segment],
-        second_binding: Option<NameBinding<'_>>,
+        second_binding: Option<Decl<'_>>,
     ) {
         let Finalize { node_id, root_span, .. } = finalize;
 
@@ -506,7 +505,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // `ExternCrate` (also used for `crate::...`) then no need to issue a
         // warning, this looks all good!
         if let Some(binding) = second_binding
-            && let NameBindingKind::Import { import, .. } = binding.kind
+            && let DeclKind::Import { import, .. } = binding.kind
             // Careful: we still want to rewrite paths from renamed extern crates.
             && let ImportKind::ExternCrate { source: None, .. } = import.kind
         {
@@ -1188,7 +1187,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 .get(&expn_id)
                                 .into_iter()
                                 .flatten()
-                                .map(|(ident, _)| TypoSuggestion::typo_from_ident(*ident, res)),
+                                .map(|(ident, _)| TypoSuggestion::typo_from_ident(ident.0, res)),
                         );
                     }
                 }
@@ -1196,19 +1195,20 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     // Never recommend deprecated helper attributes.
                 }
                 Scope::MacroRules(macro_rules_scope) => {
-                    if let MacroRulesScope::Binding(macro_rules_binding) = macro_rules_scope.get() {
-                        let res = macro_rules_binding.binding.res();
+                    if let MacroRulesScope::Def(macro_rules_def) = macro_rules_scope.get() {
+                        let res = macro_rules_def.decl.res();
                         if filter_fn(res) {
-                            suggestions.push(TypoSuggestion::typo_from_ident(
-                                macro_rules_binding.ident,
-                                res,
-                            ))
+                            suggestions
+                                .push(TypoSuggestion::typo_from_ident(macro_rules_def.ident.0, res))
                         }
                     }
                 }
-                Scope::Module(module, _) => {
+                Scope::ModuleNonGlobs(module, _) => {
                     this.add_module_candidates(module, suggestions, filter_fn, None);
                 }
+                Scope::ModuleGlobs(..) => {
+                    // Already handled in `ModuleNonGlobs`.
+                }
                 Scope::MacroUsePrelude => {
                     suggestions.extend(this.macro_use_prelude.iter().filter_map(
                         |(name, binding)| {
@@ -1338,7 +1338,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
 
                 let child_accessible =
-                    accessible && this.is_accessible_from(name_binding.vis, parent_scope.module);
+                    accessible && this.is_accessible_from(name_binding.vis(), parent_scope.module);
 
                 // do not venture inside inaccessible items of other crates
                 if in_module_is_extern && !child_accessible {
@@ -1357,9 +1357,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
 
                 // #90113: Do not count an inaccessible reexported item as a candidate.
-                if let NameBindingKind::Import { binding, .. } = name_binding.kind
-                    && this.is_accessible_from(binding.vis, parent_scope.module)
-                    && !this.is_accessible_from(name_binding.vis, parent_scope.module)
+                if let DeclKind::Import { source_decl, .. } = name_binding.kind
+                    && this.is_accessible_from(source_decl.vis(), parent_scope.module)
+                    && !this.is_accessible_from(name_binding.vis(), parent_scope.module)
                 {
                     return;
                 }
@@ -1466,8 +1466,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     let mut path_segments = path_segments.clone();
                     path_segments.push(ast::PathSegment::from_ident(ident.0));
 
-                    let alias_import = if let NameBindingKind::Import { import, .. } =
-                        name_binding.kind
+                    let alias_import = if let DeclKind::Import { import, .. } = name_binding.kind
                         && let ImportKind::ExternCrate { source: Some(_), .. } = import.kind
                         && import.parent_scope.expansion == parent_scope.expansion
                     {
@@ -1580,9 +1579,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         |(key, name_resolution)| {
                             if key.ns == TypeNS
                                 && key.ident == ident
-                                && let Some(binding) = name_resolution.borrow().best_binding()
+                                && let Some(decl) = name_resolution.borrow().best_decl()
                             {
-                                match binding.res() {
+                                match decl.res() {
                                     // No disambiguation needed if the identically named item we
                                     // found in scope actually refers to the crate in question.
                                     Res::Def(_, def_id) => def_id != crate_def_id,
@@ -1751,7 +1750,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     macro_kind.descr_expected(),
                 ),
             };
-            if let crate::NameBindingKind::Import { import, .. } = binding.kind
+            if let crate::DeclKind::Import { import, .. } = binding.kind
                 && !import.span.is_dummy()
             {
                 let note = errors::IdentImporterHereButItIsDesc {
@@ -1968,7 +1967,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         true
     }
 
-    fn binding_description(&self, b: NameBinding<'_>, ident: Ident, scope: Scope<'_>) -> String {
+    fn decl_description(&self, b: Decl<'_>, ident: Ident, scope: Scope<'_>) -> String {
         let res = b.res();
         if b.span.is_dummy() || !self.tcx.sess.source_map().is_span_accessible(b.span) {
             let (built_in, from) = match scope {
@@ -2004,7 +2003,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 && self
                     .extern_prelude
                     .get(&Macros20NormalizedIdent::new(ident))
-                    .is_some_and(|entry| entry.item_binding.map(|(b, _)| b) == Some(b1))
+                    .is_some_and(|entry| entry.item_decl.map(|(b, _)| b) == Some(b1))
         };
         let (b1, b2, scope1, scope2, swapped) = if b2.span.is_dummy() && !b1.span.is_dummy() {
             // We have to print the span-less alternative first, otherwise formatting looks bad.
@@ -2013,8 +2012,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             (b1, b2, scope1, scope2, false)
         };
 
-        let could_refer_to = |b: NameBinding<'_>, scope: Scope<'ra>, also: &str| {
-            let what = self.binding_description(b, ident, scope);
+        let could_refer_to = |b: Decl<'_>, scope: Scope<'ra>, also: &str| {
+            let what = self.decl_description(b, ident, scope);
             let note_msg = format!("`{ident}` could{also} refer to {what}");
 
             let thing = b.res().descr();
@@ -2033,7 +2032,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 help_msgs.push(format!("use `::{ident}` to refer to this {thing} unambiguously"))
             }
 
-            if let Scope::Module(module, _) = scope {
+            if let Scope::ModuleNonGlobs(module, _) | Scope::ModuleGlobs(module, _) = scope {
                 if module == self.graph_root {
                     help_msgs.push(format!(
                         "use `crate::{ident}` to refer to this {thing} unambiguously"
@@ -2072,11 +2071,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     /// If the binding refers to a tuple struct constructor with fields,
     /// returns the span of its fields.
-    fn ctor_fields_span(&self, binding: NameBinding<'_>) -> Option<Span> {
-        let NameBindingKind::Res(Res::Def(
-            DefKind::Ctor(CtorOf::Struct, CtorKind::Fn),
-            ctor_def_id,
-        )) = binding.kind
+    fn ctor_fields_span(&self, decl: Decl<'_>) -> Option<Span> {
+        let DeclKind::Def(Res::Def(DefKind::Ctor(CtorOf::Struct, CtorKind::Fn), ctor_def_id)) =
+            decl.kind
         else {
             return None;
         };
@@ -2088,7 +2085,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn report_privacy_error(&mut self, privacy_error: &PrivacyError<'ra>) {
         let PrivacyError {
             ident,
-            binding,
+            decl,
             outermost_res,
             parent_scope,
             single_nested,
@@ -2096,17 +2093,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ref source,
         } = *privacy_error;
 
-        let res = binding.res();
-        let ctor_fields_span = self.ctor_fields_span(binding);
+        let res = decl.res();
+        let ctor_fields_span = self.ctor_fields_span(decl);
         let plain_descr = res.descr().to_string();
         let nonimport_descr =
             if ctor_fields_span.is_some() { plain_descr + " constructor" } else { plain_descr };
         let import_descr = nonimport_descr.clone() + " import";
-        let get_descr =
-            |b: NameBinding<'_>| if b.is_import() { &import_descr } else { &nonimport_descr };
+        let get_descr = |b: Decl<'_>| if b.is_import() { &import_descr } else { &nonimport_descr };
 
         // Print the primary message.
-        let ident_descr = get_descr(binding);
+        let ident_descr = get_descr(decl);
         let mut err =
             self.dcx().create_err(errors::IsPrivate { span: ident.span, ident_descr, ident });
 
@@ -2206,30 +2202,30 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         // Print the whole import chain to make it easier to see what happens.
-        let first_binding = binding;
-        let mut next_binding = Some(binding);
+        let first_binding = decl;
+        let mut next_binding = Some(decl);
         let mut next_ident = ident;
         let mut path = vec![];
         while let Some(binding) = next_binding {
             let name = next_ident;
             next_binding = match binding.kind {
                 _ if res == Res::Err => None,
-                NameBindingKind::Import { binding, import, .. } => match import.kind {
-                    _ if binding.span.is_dummy() => None,
+                DeclKind::Import { source_decl, import, .. } => match import.kind {
+                    _ if source_decl.span.is_dummy() => None,
                     ImportKind::Single { source, .. } => {
                         next_ident = source;
-                        Some(binding)
+                        Some(source_decl)
                     }
                     ImportKind::Glob { .. }
                     | ImportKind::MacroUse { .. }
-                    | ImportKind::MacroExport => Some(binding),
+                    | ImportKind::MacroExport => Some(source_decl),
                     ImportKind::ExternCrate { .. } => None,
                 },
                 _ => None,
             };
 
             match binding.kind {
-                NameBindingKind::Import { import, .. } => {
+                DeclKind::Import { import, .. } => {
                     for segment in import.module_path.iter().skip(1) {
                         // Don't include `{{root}}` in suggestions - it's an internal symbol
                         // that should never be shown to users.
@@ -2242,14 +2238,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         true, // re-export
                     ));
                 }
-                NameBindingKind::Res(_) => {}
+                DeclKind::Def(_) => {}
             }
             let first = binding == first_binding;
             let def_span = self.tcx.sess.source_map().guess_head_span(binding.span);
             let mut note_span = MultiSpan::from_span(def_span);
-            if !first && binding.vis.is_public() {
+            if !first && binding.vis().is_public() {
                 let desc = match binding.kind {
-                    NameBindingKind::Import { .. } => "re-export",
+                    DeclKind::Import { .. } => "re-export",
                     _ => "directly",
                 };
                 note_span.push_span_label(def_span, format!("you could import this {desc}"));
@@ -2415,7 +2411,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         opt_ns: Option<Namespace>, // `None` indicates a module path in import
         parent_scope: &ParentScope<'ra>,
         ribs: Option<&PerNS<Vec<Rib<'ra>>>>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
         module: Option<ModuleOrUniformRoot<'ra>>,
         failed_segment_idx: usize,
@@ -2511,7 +2507,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             ns_to_try,
                             parent_scope,
                             None,
-                            ignore_binding,
+                            ignore_decl,
                             ignore_import,
                         )
                         .ok()
@@ -2525,11 +2521,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         parent_scope,
                         None,
                         &ribs[ns_to_try],
-                        ignore_binding,
+                        ignore_decl,
                         diag_metadata,
                     ) {
                         // we found a locally-imported or available item/module
-                        Some(LexicalScopeBinding::Item(binding)) => Some(binding),
+                        Some(LateDecl::Decl(binding)) => Some(binding),
                         _ => None,
                     }
                 } else {
@@ -2540,7 +2536,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             parent_scope,
                             None,
                             false,
-                            ignore_binding,
+                            ignore_decl,
                             ignore_import,
                         )
                         .ok()
@@ -2576,7 +2572,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     parent_scope,
                     None,
                     &ribs[ValueNS],
-                    ignore_binding,
+                    ignore_decl,
                     diag_metadata,
                 )
             } else {
@@ -2591,7 +2587,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 //                               // variable `Foo`.
                 // }
                 // ```
-                Some(LexicalScopeBinding::Res(Res::Local(id))) => {
+                Some(LateDecl::RibDef(Res::Local(id))) => {
                     Some(*self.pat_span_map.get(&id).unwrap())
                 }
                 // Name matches item from a local name binding
@@ -2605,7 +2601,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 //                               // binding `Foo`.
                 // }
                 // ```
-                Some(LexicalScopeBinding::Item(name_binding)) => Some(name_binding.span),
+                Some(LateDecl::Decl(name_binding)) => Some(name_binding.span),
                 _ => None,
             };
             let suggestion = match_span.map(|span| {
@@ -2644,7 +2640,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 parent_scope,
                 None,
                 false,
-                ignore_binding,
+                ignore_decl,
                 ignore_import,
             ) {
                 let descr = binding.res().descr();
@@ -2896,7 +2892,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return None;
         }
 
-        let binding_key = BindingKey::new(ident, MacroNS);
+        let binding_key = BindingKey::new(Macros20NormalizedIdent::new(ident), MacroNS);
         let binding = self.resolution(crate_module, binding_key)?.binding()?;
         let Res::Def(DefKind::Macro(kinds), _) = binding.res() else {
             return None;
diff --git a/compiler/rustc_resolve/src/effective_visibilities.rs b/compiler/rustc_resolve/src/effective_visibilities.rs
index fe6e5b8e6eb6..ebdb0060e1b9 100644
--- a/compiler/rustc_resolve/src/effective_visibilities.rs
+++ b/compiler/rustc_resolve/src/effective_visibilities.rs
@@ -8,12 +8,12 @@ use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility,
 use rustc_middle::ty::Visibility;
 use tracing::info;
 
-use crate::{NameBinding, NameBindingKind, Resolver};
+use crate::{Decl, DeclKind, Resolver};
 
 #[derive(Clone, Copy)]
 enum ParentId<'ra> {
     Def(LocalDefId),
-    Import(NameBinding<'ra>),
+    Import(Decl<'ra>),
 }
 
 impl ParentId<'_> {
@@ -28,10 +28,10 @@ impl ParentId<'_> {
 pub(crate) struct EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
     r: &'a mut Resolver<'ra, 'tcx>,
     def_effective_visibilities: EffectiveVisibilities,
-    /// While walking import chains we need to track effective visibilities per-binding, and def id
+    /// While walking import chains we need to track effective visibilities per-decl, and def id
     /// keys in `Resolver::effective_visibilities` are not enough for that, because multiple
-    /// bindings can correspond to a single def id in imports. So we keep a separate table.
-    import_effective_visibilities: EffectiveVisibilities<NameBinding<'ra>>,
+    /// declarations can correspond to a single def id in imports. So we keep a separate table.
+    import_effective_visibilities: EffectiveVisibilities<Decl<'ra>>,
     // It's possible to recalculate this at any point, but it's relatively expensive.
     current_private_vis: Visibility,
     changed: bool,
@@ -42,8 +42,8 @@ impl Resolver<'_, '_> {
         self.get_nearest_non_block_module(def_id.to_def_id()).nearest_parent_mod().expect_local()
     }
 
-    fn private_vis_import(&self, binding: NameBinding<'_>) -> Visibility {
-        let NameBindingKind::Import { import, .. } = binding.kind else { unreachable!() };
+    fn private_vis_import(&self, decl: Decl<'_>) -> Visibility {
+        let DeclKind::Import { import, .. } = decl.kind else { unreachable!() };
         Visibility::Restricted(
             import
                 .id()
@@ -70,7 +70,7 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
     pub(crate) fn compute_effective_visibilities<'c>(
         r: &'a mut Resolver<'ra, 'tcx>,
         krate: &'c Crate,
-    ) -> FxHashSet<NameBinding<'ra>> {
+    ) -> FxHashSet<Decl<'ra>> {
         let mut visitor = EffectiveVisibilitiesVisitor {
             r,
             def_effective_visibilities: Default::default(),
@@ -91,17 +91,19 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
         let mut exported_ambiguities = FxHashSet::default();
 
         // Update visibilities for import def ids. These are not used during the
-        // `EffectiveVisibilitiesVisitor` pass, because we have more detailed binding-based
+        // `EffectiveVisibilitiesVisitor` pass, because we have more detailed declaration-based
         // information, but are used by later passes. Effective visibility of an import def id
-        // is the maximum value among visibilities of bindings corresponding to that def id.
-        for (binding, eff_vis) in visitor.import_effective_visibilities.iter() {
-            let NameBindingKind::Import { import, .. } = binding.kind else { unreachable!() };
-            if !binding.is_ambiguity_recursive() {
+        // is the maximum value among visibilities of declarations corresponding to that def id.
+        for (decl, eff_vis) in visitor.import_effective_visibilities.iter() {
+            let DeclKind::Import { import, .. } = decl.kind else { unreachable!() };
+            if !decl.is_ambiguity_recursive() {
                 if let Some(node_id) = import.id() {
                     r.effective_visibilities.update_eff_vis(r.local_def_id(node_id), eff_vis, r.tcx)
                 }
-            } else if binding.ambiguity.is_some() && eff_vis.is_public_at_level(Level::Reexported) {
-                exported_ambiguities.insert(*binding);
+            } else if decl.ambiguity.get().is_some()
+                && eff_vis.is_public_at_level(Level::Reexported)
+            {
+                exported_ambiguities.insert(*decl);
             }
         }
 
@@ -110,12 +112,12 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
         exported_ambiguities
     }
 
-    /// Update effective visibilities of bindings in the given module,
+    /// Update effective visibilities of name declarations in the given module,
     /// including their whole reexport chains.
     fn set_bindings_effective_visibilities(&mut self, module_id: LocalDefId) {
         let module = self.r.expect_module(module_id.to_def_id());
         for (_, name_resolution) in self.r.resolutions(module).borrow().iter() {
-            let Some(mut binding) = name_resolution.borrow().binding() else {
+            let Some(mut decl) = name_resolution.borrow().binding() else {
                 continue;
             };
             // Set the given effective visibility level to `Level::Direct` and
@@ -126,27 +128,27 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
             // leading to it into the table. They are used by the `ambiguous_glob_reexports`
             // lint. For all bindings added to the table this way `is_ambiguity` returns true.
             let is_ambiguity =
-                |binding: NameBinding<'ra>, warn: bool| binding.ambiguity.is_some() && !warn;
+                |decl: Decl<'ra>, warn: bool| decl.ambiguity.get().is_some() && !warn;
             let mut parent_id = ParentId::Def(module_id);
-            let mut warn_ambiguity = binding.warn_ambiguity;
-            while let NameBindingKind::Import { binding: nested_binding, .. } = binding.kind {
-                self.update_import(binding, parent_id);
+            let mut warn_ambiguity = decl.warn_ambiguity.get();
+            while let DeclKind::Import { source_decl, .. } = decl.kind {
+                self.update_import(decl, parent_id);
 
-                if is_ambiguity(binding, warn_ambiguity) {
+                if is_ambiguity(decl, warn_ambiguity) {
                     // Stop at the root ambiguity, further bindings in the chain should not
                     // be reexported because the root ambiguity blocks any access to them.
                     // (Those further bindings are most likely not ambiguities themselves.)
                     break;
                 }
 
-                parent_id = ParentId::Import(binding);
-                binding = nested_binding;
-                warn_ambiguity |= nested_binding.warn_ambiguity;
+                parent_id = ParentId::Import(decl);
+                decl = source_decl;
+                warn_ambiguity |= source_decl.warn_ambiguity.get();
             }
-            if !is_ambiguity(binding, warn_ambiguity)
-                && let Some(def_id) = binding.res().opt_def_id().and_then(|id| id.as_local())
+            if !is_ambiguity(decl, warn_ambiguity)
+                && let Some(def_id) = decl.res().opt_def_id().and_then(|id| id.as_local())
             {
-                self.update_def(def_id, binding.vis.expect_local(), parent_id);
+                self.update_def(def_id, decl.vis().expect_local(), parent_id);
             }
         }
     }
@@ -188,15 +190,15 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
         }
     }
 
-    fn update_import(&mut self, binding: NameBinding<'ra>, parent_id: ParentId<'ra>) {
-        let nominal_vis = binding.vis.expect_local();
+    fn update_import(&mut self, decl: Decl<'ra>, parent_id: ParentId<'ra>) {
+        let nominal_vis = decl.vis().expect_local();
         let Some(cheap_private_vis) = self.may_update(nominal_vis, parent_id) else { return };
         let inherited_eff_vis = self.effective_vis_or_private(parent_id);
         let tcx = self.r.tcx;
         self.changed |= self.import_effective_visibilities.update(
-            binding,
+            decl,
             Some(nominal_vis),
-            || cheap_private_vis.unwrap_or_else(|| self.r.private_vis_import(binding)),
+            || cheap_private_vis.unwrap_or_else(|| self.r.private_vis_import(decl)),
             inherited_eff_vis,
             parent_id.level(),
             tcx,
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 669f045681b7..91fe6741950b 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -9,7 +9,8 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::parse::feature_err;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
-use rustc_span::{Ident, Span, kw, sym};
+use rustc_span::{Ident, Macros20NormalizedIdent, Span, kw, sym};
+use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
 use crate::errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
@@ -19,10 +20,9 @@ use crate::late::{
 };
 use crate::macros::{MacroRulesScope, sub_namespace_match};
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingKey, CmResolver, Determinacy, Finalize, ImportKind,
-    LexicalScopeBinding, Module, ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind,
-    ParentScope, PathResult, PrivacyError, Res, ResolutionError, Resolver, Scope, ScopeSet,
-    Segment, Stage, Used, errors,
+    AmbiguityError, AmbiguityKind, BindingKey, CmResolver, Decl, DeclKind, Determinacy, Finalize,
+    ImportKind, LateDecl, Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult,
+    PrivacyError, Res, ResolutionError, Resolver, Scope, ScopeSet, Segment, Stage, Used, errors,
 };
 
 #[derive(Copy, Clone)]
@@ -51,7 +51,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         mut self: CmResolver<'r, 'ra, 'tcx>,
         scope_set: ScopeSet<'ra>,
         parent_scope: &ParentScope<'ra>,
-        ctxt: SyntaxContext,
+        orig_ctxt: SyntaxContext,
         derive_fallback_lint_id: Option<NodeId>,
         mut visitor: impl FnMut(
             &mut CmResolver<'r, 'ra, 'tcx>,
@@ -101,27 +101,29 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // 4c. Standard library prelude (de-facto closed, controlled).
         // 6. Language prelude: builtin attributes (closed, controlled).
 
-        let rust_2015 = ctxt.edition().is_rust_2015();
         let (ns, macro_kind) = match scope_set {
-            ScopeSet::All(ns) | ScopeSet::ModuleAndExternPrelude(ns, _) => (ns, None),
+            ScopeSet::All(ns)
+            | ScopeSet::Module(ns, _)
+            | ScopeSet::ModuleAndExternPrelude(ns, _) => (ns, None),
             ScopeSet::ExternPrelude => (TypeNS, None),
             ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind)),
         };
         let module = match scope_set {
             // Start with the specified module.
-            ScopeSet::ModuleAndExternPrelude(_, module) => module,
+            ScopeSet::Module(_, module) | ScopeSet::ModuleAndExternPrelude(_, module) => module,
             // Jump out of trait or enum modules, they do not act as scopes.
             _ => parent_scope.module.nearest_item_scope(),
         };
+        let module_only = matches!(scope_set, ScopeSet::Module(..));
         let module_and_extern_prelude = matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..));
         let extern_prelude = matches!(scope_set, ScopeSet::ExternPrelude);
         let mut scope = match ns {
-            _ if module_and_extern_prelude => Scope::Module(module, None),
+            _ if module_only || module_and_extern_prelude => Scope::ModuleNonGlobs(module, None),
             _ if extern_prelude => Scope::ExternPreludeItems,
-            TypeNS | ValueNS => Scope::Module(module, None),
+            TypeNS | ValueNS => Scope::ModuleNonGlobs(module, None),
             MacroNS => Scope::DeriveHelpers(parent_scope.expansion),
         };
-        let mut ctxt = ctxt.normalize_to_macros_2_0();
+        let mut ctxt = orig_ctxt.normalize_to_macros_2_0();
         let mut use_prelude = !module.no_implicit_prelude;
 
         loop {
@@ -145,8 +147,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                     true
                 }
-                Scope::Module(..) => true,
-                Scope::MacroUsePrelude => use_prelude || rust_2015,
+                Scope::ModuleNonGlobs(..) | Scope::ModuleGlobs(..) => true,
+                Scope::MacroUsePrelude => use_prelude || orig_ctxt.edition().is_rust_2015(),
                 Scope::BuiltinAttrs => true,
                 Scope::ExternPreludeItems | Scope::ExternPreludeFlags => {
                     use_prelude || module_and_extern_prelude || extern_prelude
@@ -180,26 +182,28 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
                 Scope::DeriveHelpersCompat => Scope::MacroRules(parent_scope.macro_rules),
                 Scope::MacroRules(macro_rules_scope) => match macro_rules_scope.get() {
-                    MacroRulesScope::Binding(binding) => {
+                    MacroRulesScope::Def(binding) => {
                         Scope::MacroRules(binding.parent_macro_rules_scope)
                     }
                     MacroRulesScope::Invocation(invoc_id) => {
                         Scope::MacroRules(self.invocation_parent_scopes[&invoc_id].macro_rules)
                     }
-                    MacroRulesScope::Empty => Scope::Module(module, None),
+                    MacroRulesScope::Empty => Scope::ModuleNonGlobs(module, None),
                 },
-                Scope::Module(..) if module_and_extern_prelude => match ns {
+                Scope::ModuleNonGlobs(module, lint_id) => Scope::ModuleGlobs(module, lint_id),
+                Scope::ModuleGlobs(..) if module_only => break,
+                Scope::ModuleGlobs(..) if module_and_extern_prelude => match ns {
                     TypeNS => {
                         ctxt.adjust(ExpnId::root());
                         Scope::ExternPreludeItems
                     }
                     ValueNS | MacroNS => break,
                 },
-                Scope::Module(module, prev_lint_id) => {
+                Scope::ModuleGlobs(module, prev_lint_id) => {
                     use_prelude = !module.no_implicit_prelude;
                     match self.hygienic_lexical_parent(module, &mut ctxt, derive_fallback_lint_id) {
                         Some((parent_module, lint_id)) => {
-                            Scope::Module(parent_module, lint_id.or(prev_lint_id))
+                            Scope::ModuleNonGlobs(parent_module, lint_id.or(prev_lint_id))
                         }
                         None => {
                             ctxt.adjust(ExpnId::root());
@@ -300,9 +304,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
         ribs: &[Rib<'ra>],
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         diag_metadata: Option<&DiagMetadata<'_>>,
-    ) -> Option<LexicalScopeBinding<'ra>> {
+    ) -> Option<LateDecl<'ra>> {
         let orig_ident = ident;
         let (general_span, normalized_span) = if ident.name == kw::SelfUpper {
             // FIXME(jseyfried) improve `Self` hygiene
@@ -325,7 +329,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let rib_ident = if rib.kind.contains_params() { normalized_ident } else { ident };
             if let Some((original_rib_ident_def, res)) = rib.bindings.get_key_value(&rib_ident) {
                 // The ident resolves to a type parameter or local variable.
-                return Some(LexicalScopeBinding::Res(self.validate_res_from_ribs(
+                return Some(LateDecl::RibDef(self.validate_res_from_ribs(
                     i,
                     rib_ident,
                     *res,
@@ -335,19 +339,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     diag_metadata,
                 )));
             } else if let RibKind::Block(Some(module)) = rib.kind
-                && let Ok(binding) = self.cm().resolve_ident_in_module_unadjusted(
-                    module,
+                && let Ok(binding) = self.cm().resolve_ident_in_scope_set(
                     ident,
-                    ns,
+                    ScopeSet::Module(ns, module),
                     parent_scope,
-                    Shadowing::Unrestricted,
                     finalize.map(|finalize| Finalize { used: Used::Scope, ..finalize }),
-                    ignore_binding,
+                    finalize.is_some(),
+                    ignore_decl,
                     None,
                 )
             {
                 // The ident resolves to an item in a block.
-                return Some(LexicalScopeBinding::Item(binding));
+                return Some(LateDecl::Decl(binding));
             } else if let RibKind::Module(module) = rib.kind {
                 // Encountered a module item, abandon ribs and look into that module and preludes.
                 let parent_scope = &ParentScope { module, ..*parent_scope };
@@ -360,11 +363,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         parent_scope,
                         finalize,
                         finalize.is_some(),
-                        ignore_binding,
+                        ignore_decl,
                         None,
                     )
                     .ok()
-                    .map(LexicalScopeBinding::Item);
+                    .map(LateDecl::Decl);
             }
 
             if let RibKind::MacroDefinition(def) = rib.kind
@@ -388,18 +391,20 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
         force: bool,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, Determinacy> {
+    ) -> Result<Decl<'ra>, Determinacy> {
         assert!(force || finalize.is_none()); // `finalize` implies `force`
 
         // Make sure `self`, `super` etc produce an error when passed to here.
-        if orig_ident.is_path_segment_keyword() {
+        if !matches!(scope_set, ScopeSet::Module(..)) && orig_ident.is_path_segment_keyword() {
             return Err(Determinacy::Determined);
         }
 
         let (ns, macro_kind) = match scope_set {
-            ScopeSet::All(ns) | ScopeSet::ModuleAndExternPrelude(ns, _) => (ns, None),
+            ScopeSet::All(ns)
+            | ScopeSet::Module(ns, _)
+            | ScopeSet::ModuleAndExternPrelude(ns, _) => (ns, None),
             ScopeSet::ExternPrelude => (TypeNS, None),
             ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind)),
         };
@@ -419,7 +424,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // }
         // So we have to save the innermost solution and continue searching in outer scopes
         // to detect potential ambiguities.
-        let mut innermost_results: Vec<(NameBinding<'_>, Scope<'_>)> = Vec::new();
+        let mut innermost_results: SmallVec<[(Decl<'_>, Scope<'_>); 2]> = SmallVec::new();
         let mut determinacy = Determinacy::Determined;
 
         // Go through all the scopes and try to resolve the name.
@@ -429,47 +434,59 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             orig_ident.span.ctxt(),
             derive_fallback_lint_id,
             |this, scope, use_prelude, ctxt| {
-                // We can break with an error at this step, it means we cannot determine the
-                // resolution right now, but we must block and wait until we can instead of
-                // considering outer scopes.
-                match this.reborrow().resolve_ident_in_scope(
-                    orig_ident,
+                let ident = Ident::new(orig_ident.name, orig_ident.span.with_ctxt(ctxt));
+                // The passed `ctxt` is already normalized, so avoid expensive double normalization.
+                let ident = Macros20NormalizedIdent(ident);
+                let res = match this.reborrow().resolve_ident_in_scope(
+                    ident,
                     ns,
                     scope,
                     use_prelude,
-                    ctxt,
                     scope_set,
                     parent_scope,
-                    // Shadowed bindings don't need to be marked as used or non-speculatively loaded.
+                    // Shadowed decls don't need to be marked as used or non-speculatively loaded.
                     if innermost_results.is_empty() { finalize } else { None },
                     force,
-                    ignore_binding,
+                    ignore_decl,
                     ignore_import,
-                )? {
-                    Ok(binding) if sub_namespace_match(binding.macro_kinds(), macro_kind) => {
+                ) {
+                    Ok(decl) => Ok(decl),
+                    // We can break with an error at this step, it means we cannot determine the
+                    // resolution right now, but we must block and wait until we can, instead of
+                    // considering outer scopes. Although there's no need to do that if we already
+                    // have a better solution.
+                    Err(ControlFlow::Break(determinacy)) if innermost_results.is_empty() => {
+                        return ControlFlow::Break(Err(determinacy));
+                    }
+                    Err(determinacy) => Err(determinacy.into_value()),
+                };
+                match res {
+                    Ok(decl) if sub_namespace_match(decl.macro_kinds(), macro_kind) => {
                         // Below we report various ambiguity errors.
                         // We do not need to report them if we are either in speculative resolution,
                         // or in late resolution when everything is already imported and expanded
                         // and no ambiguities exist.
                         if matches!(finalize, None | Some(Finalize { stage: Stage::Late, .. })) {
-                            return ControlFlow::Break(Ok(binding));
+                            return ControlFlow::Break(Ok(decl));
                         }
 
-                        if let Some(&(innermost_binding, _)) = innermost_results.first() {
+                        if let Some(&(innermost_decl, _)) = innermost_results.first() {
                             // Found another solution, if the first one was "weak", report an error.
                             if this.get_mut().maybe_push_ambiguity(
                                 orig_ident,
+                                ns,
+                                scope_set,
                                 parent_scope,
-                                binding,
+                                decl,
                                 scope,
                                 &innermost_results,
                             ) {
                                 // No need to search for more potential ambiguities, one is enough.
-                                return ControlFlow::Break(Ok(innermost_binding));
+                                return ControlFlow::Break(Ok(innermost_decl));
                             }
                         }
 
-                        innermost_results.push((binding, scope));
+                        innermost_results.push((decl, scope));
                     }
                     Ok(_) | Err(Determinacy::Determined) => {}
                     Err(Determinacy::Undetermined) => determinacy = Determinacy::Undetermined,
@@ -486,33 +503,32 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         // Scope visiting walked all the scopes and maybe found something in one of them.
         match innermost_results.first() {
-            Some(&(binding, ..)) => Ok(binding),
+            Some(&(decl, ..)) => Ok(decl),
             None => Err(Determinacy::determined(determinacy == Determinacy::Determined || force)),
         }
     }
 
     fn resolve_ident_in_scope<'r>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
-        orig_ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
         scope: Scope<'ra>,
         use_prelude: UsePrelude,
-        ctxt: SyntaxContext,
         scope_set: ScopeSet<'ra>,
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
         force: bool,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> ControlFlow<Result<NameBinding<'ra>, Determinacy>, Result<NameBinding<'ra>, Determinacy>>
-    {
-        let ident = Ident::new(orig_ident.name, orig_ident.span.with_ctxt(ctxt));
+    ) -> Result<Decl<'ra>, ControlFlow<Determinacy, Determinacy>> {
         let ret = match scope {
             Scope::DeriveHelpers(expn_id) => {
-                if let Some(binding) = self.helper_attrs.get(&expn_id).and_then(|attrs| {
-                    attrs.iter().rfind(|(i, _)| ident == *i).map(|(_, binding)| *binding)
-                }) {
-                    Ok(binding)
+                if let Some(decl) = self
+                    .helper_attrs
+                    .get(&expn_id)
+                    .and_then(|attrs| attrs.iter().rfind(|(i, _)| ident == *i).map(|(_, d)| *d))
+                {
+                    Ok(decl)
                 } else {
                     Err(Determinacy::Determined)
                 }
@@ -529,12 +545,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     ) {
                         Ok((Some(ext), _)) => {
                             if ext.helper_attrs.contains(&ident.name) {
-                                let binding = self.arenas.new_pub_res_binding(
+                                let decl = self.arenas.new_pub_def_decl(
                                     Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat),
                                     derive.span,
                                     LocalExpnId::ROOT,
                                 );
-                                result = Ok(binding);
+                                result = Ok(decl);
                                 break;
                             }
                         }
@@ -545,32 +561,86 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 result
             }
             Scope::MacroRules(macro_rules_scope) => match macro_rules_scope.get() {
-                MacroRulesScope::Binding(macro_rules_binding)
-                    if ident == macro_rules_binding.ident =>
-                {
-                    Ok(macro_rules_binding.binding)
+                MacroRulesScope::Def(macro_rules_def) if ident == macro_rules_def.ident => {
+                    Ok(macro_rules_def.decl)
                 }
                 MacroRulesScope::Invocation(_) => Err(Determinacy::Undetermined),
                 _ => Err(Determinacy::Determined),
             },
-            Scope::Module(module, derive_fallback_lint_id) => {
-                let (adjusted_parent_scope, adjusted_finalize) =
-                    if matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..)) {
-                        (parent_scope, finalize)
-                    } else {
-                        (
-                            &ParentScope { module, ..*parent_scope },
-                            finalize.map(|f| Finalize { used: Used::Scope, ..f }),
-                        )
-                    };
-                let binding = self.reborrow().resolve_ident_in_module_unadjusted(
+            Scope::ModuleNonGlobs(module, derive_fallback_lint_id) => {
+                let (adjusted_parent_scope, adjusted_finalize) = if matches!(
+                    scope_set,
+                    ScopeSet::Module(..) | ScopeSet::ModuleAndExternPrelude(..)
+                ) {
+                    (parent_scope, finalize)
+                } else {
+                    (
+                        &ParentScope { module, ..*parent_scope },
+                        finalize.map(|f| Finalize { used: Used::Scope, ..f }),
+                    )
+                };
+                let decl = self.reborrow().resolve_ident_in_module_non_globs_unadjusted(
                     module,
                     ident,
                     ns,
                     adjusted_parent_scope,
-                    Shadowing::Restricted,
+                    if matches!(scope_set, ScopeSet::Module(..)) {
+                        Shadowing::Unrestricted
+                    } else {
+                        Shadowing::Restricted
+                    },
                     adjusted_finalize,
-                    ignore_binding,
+                    ignore_decl,
+                    ignore_import,
+                );
+                match decl {
+                    Ok(decl) => {
+                        if let Some(lint_id) = derive_fallback_lint_id {
+                            self.get_mut().lint_buffer.buffer_lint(
+                                PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
+                                lint_id,
+                                ident.span,
+                                errors::ProcMacroDeriveResolutionFallback {
+                                    span: ident.span,
+                                    ns_descr: ns.descr(),
+                                    ident: ident.0,
+                                },
+                            );
+                        }
+                        Ok(decl)
+                    }
+                    Err(ControlFlow::Continue(determinacy)) => Err(determinacy),
+                    Err(ControlFlow::Break(determinacy)) => {
+                        return Err(ControlFlow::Break(Determinacy::determined(
+                            determinacy == Determinacy::Determined || force,
+                        )));
+                    }
+                }
+            }
+            Scope::ModuleGlobs(module, derive_fallback_lint_id) => {
+                let (adjusted_parent_scope, adjusted_finalize) = if matches!(
+                    scope_set,
+                    ScopeSet::Module(..) | ScopeSet::ModuleAndExternPrelude(..)
+                ) {
+                    (parent_scope, finalize)
+                } else {
+                    (
+                        &ParentScope { module, ..*parent_scope },
+                        finalize.map(|f| Finalize { used: Used::Scope, ..f }),
+                    )
+                };
+                let binding = self.reborrow().resolve_ident_in_module_globs_unadjusted(
+                    module,
+                    ident,
+                    ns,
+                    adjusted_parent_scope,
+                    if matches!(scope_set, ScopeSet::Module(..)) {
+                        Shadowing::Unrestricted
+                    } else {
+                        Shadowing::Restricted
+                    },
+                    adjusted_finalize,
+                    ignore_decl,
                     ignore_import,
                 );
                 match binding {
@@ -579,37 +649,37 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             self.get_mut().lint_buffer.buffer_lint(
                                 PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
                                 lint_id,
-                                orig_ident.span,
+                                ident.span,
                                 errors::ProcMacroDeriveResolutionFallback {
-                                    span: orig_ident.span,
+                                    span: ident.span,
                                     ns_descr: ns.descr(),
-                                    ident,
+                                    ident: ident.0,
                                 },
                             );
                         }
                         Ok(binding)
                     }
                     Err(ControlFlow::Continue(determinacy)) => Err(determinacy),
-                    Err(ControlFlow::Break(Determinacy::Undetermined)) => {
-                        return ControlFlow::Break(Err(Determinacy::determined(force)));
+                    Err(ControlFlow::Break(determinacy)) => {
+                        return Err(ControlFlow::Break(Determinacy::determined(
+                            determinacy == Determinacy::Determined || force,
+                        )));
                     }
-                    // Privacy errors, do not happen during in scope resolution.
-                    Err(ControlFlow::Break(Determinacy::Determined)) => unreachable!(),
                 }
             }
             Scope::MacroUsePrelude => match self.macro_use_prelude.get(&ident.name).cloned() {
-                Some(binding) => Ok(binding),
+                Some(decl) => Ok(decl),
                 None => Err(Determinacy::determined(
                     self.graph_root.unexpanded_invocations.borrow().is_empty(),
                 )),
             },
-            Scope::BuiltinAttrs => match self.builtin_attrs_bindings.get(&ident.name) {
-                Some(binding) => Ok(*binding),
+            Scope::BuiltinAttrs => match self.builtin_attr_decls.get(&ident.name) {
+                Some(decl) => Ok(*decl),
                 None => Err(Determinacy::Determined),
             },
             Scope::ExternPreludeItems => {
                 match self.reborrow().extern_prelude_get_item(ident, finalize.is_some()) {
-                    Some(binding) => Ok(binding),
+                    Some(decl) => Ok(decl),
                     None => Err(Determinacy::determined(
                         self.graph_root.unexpanded_invocations.borrow().is_empty(),
                     )),
@@ -617,37 +687,35 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
             Scope::ExternPreludeFlags => {
                 match self.extern_prelude_get_flag(ident, finalize.is_some()) {
-                    Some(binding) => Ok(binding),
+                    Some(decl) => Ok(decl),
                     None => Err(Determinacy::Determined),
                 }
             }
-            Scope::ToolPrelude => match self.registered_tool_bindings.get(&ident) {
-                Some(binding) => Ok(*binding),
+            Scope::ToolPrelude => match self.registered_tool_decls.get(&ident) {
+                Some(decl) => Ok(*decl),
                 None => Err(Determinacy::Determined),
             },
             Scope::StdLibPrelude => {
                 let mut result = Err(Determinacy::Determined);
                 if let Some(prelude) = self.prelude
-                    && let Ok(binding) = self.reborrow().resolve_ident_in_module_unadjusted(
-                        prelude,
-                        ident,
-                        ns,
+                    && let Ok(decl) = self.reborrow().resolve_ident_in_scope_set(
+                        ident.0,
+                        ScopeSet::Module(ns, prelude),
                         parent_scope,
-                        Shadowing::Unrestricted,
                         None,
-                        ignore_binding,
+                        false,
+                        ignore_decl,
                         ignore_import,
                     )
-                    && (matches!(use_prelude, UsePrelude::Yes)
-                        || self.is_builtin_macro(binding.res()))
+                    && (matches!(use_prelude, UsePrelude::Yes) || self.is_builtin_macro(decl.res()))
                 {
-                    result = Ok(binding)
+                    result = Ok(decl)
                 }
 
                 result
             }
-            Scope::BuiltinTypes => match self.builtin_types_bindings.get(&ident.name) {
-                Some(binding) => {
+            Scope::BuiltinTypes => match self.builtin_type_decls.get(&ident.name) {
+                Some(decl) => {
                     if matches!(ident.name, sym::f16)
                         && !self.tcx.features().f16()
                         && !ident.span.allows_unstable(sym::f16)
@@ -674,31 +742,34 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         )
                         .emit();
                     }
-                    Ok(*binding)
+                    Ok(*decl)
                 }
                 None => Err(Determinacy::Determined),
             },
         };
 
-        ControlFlow::Continue(ret)
+        ret.map_err(ControlFlow::Continue)
     }
 
     fn maybe_push_ambiguity(
         &mut self,
         orig_ident: Ident,
+        ns: Namespace,
+        scope_set: ScopeSet<'ra>,
         parent_scope: &ParentScope<'ra>,
-        binding: NameBinding<'ra>,
+        decl: Decl<'ra>,
         scope: Scope<'ra>,
-        innermost_results: &[(NameBinding<'ra>, Scope<'ra>)],
+        innermost_results: &[(Decl<'ra>, Scope<'ra>)],
     ) -> bool {
-        let (innermost_binding, innermost_scope) = *innermost_results.first().unwrap();
-        let (res, innermost_res) = (binding.res(), innermost_binding.res());
+        let (innermost_decl, innermost_scope) = innermost_results[0];
+        let (res, innermost_res) = (decl.res(), innermost_decl.res());
         if res == innermost_res {
             return false;
         }
 
         // FIXME: Use `scope` instead of `res` to detect built-in attrs and derive helpers,
         // it will exclude imports, make slightly more code legal, and will require lang approval.
+        let module_only = matches!(scope_set, ScopeSet::Module(..));
         let is_builtin = |res| matches!(res, Res::NonMacroAttr(NonMacroAttrKind::Builtin(..)));
         let derive_helper = Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper);
         let derive_helper_compat = Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat);
@@ -710,12 +781,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         } else if res == derive_helper_compat && innermost_res != derive_helper {
             span_bug!(orig_ident.span, "impossible inner resolution kind")
         } else if matches!(innermost_scope, Scope::MacroRules(_))
-            && matches!(scope, Scope::Module(..))
-            && !self.disambiguate_macro_rules_vs_modularized(innermost_binding, binding)
+            && matches!(scope, Scope::ModuleNonGlobs(..) | Scope::ModuleGlobs(..))
+            && !self.disambiguate_macro_rules_vs_modularized(innermost_decl, decl)
         {
             Some(AmbiguityKind::MacroRulesVsModularized)
         } else if matches!(scope, Scope::MacroRules(_))
-            && matches!(innermost_scope, Scope::Module(..))
+            && matches!(innermost_scope, Scope::ModuleNonGlobs(..) | Scope::ModuleGlobs(..))
         {
             // should be impossible because of visitation order in
             // visit_scopes
@@ -727,30 +798,54 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 "ambiguous scoped macro resolutions with path-based \
                                         scope resolution as first candidate"
             )
-        } else if innermost_binding.is_glob_import() {
+        } else if innermost_decl.is_glob_import() {
             Some(AmbiguityKind::GlobVsOuter)
-        } else if innermost_binding.may_appear_after(parent_scope.expansion, binding) {
+        } else if !module_only && innermost_decl.may_appear_after(parent_scope.expansion, decl) {
             Some(AmbiguityKind::MoreExpandedVsOuter)
+        } else if innermost_decl.expansion != LocalExpnId::ROOT
+            && (!module_only || ns == MacroNS)
+            && let Scope::ModuleGlobs(m1, _) = scope
+            && let Scope::ModuleNonGlobs(m2, _) = innermost_scope
+            && m1 == m2
+        {
+            // FIXME: this error is too conservative and technically unnecessary now when module
+            // scope is split into two scopes, at least when not resolving in `ScopeSet::Module`,
+            // remove it with lang team approval.
+            Some(AmbiguityKind::GlobVsExpanded)
         } else {
             None
         };
+
         if let Some(kind) = ambiguity_error_kind {
             // Skip ambiguity errors for extern flag bindings "overridden"
             // by extern item bindings.
             // FIXME: Remove with lang team approval.
             let issue_145575_hack = matches!(scope, Scope::ExternPreludeFlags)
-                && innermost_results[1..].iter().any(|(b, s)| {
-                    matches!(s, Scope::ExternPreludeItems) && *b != innermost_binding
-                });
+                && innermost_results[1..]
+                    .iter()
+                    .any(|(b, s)| matches!(s, Scope::ExternPreludeItems) && *b != innermost_decl);
+            // Skip ambiguity errors for nonglob module bindings "overridden"
+            // by glob module bindings in the same module.
+            // FIXME: Remove with lang team approval.
+            let issue_149681_hack = match scope {
+                Scope::ModuleGlobs(m1, _)
+                    if innermost_results[1..]
+                        .iter()
+                        .any(|(_, s)| matches!(*s, Scope::ModuleNonGlobs(m2, _) if m1 == m2)) =>
+                {
+                    true
+                }
+                _ => false,
+            };
 
-            if issue_145575_hack {
+            if issue_145575_hack || issue_149681_hack {
                 self.issue_145575_hack_applied = true;
             } else {
                 self.ambiguity_errors.push(AmbiguityError {
                     kind,
                     ident: orig_ident,
-                    b1: innermost_binding,
-                    b2: binding,
+                    b1: innermost_decl,
+                    b2: decl,
                     scope1: innermost_scope,
                     scope2: scope,
                     warning: false,
@@ -770,7 +865,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ns: Namespace,
         parent_scope: &ParentScope<'ra>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, Determinacy> {
+    ) -> Result<Decl<'ra>, Determinacy> {
         self.resolve_ident_in_module(module, ident, ns, parent_scope, None, None, ignore_import)
     }
 
@@ -782,9 +877,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ns: Namespace,
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, Determinacy> {
+    ) -> Result<Decl<'ra>, Determinacy> {
         let tmp_parent_scope;
         let mut adjusted_parent_scope = parent_scope;
         match module {
@@ -808,7 +903,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ns,
             adjusted_parent_scope,
             finalize,
-            ignore_binding,
+            ignore_decl,
             ignore_import,
         )
     }
@@ -822,29 +917,26 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ns: Namespace,
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, Determinacy> {
+    ) -> Result<Decl<'ra>, Determinacy> {
         match module {
-            ModuleOrUniformRoot::Module(module) => self
-                .resolve_ident_in_module_unadjusted(
-                    module,
-                    ident,
-                    ns,
-                    parent_scope,
-                    Shadowing::Unrestricted,
-                    finalize,
-                    ignore_binding,
-                    ignore_import,
-                )
-                .map_err(|determinacy| determinacy.into_value()),
+            ModuleOrUniformRoot::Module(module) => self.resolve_ident_in_scope_set(
+                ident,
+                ScopeSet::Module(ns, module),
+                parent_scope,
+                finalize,
+                finalize.is_some(),
+                ignore_decl,
+                ignore_import,
+            ),
             ModuleOrUniformRoot::ModuleAndExternPrelude(module) => self.resolve_ident_in_scope_set(
                 ident,
                 ScopeSet::ModuleAndExternPrelude(ns, module),
                 parent_scope,
                 finalize,
                 finalize.is_some(),
-                ignore_binding,
+                ignore_decl,
                 ignore_import,
             ),
             ModuleOrUniformRoot::ExternPrelude => {
@@ -857,7 +949,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         parent_scope,
                         finalize,
                         finalize.is_some(),
-                        ignore_binding,
+                        ignore_decl,
                         ignore_import,
                     )
                 }
@@ -866,7 +958,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 if ns == TypeNS {
                     if ident.name == kw::Crate || ident.name == kw::DollarCrate {
                         let module = self.resolve_crate_root(ident);
-                        return Ok(module.self_binding.unwrap());
+                        return Ok(module.self_decl.unwrap());
                     } else if ident.name == kw::Super || ident.name == kw::SelfLower {
                         // FIXME: Implement these with renaming requirements so that e.g.
                         // `use super;` doesn't work, but `use super as name;` does.
@@ -880,67 +972,27 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     parent_scope,
                     finalize,
                     finalize.is_some(),
-                    ignore_binding,
+                    ignore_decl,
                     ignore_import,
                 )
             }
         }
     }
 
-    /// Attempts to resolve `ident` in namespace `ns` of `module`.
-    fn resolve_ident_in_module_unadjusted<'r>(
+    /// Attempts to resolve `ident` in namespace `ns` of non-glob bindings in `module`.
+    fn resolve_ident_in_module_non_globs_unadjusted<'r>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
         module: Module<'ra>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
         parent_scope: &ParentScope<'ra>,
         shadowing: Shadowing,
         finalize: Option<Finalize>,
         // This binding should be ignored during in-module resolution, so that we don't get
         // "self-confirming" import resolutions during import validation and checking.
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, ControlFlow<Determinacy, Determinacy>> {
-        let res = self.reborrow().resolve_ident_in_module_non_globs_unadjusted(
-            module,
-            ident,
-            ns,
-            parent_scope,
-            shadowing,
-            finalize,
-            ignore_binding,
-            ignore_import,
-        );
-
-        match res {
-            Ok(_) | Err(ControlFlow::Break(_)) => return res,
-            Err(ControlFlow::Continue(_)) => {}
-        }
-
-        self.resolve_ident_in_module_globs_unadjusted(
-            module,
-            ident,
-            ns,
-            parent_scope,
-            shadowing,
-            finalize,
-            ignore_binding,
-            ignore_import,
-        )
-    }
-
-    /// Attempts to resolve `ident` in namespace `ns` of non-glob bindings in `module`.
-    fn resolve_ident_in_module_non_globs_unadjusted<'r>(
-        mut self: CmResolver<'r, 'ra, 'tcx>,
-        module: Module<'ra>,
-        ident: Ident,
-        ns: Namespace,
-        parent_scope: &ParentScope<'ra>,
-        shadowing: Shadowing,
-        finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
-        ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, ControlFlow<Determinacy, Determinacy>> {
+    ) -> Result<Decl<'ra>, ControlFlow<Determinacy, Determinacy>> {
         let key = BindingKey::new(ident, ns);
         // `try_borrow_mut` is required to ensure exclusive access, even if the resulting binding
         // doesn't need to be mutable. It will fail when there is a cycle of imports, and without
@@ -950,13 +1002,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .try_borrow_mut_unchecked()
             .map_err(|_| ControlFlow::Continue(Determined))?;
 
-        let binding = resolution.non_glob_binding.filter(|b| Some(*b) != ignore_binding);
+        let binding = resolution.non_glob_decl.filter(|b| Some(*b) != ignore_decl);
 
         if let Some(finalize) = finalize {
             return self.get_mut().finalize_module_binding(
-                ident,
+                ident.0,
                 binding,
-                if resolution.non_glob_binding.is_some() { resolution.glob_binding } else { None },
                 parent_scope,
                 module,
                 finalize,
@@ -966,7 +1017,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         // Items and single imports are not shadowable, if we have one, then it's determined.
         if let Some(binding) = binding {
-            let accessible = self.is_accessible_from(binding.vis, parent_scope.module);
+            let accessible = self.is_accessible_from(binding.vis(), parent_scope.module);
             return if accessible { Ok(binding) } else { Err(ControlFlow::Break(Determined)) };
         }
 
@@ -976,7 +1027,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             None,
             ns,
             ignore_import,
-            ignore_binding,
+            ignore_decl,
             parent_scope,
         ) {
             return Err(ControlFlow::Break(Undetermined));
@@ -995,14 +1046,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn resolve_ident_in_module_globs_unadjusted<'r>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
         module: Module<'ra>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
         parent_scope: &ParentScope<'ra>,
         shadowing: Shadowing,
         finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
-    ) -> Result<NameBinding<'ra>, ControlFlow<Determinacy, Determinacy>> {
+    ) -> Result<Decl<'ra>, ControlFlow<Determinacy, Determinacy>> {
         let key = BindingKey::new(ident, ns);
         // `try_borrow_mut` is required to ensure exclusive access, even if the resulting binding
         // doesn't need to be mutable. It will fail when there is a cycle of imports, and without
@@ -1012,13 +1063,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .try_borrow_mut_unchecked()
             .map_err(|_| ControlFlow::Continue(Determined))?;
 
-        let binding = resolution.glob_binding.filter(|b| Some(*b) != ignore_binding);
+        let binding = resolution.glob_decl.filter(|b| Some(*b) != ignore_decl);
 
         if let Some(finalize) = finalize {
             return self.get_mut().finalize_module_binding(
-                ident,
+                ident.0,
                 binding,
-                if resolution.non_glob_binding.is_some() { resolution.glob_binding } else { None },
                 parent_scope,
                 module,
                 finalize,
@@ -1033,7 +1083,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             binding,
             ns,
             ignore_import,
-            ignore_binding,
+            ignore_decl,
             parent_scope,
         ) {
             return Err(ControlFlow::Break(Undetermined));
@@ -1053,7 +1103,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // shadowing is enabled, see `macro_expanded_macro_export_errors`).
         if let Some(binding) = binding {
             return if binding.determined() || ns == MacroNS || shadowing == Shadowing::Restricted {
-                let accessible = self.is_accessible_from(binding.vis, parent_scope.module);
+                let accessible = self.is_accessible_from(binding.vis(), parent_scope.module);
                 if accessible { Ok(binding) } else { Err(ControlFlow::Break(Determined)) }
             } else {
                 Err(ControlFlow::Break(Undetermined))
@@ -1086,9 +1136,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 None => return Err(ControlFlow::Continue(Undetermined)),
             };
             let tmp_parent_scope;
-            let (mut adjusted_parent_scope, mut ident) =
-                (parent_scope, ident.normalize_to_macros_2_0());
-            match ident.span.glob_adjust(module.expansion, glob_import.span) {
+            let (mut adjusted_parent_scope, mut ident) = (parent_scope, ident);
+            match ident.0.span.glob_adjust(module.expansion, glob_import.span) {
                 Some(Some(def)) => {
                     tmp_parent_scope =
                         ParentScope { module: self.expn_def_scope(def), ..*parent_scope };
@@ -1097,28 +1146,24 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 Some(None) => {}
                 None => continue,
             };
-            let result = self.reborrow().resolve_ident_in_module_unadjusted(
-                module,
-                ident,
-                ns,
+            let result = self.reborrow().resolve_ident_in_scope_set(
+                ident.0,
+                ScopeSet::Module(ns, module),
                 adjusted_parent_scope,
-                Shadowing::Unrestricted,
                 None,
-                ignore_binding,
+                false,
+                ignore_decl,
                 ignore_import,
             );
 
             match result {
-                Err(ControlFlow::Break(Determined) | ControlFlow::Continue(Determined)) => continue,
+                Err(Determined) => continue,
                 Ok(binding)
-                    if !self.is_accessible_from(binding.vis, glob_import.parent_scope.module) =>
+                    if !self.is_accessible_from(binding.vis(), glob_import.parent_scope.module) =>
                 {
                     continue;
                 }
-                Ok(_)
-                | Err(ControlFlow::Break(Undetermined) | ControlFlow::Continue(Undetermined)) => {
-                    return Err(ControlFlow::Continue(Undetermined));
-                }
+                Ok(_) | Err(Undetermined) => return Err(ControlFlow::Continue(Undetermined)),
             }
         }
 
@@ -1129,24 +1174,23 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn finalize_module_binding(
         &mut self,
         ident: Ident,
-        binding: Option<NameBinding<'ra>>,
-        shadowed_glob: Option<NameBinding<'ra>>,
+        binding: Option<Decl<'ra>>,
         parent_scope: &ParentScope<'ra>,
         module: Module<'ra>,
         finalize: Finalize,
         shadowing: Shadowing,
-    ) -> Result<NameBinding<'ra>, ControlFlow<Determinacy, Determinacy>> {
+    ) -> Result<Decl<'ra>, ControlFlow<Determinacy, Determinacy>> {
         let Finalize { path_span, report_private, used, root_span, .. } = finalize;
 
         let Some(binding) = binding else {
             return Err(ControlFlow::Continue(Determined));
         };
 
-        if !self.is_accessible_from(binding.vis, parent_scope.module) {
+        if !self.is_accessible_from(binding.vis(), parent_scope.module) {
             if report_private {
                 self.privacy_errors.push(PrivacyError {
                     ident,
-                    binding,
+                    decl: binding,
                     dedup_span: path_span,
                     outermost_res: None,
                     source: None,
@@ -1158,27 +1202,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         }
 
-        // Forbid expanded shadowing to avoid time travel.
-        if let Some(shadowed_glob) = shadowed_glob
-            && shadowing == Shadowing::Restricted
-            && finalize.stage == Stage::Early
-            && binding.expansion != LocalExpnId::ROOT
-            && binding.res() != shadowed_glob.res()
-        {
-            self.ambiguity_errors.push(AmbiguityError {
-                kind: AmbiguityKind::GlobVsExpanded,
-                ident,
-                b1: binding,
-                b2: shadowed_glob,
-                scope1: Scope::Module(self.empty_module, None),
-                scope2: Scope::Module(self.empty_module, None),
-                warning: false,
-            });
-        }
-
         if shadowing == Shadowing::Unrestricted
             && binding.expansion != LocalExpnId::ROOT
-            && let NameBindingKind::Import { import, .. } = binding.kind
+            && let DeclKind::Import { import, .. } = binding.kind
             && matches!(import.kind, ImportKind::MacroExport)
         {
             self.macro_expanded_macro_export_errors.insert((path_span, binding.span));
@@ -1224,21 +1250,29 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn single_import_can_define_name<'r>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
         resolution: &NameResolution<'ra>,
-        binding: Option<NameBinding<'ra>>,
+        binding: Option<Decl<'ra>>,
         ns: Namespace,
         ignore_import: Option<Import<'ra>>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         parent_scope: &ParentScope<'ra>,
     ) -> bool {
         for single_import in &resolution.single_imports {
+            if let Some(decl) = resolution.non_glob_decl
+                && let DeclKind::Import { import, .. } = decl.kind
+                && import == *single_import
+            {
+                // Single import has already defined the name and we are aware of it,
+                // no need to block the globs.
+                continue;
+            }
             if ignore_import == Some(*single_import) {
                 continue;
             }
             if !self.is_accessible_from(single_import.vis, parent_scope.module) {
                 continue;
             }
-            if let Some(ignored) = ignore_binding
-                && let NameBindingKind::Import { import, .. } = ignored.kind
+            if let Some(ignored) = ignore_decl
+                && let DeclKind::Import { import, .. } = ignored.kind
                 && import == *single_import
             {
                 continue;
@@ -1247,13 +1281,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let Some(module) = single_import.imported_module.get() else {
                 return true;
             };
-            let ImportKind::Single { source, target, bindings, .. } = &single_import.kind else {
+            let ImportKind::Single { source, target, decls, .. } = &single_import.kind else {
                 unreachable!();
             };
             if source != target {
-                if bindings.iter().all(|binding| binding.get().binding().is_none()) {
+                if decls.iter().all(|d| d.get().decl().is_none()) {
                     return true;
-                } else if bindings[ns].get().binding().is_none() && binding.is_some() {
+                } else if decls[ns].get().decl().is_none() && binding.is_some() {
                     return true;
                 }
             }
@@ -1264,12 +1298,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 ns,
                 &single_import.parent_scope,
                 None,
-                ignore_binding,
+                ignore_decl,
                 ignore_import,
             ) {
                 Err(Determined) => continue,
                 Ok(binding)
-                    if !self.is_accessible_from(binding.vis, single_import.parent_scope.module) =>
+                    if !self
+                        .is_accessible_from(binding.vis(), single_import.parent_scope.module) =>
                 {
                     continue;
                 }
@@ -1286,7 +1321,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         &mut self,
         rib_index: usize,
         rib_ident: Ident,
-        mut res: Res,
+        res: Res,
         finalize: Option<Span>,
         original_rib_ident_def: Ident,
         all_ribs: &[Rib<'ra>],
@@ -1439,44 +1474,28 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         }
 
                         RibKind::ConstantItem(trivial, _) => {
-                            if let ConstantHasGenerics::No(cause) = trivial {
-                                // HACK(min_const_generics): If we encounter `Self` in an anonymous
-                                // constant we can't easily tell if it's generic at this stage, so
-                                // we instead remember this and then enforce the self type to be
-                                // concrete later on.
-                                if let Res::SelfTyAlias {
-                                    alias_to: def,
-                                    forbid_generic: _,
-                                    is_trait_impl,
-                                } = res
-                                {
-                                    res = Res::SelfTyAlias {
-                                        alias_to: def,
-                                        forbid_generic: true,
-                                        is_trait_impl,
-                                    }
-                                } else {
-                                    if let Some(span) = finalize {
-                                        let error = match cause {
-                                            NoConstantGenericsReason::IsEnumDiscriminant => {
-                                                ResolutionError::ParamInEnumDiscriminant {
-                                                    name: rib_ident.name,
-                                                    param_kind: ParamKindInEnumDiscriminant::Type,
-                                                }
+                            if let ConstantHasGenerics::No(cause) = trivial
+                                && !matches!(res, Res::SelfTyAlias { .. })
+                            {
+                                if let Some(span) = finalize {
+                                    let error = match cause {
+                                        NoConstantGenericsReason::IsEnumDiscriminant => {
+                                            ResolutionError::ParamInEnumDiscriminant {
+                                                name: rib_ident.name,
+                                                param_kind: ParamKindInEnumDiscriminant::Type,
                                             }
-                                            NoConstantGenericsReason::NonTrivialConstArg => {
-                                                ResolutionError::ParamInNonTrivialAnonConst {
-                                                    name: rib_ident.name,
-                                                    param_kind:
-                                                        ParamKindInNonTrivialAnonConst::Type,
-                                                }
+                                        }
+                                        NoConstantGenericsReason::NonTrivialConstArg => {
+                                            ResolutionError::ParamInNonTrivialAnonConst {
+                                                name: rib_ident.name,
+                                                param_kind: ParamKindInNonTrivialAnonConst::Type,
                                             }
-                                        };
-                                        let _: ErrorGuaranteed = self.report_error(span, error);
-                                    }
-
-                                    return Res::Err;
+                                        }
+                                    };
+                                    let _: ErrorGuaranteed = self.report_error(span, error);
                                 }
+
+                                return Res::Err;
                             }
 
                             continue;
@@ -1645,7 +1664,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         opt_ns: Option<Namespace>, // `None` indicates a module path in import
         parent_scope: &ParentScope<'ra>,
         finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
     ) -> PathResult<'ra> {
         self.resolve_path_with_ribs(
@@ -1655,7 +1674,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             None,
             finalize,
             None,
-            ignore_binding,
+            ignore_decl,
             ignore_import,
             None,
         )
@@ -1669,7 +1688,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         source: Option<PathSource<'_, '_, '_>>,
         finalize: Option<Finalize>,
         ribs: Option<&PerNS<Vec<Rib<'ra>>>>,
-        ignore_binding: Option<NameBinding<'ra>>,
+        ignore_decl: Option<Decl<'ra>>,
         ignore_import: Option<Import<'ra>>,
         diag_metadata: Option<&DiagMetadata<'_>>,
     ) -> PathResult<'ra> {
@@ -1796,7 +1815,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     ns,
                     parent_scope,
                     finalize,
-                    ignore_binding,
+                    ignore_decl,
                     ignore_import,
                 )
             } else if let Some(ribs) = ribs
@@ -1809,13 +1828,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     parent_scope,
                     finalize,
                     &ribs[ns],
-                    ignore_binding,
+                    ignore_decl,
                     diag_metadata,
                 ) {
                     // we found a locally-imported or available item/module
-                    Some(LexicalScopeBinding::Item(binding)) => Ok(binding),
+                    Some(LateDecl::Decl(binding)) => Ok(binding),
                     // we found a local variable or type param
-                    Some(LexicalScopeBinding::Res(res)) => {
+                    Some(LateDecl::RibDef(res)) => {
                         record_segment_res(self.reborrow(), finalize, res, id);
                         return PathResult::NonModule(PartialRes::with_unresolved_segments(
                             res,
@@ -1831,7 +1850,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     parent_scope,
                     finalize,
                     finalize.is_some(),
-                    ignore_binding,
+                    ignore_decl,
                     ignore_import,
                 )
             };
@@ -1931,7 +1950,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 opt_ns,
                                 parent_scope,
                                 ribs,
-                                ignore_binding,
+                                ignore_decl,
                                 ignore_import,
                                 module,
                                 segment_idx,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 4e0f3db59821..b98061ea8130 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -9,7 +9,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir::def::{self, DefKind, PartialRes};
 use rustc_hir::def_id::{DefId, LocalDefIdMap};
-use rustc_middle::metadata::{AmbigModChild, AmbigModChildKind, ModChild, Reexport};
+use rustc_middle::metadata::{AmbigModChild, ModChild, Reexport};
 use rustc_middle::span_bug;
 use rustc_middle::ty::Visibility;
 use rustc_session::lint::BuiltinLintDiag;
@@ -20,7 +20,7 @@ use rustc_session::lint::builtin::{
 use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::hygiene::LocalExpnId;
-use rustc_span::{Ident, Span, Symbol, kw, sym};
+use rustc_span::{Ident, Macros20NormalizedIdent, Span, Symbol, kw, sym};
 use tracing::debug;
 
 use crate::Namespace::{self, *};
@@ -32,27 +32,27 @@ use crate::errors::{
 };
 use crate::ref_mut::CmCell;
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingKey, CmResolver, Determinacy, Finalize, ImportSuggestion,
-    Module, ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope,
-    PathResult, PerNS, ResolutionError, Resolver, ScopeSet, Segment, Used, module_to_string,
-    names_to_string,
+    AmbiguityError, BindingKey, CmResolver, Decl, DeclData, DeclKind, Determinacy, Finalize,
+    ImportSuggestion, Module, ModuleOrUniformRoot, ParentScope, PathResult, PerNS, ResolutionError,
+    Resolver, ScopeSet, Segment, Used, module_to_string, names_to_string,
 };
 
 type Res = def::Res<NodeId>;
 
-/// A [`NameBinding`] in the process of being resolved.
+/// A potential import declaration in the process of being planted into a module.
+/// Also used for lazily planting names from `--extern` flags to extern prelude.
 #[derive(Clone, Copy, Default, PartialEq)]
-pub(crate) enum PendingBinding<'ra> {
-    Ready(Option<NameBinding<'ra>>),
+pub(crate) enum PendingDecl<'ra> {
+    Ready(Option<Decl<'ra>>),
     #[default]
     Pending,
 }
 
-impl<'ra> PendingBinding<'ra> {
-    pub(crate) fn binding(self) -> Option<NameBinding<'ra>> {
+impl<'ra> PendingDecl<'ra> {
+    pub(crate) fn decl(self) -> Option<Decl<'ra>> {
         match self {
-            PendingBinding::Ready(binding) => binding,
-            PendingBinding::Pending => None,
+            PendingDecl::Ready(decl) => decl,
+            PendingDecl::Pending => None,
         }
     }
 }
@@ -66,8 +66,8 @@ pub(crate) enum ImportKind<'ra> {
         /// `target` in `use prefix::source as target`.
         /// It will directly use `source` when the format is `use prefix::source`.
         target: Ident,
-        /// Bindings introduced by the import.
-        bindings: PerNS<CmCell<PendingBinding<'ra>>>,
+        /// Name declarations introduced by the import.
+        decls: PerNS<CmCell<PendingDecl<'ra>>>,
         /// `true` for `...::{self [as target]}` imports, `false` otherwise.
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
@@ -110,14 +110,14 @@ impl<'ra> std::fmt::Debug for ImportKind<'ra> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use ImportKind::*;
         match self {
-            Single { source, target, bindings, type_ns_only, nested, id, .. } => f
+            Single { source, target, decls, type_ns_only, nested, id, .. } => f
                 .debug_struct("Single")
                 .field("source", source)
                 .field("target", target)
                 // Ignore the nested bindings to avoid an infinite loop while printing.
                 .field(
-                    "bindings",
-                    &bindings.clone().map(|b| b.into_inner().binding().map(|_| format_args!(".."))),
+                    "decls",
+                    &decls.clone().map(|b| b.into_inner().decl().map(|_| format_args!(".."))),
                 )
                 .field("type_ns_only", type_ns_only)
                 .field("nested", nested)
@@ -244,16 +244,16 @@ pub(crate) struct NameResolution<'ra> {
     /// Single imports that may define the name in the namespace.
     /// Imports are arena-allocated, so it's ok to use pointers as keys.
     pub single_imports: FxIndexSet<Import<'ra>>,
-    /// The non-glob binding for this name, if it is known to exist.
-    pub non_glob_binding: Option<NameBinding<'ra>>,
-    /// The glob binding for this name, if it is known to exist.
-    pub glob_binding: Option<NameBinding<'ra>>,
+    /// The non-glob declaration for this name, if it is known to exist.
+    pub non_glob_decl: Option<Decl<'ra>>,
+    /// The glob declaration for this name, if it is known to exist.
+    pub glob_decl: Option<Decl<'ra>>,
 }
 
 impl<'ra> NameResolution<'ra> {
     /// Returns the binding for the name if it is known or None if it not known.
-    pub(crate) fn binding(&self) -> Option<NameBinding<'ra>> {
-        self.best_binding().and_then(|binding| {
+    pub(crate) fn binding(&self) -> Option<Decl<'ra>> {
+        self.best_decl().and_then(|binding| {
             if !binding.is_glob_import() || self.single_imports.is_empty() {
                 Some(binding)
             } else {
@@ -262,8 +262,8 @@ impl<'ra> NameResolution<'ra> {
         })
     }
 
-    pub(crate) fn best_binding(&self) -> Option<NameBinding<'ra>> {
-        self.non_glob_binding.or(self.glob_binding)
+    pub(crate) fn best_decl(&self) -> Option<Decl<'ra>> {
+        self.non_glob_decl.or(self.glob_decl)
     }
 }
 
@@ -283,13 +283,10 @@ struct UnresolvedImportError {
 
 // Reexports of the form `pub use foo as bar;` where `foo` is `extern crate foo;`
 // are permitted for backward-compatibility under a deprecation lint.
-fn pub_use_of_private_extern_crate_hack(
-    import: Import<'_>,
-    binding: NameBinding<'_>,
-) -> Option<NodeId> {
-    match (&import.kind, &binding.kind) {
-        (ImportKind::Single { .. }, NameBindingKind::Import { import: binding_import, .. })
-            if let ImportKind::ExternCrate { id, .. } = binding_import.kind
+fn pub_use_of_private_extern_crate_hack(import: Import<'_>, decl: Decl<'_>) -> Option<NodeId> {
+    match (&import.kind, &decl.kind) {
+        (ImportKind::Single { .. }, DeclKind::Import { import: decl_import, .. })
+            if let ImportKind::ExternCrate { id, .. } = decl_import.kind
                 && import.vis.is_public() =>
         {
             Some(id)
@@ -298,21 +295,35 @@ fn pub_use_of_private_extern_crate_hack(
     }
 }
 
+/// Removes identical import layers from two declarations.
+fn remove_same_import<'ra>(d1: Decl<'ra>, d2: Decl<'ra>) -> (Decl<'ra>, Decl<'ra>) {
+    if let DeclKind::Import { import: import1, source_decl: d1_next } = d1.kind
+        && let DeclKind::Import { import: import2, source_decl: d2_next } = d2.kind
+        && import1 == import2
+        && d1.warn_ambiguity.get() == d2.warn_ambiguity.get()
+    {
+        assert_eq!(d1.ambiguity.get(), d2.ambiguity.get());
+        assert!(!d1.warn_ambiguity.get());
+        assert_eq!(d1.expansion, d2.expansion);
+        assert_eq!(d1.span, d2.span);
+        assert_eq!(d1.vis(), d2.vis());
+        remove_same_import(d1_next, d2_next)
+    } else {
+        (d1, d2)
+    }
+}
+
 impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
-    /// Given a binding and an import that resolves to it,
-    /// return the corresponding binding defined by the import.
-    pub(crate) fn import(
-        &self,
-        binding: NameBinding<'ra>,
-        import: Import<'ra>,
-    ) -> NameBinding<'ra> {
+    /// Given an import and the declaration that it points to,
+    /// create the corresponding import declaration.
+    pub(crate) fn new_import_decl(&self, decl: Decl<'ra>, import: Import<'ra>) -> Decl<'ra> {
         let import_vis = import.vis.to_def_id();
-        let vis = if binding.vis.is_at_least(import_vis, self.tcx)
-            || pub_use_of_private_extern_crate_hack(import, binding).is_some()
+        let vis = if decl.vis().is_at_least(import_vis, self.tcx)
+            || pub_use_of_private_extern_crate_hack(import, decl).is_some()
         {
             import_vis
         } else {
-            binding.vis
+            decl.vis()
         };
 
         if let ImportKind::Glob { ref max_vis, .. } = import.kind
@@ -322,28 +333,91 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             max_vis.set_unchecked(Some(vis.expect_local()))
         }
 
-        self.arenas.alloc_name_binding(NameBindingData {
-            kind: NameBindingKind::Import { binding, import },
-            ambiguity: None,
-            warn_ambiguity: false,
+        self.arenas.alloc_decl(DeclData {
+            kind: DeclKind::Import { source_decl: decl, import },
+            ambiguity: CmCell::new(None),
+            warn_ambiguity: CmCell::new(false),
             span: import.span,
-            vis,
+            vis: CmCell::new(vis),
             expansion: import.parent_scope.expansion,
         })
     }
 
-    /// Define the name or return the existing binding if there is a collision.
-    pub(crate) fn try_define_local(
+    /// If `glob_decl` attempts to overwrite `old_glob_decl` in a module,
+    /// decide which one to keep.
+    fn select_glob_decl(
+        &self,
+        glob_decl: Decl<'ra>,
+        old_glob_decl: Decl<'ra>,
+        warn_ambiguity: bool,
+    ) -> Decl<'ra> {
+        assert!(glob_decl.is_glob_import());
+        assert!(old_glob_decl.is_glob_import());
+        assert_ne!(glob_decl, old_glob_decl);
+        // `best_decl` with a given key in a module may be overwritten in a
+        // number of cases (all of them can be seen below in the `match` in `try_define_local`),
+        // all these overwrites will be re-fetched by glob imports importing
+        // from that module without generating new ambiguities.
+        // - A glob decl is overwritten by a non-glob decl arriving later.
+        // - A glob decl is overwritten by its clone after setting ambiguity in it.
+        //   FIXME: avoid this by removing `warn_ambiguity`, or by triggering glob re-fetch
+        //   with the same decl in some way.
+        // - A glob decl is overwritten by a glob decl re-fetching an
+        //   overwritten decl from other module (the recursive case).
+        // Here we are detecting all such re-fetches and overwrite old decls
+        // with the re-fetched decls.
+        // This is probably incorrect in corner cases, and the outdated decls still get
+        // propagated to other places and get stuck there, but that's what we have at the moment.
+        let (deep_decl, old_deep_decl) = remove_same_import(glob_decl, old_glob_decl);
+        if deep_decl != glob_decl {
+            // Some import layers have been removed, need to overwrite.
+            assert_ne!(old_deep_decl, old_glob_decl);
+            // FIXME: reenable the asserts when `warn_ambiguity` is removed (#149195).
+            // assert_ne!(old_deep_decl, deep_decl);
+            // assert!(old_deep_decl.is_glob_import());
+            assert!(!deep_decl.is_glob_import());
+            if glob_decl.is_ambiguity_recursive() {
+                glob_decl.warn_ambiguity.set_unchecked(true);
+            }
+            glob_decl
+        } else if glob_decl.res() != old_glob_decl.res() {
+            old_glob_decl.ambiguity.set_unchecked(Some(glob_decl));
+            old_glob_decl.warn_ambiguity.set_unchecked(warn_ambiguity);
+            if warn_ambiguity {
+                old_glob_decl
+            } else {
+                // Need a fresh decl so other glob imports importing it could re-fetch it
+                // and set their own `warn_ambiguity` to true.
+                // FIXME: remove this when `warn_ambiguity` is removed (#149195).
+                self.arenas.alloc_decl((*old_glob_decl).clone())
+            }
+        } else if !old_glob_decl.vis().is_at_least(glob_decl.vis(), self.tcx) {
+            // We are glob-importing the same item but with greater visibility.
+            old_glob_decl.vis.set_unchecked(glob_decl.vis());
+            old_glob_decl
+        } else if glob_decl.is_ambiguity_recursive() && !old_glob_decl.is_ambiguity_recursive() {
+            // Overwriting a non-ambiguous glob import with an ambiguous glob import.
+            old_glob_decl.ambiguity.set_unchecked(Some(glob_decl));
+            old_glob_decl.warn_ambiguity.set_unchecked(true);
+            old_glob_decl
+        } else {
+            old_glob_decl
+        }
+    }
+
+    /// Attempt to put the declaration with the given name and namespace into the module,
+    /// and return existing declaration if there is a collision.
+    pub(crate) fn try_plant_decl_into_local_module(
         &mut self,
         module: Module<'ra>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
-        binding: NameBinding<'ra>,
+        decl: Decl<'ra>,
         warn_ambiguity: bool,
-    ) -> Result<(), NameBinding<'ra>> {
-        let res = binding.res();
-        self.check_reserved_macro_name(ident, res);
-        self.set_binding_parent_module(binding, module);
+    ) -> Result<(), Decl<'ra>> {
+        let res = decl.res();
+        self.check_reserved_macro_name(ident.0, res);
+        self.set_decl_parent_module(decl, module);
         // Even if underscore names cannot be looked up, we still need to add them to modules,
         // because they can be fetched by glob imports from those modules, and bring traits
         // into scope both directly and through glob imports.
@@ -352,82 +426,40 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             module.underscore_disambiguator.get()
         });
         self.update_local_resolution(module, key, warn_ambiguity, |this, resolution| {
-            if let Some(old_binding) = resolution.best_binding() {
-                if res == Res::Err && old_binding.res() != Res::Err {
-                    // Do not override real bindings with `Res::Err`s from error recovery.
+            if let Some(old_decl) = resolution.best_decl() {
+                assert_ne!(decl, old_decl);
+                assert!(!decl.warn_ambiguity.get());
+                if res == Res::Err && old_decl.res() != Res::Err {
+                    // Do not override real declarations with `Res::Err`s from error recovery.
                     return Ok(());
                 }
-                match (old_binding.is_glob_import(), binding.is_glob_import()) {
+                match (old_decl.is_glob_import(), decl.is_glob_import()) {
                     (true, true) => {
-                        let (glob_binding, old_glob_binding) = (binding, old_binding);
-                        // FIXME: remove `!binding.is_ambiguity_recursive()` after delete the warning ambiguity.
-                        if !binding.is_ambiguity_recursive()
-                            && let NameBindingKind::Import { import: old_import, .. } =
-                                old_glob_binding.kind
-                            && let NameBindingKind::Import { import, .. } = glob_binding.kind
-                            && old_import == import
-                        {
-                            // When imported from the same glob-import statement, we should replace
-                            // `old_glob_binding` with `glob_binding`, regardless of whether
-                            // they have the same resolution or not.
-                            resolution.glob_binding = Some(glob_binding);
-                        } else if res != old_glob_binding.res() {
-                            resolution.glob_binding = Some(this.new_ambiguity_binding(
-                                AmbiguityKind::GlobVsGlob,
-                                old_glob_binding,
-                                glob_binding,
-                                warn_ambiguity,
-                            ));
-                        } else if !old_binding.vis.is_at_least(binding.vis, this.tcx) {
-                            // We are glob-importing the same item but with greater visibility.
-                            resolution.glob_binding = Some(glob_binding);
-                        } else if binding.is_ambiguity_recursive() {
-                            resolution.glob_binding =
-                                Some(this.new_warn_ambiguity_binding(glob_binding));
-                        }
+                        resolution.glob_decl =
+                            Some(this.select_glob_decl(decl, old_decl, warn_ambiguity));
                     }
                     (old_glob @ true, false) | (old_glob @ false, true) => {
-                        let (glob_binding, non_glob_binding) =
-                            if old_glob { (old_binding, binding) } else { (binding, old_binding) };
-                        if ns == MacroNS
-                            && non_glob_binding.expansion != LocalExpnId::ROOT
-                            && glob_binding.res() != non_glob_binding.res()
+                        let (glob_decl, non_glob_decl) =
+                            if old_glob { (old_decl, decl) } else { (decl, old_decl) };
+                        resolution.non_glob_decl = Some(non_glob_decl);
+                        if let Some(old_glob_decl) = resolution.glob_decl
+                            && old_glob_decl != glob_decl
                         {
-                            resolution.non_glob_binding = Some(this.new_ambiguity_binding(
-                                AmbiguityKind::GlobVsExpanded,
-                                non_glob_binding,
-                                glob_binding,
-                                false,
-                            ));
+                            resolution.glob_decl =
+                                Some(this.select_glob_decl(glob_decl, old_glob_decl, false));
                         } else {
-                            resolution.non_glob_binding = Some(non_glob_binding);
-                        }
-
-                        if let Some(old_glob_binding) = resolution.glob_binding {
-                            assert!(old_glob_binding.is_glob_import());
-                            if glob_binding.res() != old_glob_binding.res() {
-                                resolution.glob_binding = Some(this.new_ambiguity_binding(
-                                    AmbiguityKind::GlobVsGlob,
-                                    old_glob_binding,
-                                    glob_binding,
-                                    false,
-                                ));
-                            } else if !old_glob_binding.vis.is_at_least(binding.vis, this.tcx) {
-                                resolution.glob_binding = Some(glob_binding);
-                            }
-                        } else {
-                            resolution.glob_binding = Some(glob_binding);
+                            resolution.glob_decl = Some(glob_decl);
                         }
                     }
                     (false, false) => {
-                        return Err(old_binding);
+                        return Err(old_decl);
                     }
                 }
             } else {
-                if binding.is_glob_import() {
-                    resolution.glob_binding = Some(binding);
+                if decl.is_glob_import() {
+                    resolution.glob_decl = Some(decl);
                 } else {
-                    resolution.non_glob_binding = Some(binding);
+                    resolution.non_glob_decl = Some(decl);
                 }
             }
 
@@ -435,23 +467,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         })
     }
 
-    fn new_ambiguity_binding(
-        &self,
-        ambiguity_kind: AmbiguityKind,
-        primary_binding: NameBinding<'ra>,
-        secondary_binding: NameBinding<'ra>,
-        warn_ambiguity: bool,
-    ) -> NameBinding<'ra> {
-        let ambiguity = Some((secondary_binding, ambiguity_kind));
-        let data = NameBindingData { ambiguity, warn_ambiguity, ..*primary_binding };
-        self.arenas.alloc_name_binding(data)
-    }
-
-    fn new_warn_ambiguity_binding(&self, binding: NameBinding<'ra>) -> NameBinding<'ra> {
-        assert!(binding.is_ambiguity_recursive());
-        self.arenas.alloc_name_binding(NameBindingData { warn_ambiguity: true, ..*binding })
-    }
-
     // Use `f` to mutate the resolution of the name in the module.
     // If the resolution becomes a success, define it in the module's glob importers.
     fn update_local_resolution<T, F>(
@@ -468,14 +483,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // during which the resolution might end up getting re-defined via a glob cycle.
         let (binding, t, warn_ambiguity) = {
             let resolution = &mut *self.resolution_or_default(module, key).borrow_mut_unchecked();
-            let old_binding = resolution.binding();
+            let old_decl = resolution.binding();
 
             let t = f(self, resolution);
 
             if let Some(binding) = resolution.binding()
-                && old_binding != Some(binding)
+                && old_decl != Some(binding)
             {
-                (binding, t, warn_ambiguity || old_binding.is_some())
+                (binding, t, warn_ambiguity || old_decl.is_some())
             } else {
                 return t;
             }
@@ -493,13 +508,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 Some(None) => import.parent_scope.module,
                 None => continue,
             };
-            if self.is_accessible_from(binding.vis, scope) {
-                let imported_binding = self.import(binding, *import);
-                let _ = self.try_define_local(
+            if self.is_accessible_from(binding.vis(), scope) {
+                let import_decl = self.new_import_decl(binding, *import);
+                let _ = self.try_plant_decl_into_local_module(
                     import.parent_scope.module,
-                    ident.0,
+                    ident,
                     key.ns,
-                    imported_binding,
+                    import_decl,
                     warn_ambiguity,
                 );
             }
@@ -511,26 +526,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     // Define a dummy resolution containing a `Res::Err` as a placeholder for a failed
     // or indeterminate resolution, also mark such failed imports as used to avoid duplicate diagnostics.
     fn import_dummy_binding(&mut self, import: Import<'ra>, is_indeterminate: bool) {
-        if let ImportKind::Single { target, ref bindings, .. } = import.kind {
-            if !(is_indeterminate
-                || bindings.iter().all(|binding| binding.get().binding().is_none()))
-            {
+        if let ImportKind::Single { target, ref decls, .. } = import.kind {
+            if !(is_indeterminate || decls.iter().all(|d| d.get().decl().is_none())) {
                 return; // Has resolution, do not create the dummy binding
             }
-            let dummy_binding = self.dummy_binding;
-            let dummy_binding = self.import(dummy_binding, import);
+            let dummy_decl = self.dummy_decl;
+            let dummy_decl = self.new_import_decl(dummy_decl, import);
             self.per_ns(|this, ns| {
                 let module = import.parent_scope.module;
-                let _ = this.try_define_local(module, target, ns, dummy_binding, false);
+                let ident = Macros20NormalizedIdent::new(target);
+                let _ = this.try_plant_decl_into_local_module(module, ident, ns, dummy_decl, false);
                 // Don't remove underscores from `single_imports`, they were never added.
                 if target.name != kw::Underscore {
-                    let key = BindingKey::new(target, ns);
+                    let key = BindingKey::new(ident, ns);
                     this.update_local_resolution(module, key, false, |_, resolution| {
                         resolution.single_imports.swap_remove(&import);
                     })
                 }
             });
-            self.record_use(target, dummy_binding, Used::Other);
+            self.record_use(target, dummy_decl, Used::Other);
         } else if import.imported_module.get().is_none() {
             self.import_use_map.insert(import, Used::Other);
             if let Some(id) = import.id() {
@@ -598,10 +612,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             glob_error |= import.is_glob();
 
-            if let ImportKind::Single { source, ref bindings, .. } = import.kind
+            if let ImportKind::Single { source, ref decls, .. } = import.kind
                 && source.name == kw::SelfLower
                 // Silence `unresolved import` error if E0429 is already emitted
-                && let PendingBinding::Ready(None) = bindings.value_ns.get()
+                && let PendingDecl::Ready(None) = decls.value_ns.get()
             {
                 continue;
             }
@@ -651,14 +665,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<NameBinding<'ra>>) {
+    pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<Decl<'ra>>) {
         for module in &self.local_modules {
             for (key, resolution) in self.resolutions(*module).borrow().iter() {
                 let resolution = resolution.borrow();
-                let Some(binding) = resolution.best_binding() else { continue };
+                let Some(binding) = resolution.best_decl() else { continue };
 
-                if let NameBindingKind::Import { import, .. } = binding.kind
-                    && let Some((amb_binding, _)) = binding.ambiguity
+                if let DeclKind::Import { import, .. } = binding.kind
+                    && let Some(amb_binding) = binding.ambiguity.get()
                     && binding.res() != Res::Err
                     && exported_ambiguities.contains(&binding)
                 {
@@ -675,24 +689,23 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     );
                 }
 
-                if let Some(glob_binding) = resolution.glob_binding
-                    && resolution.non_glob_binding.is_some()
+                if let Some(glob_decl) = resolution.glob_decl
+                    && resolution.non_glob_decl.is_some()
                 {
                     if binding.res() != Res::Err
-                        && glob_binding.res() != Res::Err
-                        && let NameBindingKind::Import { import: glob_import, .. } =
-                            glob_binding.kind
+                        && glob_decl.res() != Res::Err
+                        && let DeclKind::Import { import: glob_import, .. } = glob_decl.kind
                         && let Some(glob_import_id) = glob_import.id()
                         && let glob_import_def_id = self.local_def_id(glob_import_id)
                         && self.effective_visibilities.is_exported(glob_import_def_id)
-                        && glob_binding.vis.is_public()
-                        && !binding.vis.is_public()
+                        && glob_decl.vis().is_public()
+                        && !binding.vis().is_public()
                     {
                         let binding_id = match binding.kind {
-                            NameBindingKind::Res(res) => {
+                            DeclKind::Def(res) => {
                                 Some(self.def_id_to_node_id(res.def_id().expect_local()))
                             }
-                            NameBindingKind::Import { import, .. } => import.id(),
+                            DeclKind::Import { import, .. } => import.id(),
                         };
                         if let Some(binding_id) = binding_id {
                             self.lint_buffer.buffer_lint(
@@ -702,7 +715,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 BuiltinLintDiag::HiddenGlobReexports {
                                     name: key.ident.name.to_string(),
                                     namespace: key.ns.descr().to_owned(),
-                                    glob_reexport_span: glob_binding.span,
+                                    glob_reexport_span: glob_decl.span,
                                     private_item_span: binding.span,
                                 },
                             );
@@ -710,7 +723,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                 }
 
-                if let NameBindingKind::Import { import, .. } = binding.kind
+                if let DeclKind::Import { import, .. } = binding.kind
                     && let Some(binding_id) = import.id()
                     && let import_def_id = self.local_def_id(binding_id)
                     && self.effective_visibilities.is_exported(import_def_id)
@@ -863,8 +876,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         import.imported_module.set_unchecked(Some(module));
         let (source, target, bindings, type_ns_only) = match import.kind {
-            ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
-                (source, target, bindings, type_ns_only)
+            ImportKind::Single { source, target, ref decls, type_ns_only, .. } => {
+                (source, target, decls, type_ns_only)
             }
             ImportKind::Glob { .. } => {
                 self.get_mut_unchecked().resolve_glob_import(import);
@@ -876,7 +889,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut indeterminate_count = 0;
         self.per_ns_cm(|this, ns| {
             if !type_ns_only || ns == TypeNS {
-                if bindings[ns].get() != PendingBinding::Pending {
+                if bindings[ns].get() != PendingDecl::Pending {
                     return;
                 };
                 let binding_result = this.reborrow().maybe_resolve_ident_in_module(
@@ -901,19 +914,19 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             .emit();
                         }
                         // We need the `target`, `source` can be extracted.
-                        let imported_binding = this.import(binding, import);
-                        this.get_mut_unchecked().define_binding_local(
+                        let import_decl = this.new_import_decl(binding, import);
+                        this.get_mut_unchecked().plant_decl_into_local_module(
                             parent,
-                            target,
+                            Macros20NormalizedIdent::new(target),
                             ns,
-                            imported_binding,
+                            import_decl,
                         );
-                        PendingBinding::Ready(Some(imported_binding))
+                        PendingDecl::Ready(Some(import_decl))
                     }
                     Err(Determinacy::Determined) => {
                         // Don't remove underscores from `single_imports`, they were never added.
                         if target.name != kw::Underscore {
-                            let key = BindingKey::new(target, ns);
+                            let key = BindingKey::new(Macros20NormalizedIdent::new(target), ns);
                             this.get_mut_unchecked().update_local_resolution(
                                 parent,
                                 key,
@@ -923,11 +936,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 },
                             );
                         }
-                        PendingBinding::Ready(None)
+                        PendingDecl::Ready(None)
                     }
                     Err(Determinacy::Undetermined) => {
                         indeterminate_count += 1;
-                        PendingBinding::Pending
+                        PendingDecl::Pending
                     }
                 };
                 bindings[ns].set_unchecked(binding);
@@ -942,8 +955,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// Optionally returns an unresolved import error. This error is buffered and used to
     /// consolidate multiple unresolved import errors into a single diagnostic.
     fn finalize_import(&mut self, import: Import<'ra>) -> Option<UnresolvedImportError> {
-        let ignore_binding = match &import.kind {
-            ImportKind::Single { bindings, .. } => bindings[TypeNS].get().binding(),
+        let ignore_decl = match &import.kind {
+            ImportKind::Single { decls, .. } => decls[TypeNS].get().decl(),
             _ => None,
         };
         let ambiguity_errors_len =
@@ -959,7 +972,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             None,
             &import.parent_scope,
             Some(finalize),
-            ignore_binding,
+            ignore_decl,
             Some(import),
         );
 
@@ -1062,8 +1075,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         };
 
         let (ident, target, bindings, type_ns_only, import_id) = match import.kind {
-            ImportKind::Single { source, target, ref bindings, type_ns_only, id, .. } => {
-                (source, target, bindings, type_ns_only, id)
+            ImportKind::Single { source, target, ref decls, type_ns_only, id, .. } => {
+                (source, target, decls, type_ns_only, id)
             }
             ImportKind::Glob { ref max_vis, id } => {
                 if import.module_path.len() <= 1 {
@@ -1119,7 +1132,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 None,
                 &import.parent_scope,
                 Some(finalize),
-                ignore_binding,
+                ignore_decl,
                 None,
             ) {
                 let res = module.res().map(|r| (r, ident));
@@ -1138,14 +1151,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     ns,
                     &import.parent_scope,
                     Some(Finalize { report_private: false, ..finalize }),
-                    bindings[ns].get().binding(),
+                    bindings[ns].get().decl(),
                     Some(import),
                 );
 
                 match binding {
                     Ok(binding) => {
                         // Consistency checks, analogous to `finalize_macro_resolutions`.
-                        let initial_res = bindings[ns].get().binding().map(|binding| {
+                        let initial_res = bindings[ns].get().decl().map(|binding| {
                             let initial_binding = binding.import_source();
                             all_ns_err = false;
                             if target.name == kw::Underscore
@@ -1222,13 +1235,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 } // Never suggest the same name
 
                                 let resolution = resolution.borrow();
-                                if let Some(name_binding) = resolution.best_binding() {
+                                if let Some(name_binding) = resolution.best_decl() {
                                     match name_binding.kind {
-                                        NameBindingKind::Import { binding, .. } => {
-                                            match binding.kind {
-                                                // Never suggest the name that has binding error
-                                                // i.e., the name that cannot be previously resolved
-                                                NameBindingKind::Res(Res::Err) => None,
+                                        DeclKind::Import { source_decl, .. } => {
+                                            match source_decl.kind {
+                                                // Never suggest names that previously could not
+                                                // be resolved.
+                                                DeclKind::Def(Res::Err) => None,
                                                 _ => Some(i.name),
                                             }
                                         }
@@ -1312,13 +1325,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut any_successful_reexport = false;
         let mut crate_private_reexport = false;
         self.per_ns(|this, ns| {
-            let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) else {
+            let Some(binding) = bindings[ns].get().decl().map(|b| b.import_source()) else {
                 return;
             };
 
-            if !binding.vis.is_at_least(import.vis, this.tcx) {
+            if !binding.vis().is_at_least(import.vis, this.tcx) {
                 reexport_error = Some((ns, binding));
-                if let Visibility::Restricted(binding_def_id) = binding.vis
+                if let Visibility::Restricted(binding_def_id) = binding.vis()
                     && binding_def_id.is_top_level_module()
                 {
                     crate_private_reexport = true;
@@ -1359,7 +1372,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 };
 
                 match binding.kind {
-                        NameBindingKind::Res(Res::Def(DefKind::Macro(_), def_id))
+                        DeclKind::Def(Res::Def(DefKind::Macro(_), def_id))
                             // exclude decl_macro
                             if self.get_macro_by_def_id(def_id).macro_rules =>
                         {
@@ -1387,7 +1400,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let mut full_path = import.module_path.clone();
             full_path.push(Segment::from_ident(ident));
             self.per_ns(|this, ns| {
-                if let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) {
+                if let Some(binding) = bindings[ns].get().decl().map(|b| b.import_source()) {
                     this.lint_if_path_starts_with_module(finalize, &full_path, Some(binding));
                 }
             });
@@ -1397,7 +1410,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // this may resolve to either a value or a type, but for documentation
         // purposes it's good enough to just favor one over the other.
         self.per_ns(|this, ns| {
-            if let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) {
+            if let Some(binding) = bindings[ns].get().decl().map(|b| b.import_source()) {
                 this.import_res_map.entry(import_id).or_default()[ns] = Some(binding.res());
             }
         });
@@ -1408,7 +1421,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     pub(crate) fn check_for_redundant_imports(&mut self, import: Import<'ra>) -> bool {
         // This function is only called for single imports.
-        let ImportKind::Single { source, target, ref bindings, id, .. } = import.kind else {
+        let ImportKind::Single { source, target, ref decls, id, .. } = import.kind else {
             unreachable!()
         };
 
@@ -1435,7 +1448,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut is_redundant = true;
         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
         self.per_ns(|this, ns| {
-            let binding = bindings[ns].get().binding().map(|b| b.import_source());
+            let binding = decls[ns].get().decl().map(|b| b.import_source());
             if is_redundant && let Some(binding) = binding {
                 if binding.res() == Res::Err {
                     return;
@@ -1447,7 +1460,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     &import.parent_scope,
                     None,
                     false,
-                    bindings[ns].get().binding(),
+                    decls[ns].get().decl(),
                     None,
                 ) {
                     Ok(other_binding) => {
@@ -1521,17 +1534,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 Some(None) => import.parent_scope.module,
                 None => continue,
             };
-            if self.is_accessible_from(binding.vis, scope) {
-                let imported_binding = self.import(binding, import);
+            if self.is_accessible_from(binding.vis(), scope) {
+                let import_decl = self.new_import_decl(binding, import);
                 let warn_ambiguity = self
                     .resolution(import.parent_scope.module, key)
                     .and_then(|r| r.binding())
                     .is_some_and(|binding| binding.warn_ambiguity_recursive());
-                let _ = self.try_define_local(
+                let _ = self.try_plant_decl_into_local_module(
                     import.parent_scope.module,
-                    key.ident.0,
+                    key.ident,
                     key.ns,
-                    imported_binding,
+                    import_decl,
                     warn_ambiguity,
                 );
             }
@@ -1563,26 +1576,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 let child = |reexport_chain| ModChild {
                     ident: ident.0,
                     res,
-                    vis: binding.vis,
+                    vis: binding.vis(),
                     reexport_chain,
                 };
-                if let Some((ambig_binding1, ambig_binding2, ambig_kind)) =
-                    binding.descent_to_ambiguity()
-                {
+                if let Some((ambig_binding1, ambig_binding2)) = binding.descent_to_ambiguity() {
                     let main = child(ambig_binding1.reexport_chain(this));
                     let second = ModChild {
                         ident: ident.0,
                         res: ambig_binding2.res().expect_non_local(),
-                        vis: ambig_binding2.vis,
+                        vis: ambig_binding2.vis(),
                         reexport_chain: ambig_binding2.reexport_chain(this),
                     };
-                    let kind = match ambig_kind {
-                        AmbiguityKind::GlobVsGlob => AmbigModChildKind::GlobVsGlob,
-                        AmbiguityKind::GlobVsExpanded => AmbigModChildKind::GlobVsExpanded,
-                        _ => unreachable!(),
-                    };
-
-                    ambig_children.push(AmbigModChild { main, second, kind })
+                    ambig_children.push(AmbigModChild { main, second })
                 } else {
                     children.push(child(binding.reexport_chain(this)));
                 }
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index dd80f5da508c..4d2ba73c9cab 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -37,15 +37,17 @@ use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
 use rustc_session::parse::feature_err;
 use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, SyntaxContext, kw, sym};
+use rustc_span::{
+    BytePos, DUMMY_SP, Ident, Macros20NormalizedIdent, Span, Symbol, SyntaxContext, kw, sym,
+};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
 
 use crate::{
-    BindingError, BindingKey, Finalize, LexicalScopeBinding, Module, ModuleOrUniformRoot,
-    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, TyCtxt, UseError,
-    Used, errors, path_names_to_string, rustdoc,
+    BindingError, BindingKey, Decl, Finalize, LateDecl, Module, ModuleOrUniformRoot, ParentScope,
+    PathResult, ResolutionError, Resolver, Segment, Stage, TyCtxt, UseError, Used, errors,
+    path_names_to_string, rustdoc,
 };
 
 mod diagnostics;
@@ -677,7 +679,7 @@ impl MaybeExported<'_> {
 /// Used for recording UnnecessaryQualification.
 #[derive(Debug)]
 pub(crate) struct UnnecessaryQualification<'ra> {
-    pub binding: LexicalScopeBinding<'ra>,
+    pub decl: LateDecl<'ra>,
     pub node_id: NodeId,
     pub path_span: Span,
     pub removal_span: Span,
@@ -1069,8 +1071,20 @@ impl<'ast, 'ra, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'ra, 'tc
         debug!("(resolving function) entering function");
 
         if let FnKind::Fn(_, _, f) = fn_kind {
-            for EiiImpl { node_id, eii_macro_path, .. } in &f.eii_impls {
-                self.smart_resolve_path(*node_id, &None, &eii_macro_path, PathSource::Macro);
+            for EiiImpl { node_id, eii_macro_path, known_eii_macro_resolution, .. } in &f.eii_impls
+            {
+                // See docs on the `known_eii_macro_resolution` field:
+                // if we already know the resolution statically, don't bother resolving it.
+                if let Some(target) = known_eii_macro_resolution {
+                    self.smart_resolve_path(
+                        *node_id,
+                        &None,
+                        &target.extern_item_path,
+                        PathSource::Expr(None),
+                    );
+                } else {
+                    self.smart_resolve_path(*node_id, &None, &eii_macro_path, PathSource::Macro);
+                }
             }
         }
 
@@ -1472,7 +1486,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         &mut self,
         ident: Ident,
         ns: Namespace,
-    ) -> Option<LexicalScopeBinding<'ra>> {
+    ) -> Option<LateDecl<'ra>> {
         self.r.resolve_ident_in_lexical_scope(
             ident,
             ns,
@@ -1489,15 +1503,15 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         ident: Ident,
         ns: Namespace,
         finalize: Option<Finalize>,
-        ignore_binding: Option<NameBinding<'ra>>,
-    ) -> Option<LexicalScopeBinding<'ra>> {
+        ignore_decl: Option<Decl<'ra>>,
+    ) -> Option<LateDecl<'ra>> {
         self.r.resolve_ident_in_lexical_scope(
             ident,
             ns,
             &self.parent_scope,
             finalize,
             &self.ribs[ns],
-            ignore_binding,
+            ignore_decl,
             Some(&self.diag_metadata),
         )
     }
@@ -1514,7 +1528,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             opt_ns,
             &self.parent_scope,
             Some(source),
-            finalize,
+            finalize.map(|finalize| Finalize { stage: Stage::Late, ..finalize }),
             Some(&self.ribs),
             None,
             None,
@@ -2655,11 +2669,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 |this| {
                     let item_def_id = this.r.local_def_id(item.id).to_def_id();
                     this.with_self_rib(
-                        Res::SelfTyAlias {
-                            alias_to: item_def_id,
-                            forbid_generic: false,
-                            is_trait_impl: false,
-                        },
+                        Res::SelfTyAlias { alias_to: item_def_id, is_trait_impl: false },
                         |this| {
                             visit::walk_item(this, item);
                         },
@@ -2689,11 +2699,11 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
             for &ns in nss {
                 match self.maybe_resolve_ident_in_lexical_scope(ident, ns) {
-                    Some(LexicalScopeBinding::Res(..)) => {
+                    Some(LateDecl::RibDef(..)) => {
                         report_error(self, ns);
                     }
-                    Some(LexicalScopeBinding::Item(binding)) => {
-                        if let Some(LexicalScopeBinding::Res(..)) =
+                    Some(LateDecl::Decl(binding)) => {
+                        if let Some(LateDecl::RibDef(..)) =
                             self.resolve_ident_in_lexical_scope(ident, ns, None, Some(binding))
                         {
                             report_error(self, ns);
@@ -2855,6 +2865,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 ref define_opaque,
                 ..
             }) => {
+                let is_type_const = attr::contains_name(&item.attrs, sym::type_const);
                 self.with_generic_param_rib(
                     &generics.params,
                     RibKind::Item(
@@ -2873,7 +2884,22 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
                         this.with_lifetime_rib(
                             LifetimeRibKind::Elided(LifetimeRes::Static),
-                            |this| this.visit_ty(ty),
+                            |this| {
+                                if is_type_const
+                                    && !this.r.tcx.features().generic_const_parameter_types()
+                                {
+                                    this.with_rib(TypeNS, RibKind::ConstParamTy, |this| {
+                                        this.with_rib(ValueNS, RibKind::ConstParamTy, |this| {
+                                            this.with_lifetime_rib(
+                                                LifetimeRibKind::ConstParamTy,
+                                                |this| this.visit_ty(ty),
+                                            )
+                                        })
+                                    });
+                                } else {
+                                    this.visit_ty(ty);
+                                }
+                            },
                         );
 
                         if let Some(rhs) = rhs {
@@ -2905,7 +2931,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     self.parent_scope.macro_rules = self.r.macro_rules_scopes[&def_id];
                 }
 
-                if let Some(EiiExternTarget { extern_item_path, impl_unsafe: _, span: _ }) =
+                if let Some(EiiExternTarget { extern_item_path, impl_unsafe: _ }) =
                     &macro_def.eii_extern_target
                 {
                     self.smart_resolve_path(
@@ -3213,6 +3239,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     define_opaque,
                     ..
                 }) => {
+                    let is_type_const = attr::contains_name(&item.attrs, sym::type_const);
                     self.with_generic_param_rib(
                         &generics.params,
                         RibKind::AssocItem,
@@ -3227,7 +3254,20 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                 },
                                 |this| {
                                     this.visit_generics(generics);
-                                    this.visit_ty(ty);
+                                    if is_type_const
+                                        && !this.r.tcx.features().generic_const_parameter_types()
+                                    {
+                                        this.with_rib(TypeNS, RibKind::ConstParamTy, |this| {
+                                            this.with_rib(ValueNS, RibKind::ConstParamTy, |this| {
+                                                this.with_lifetime_rib(
+                                                    LifetimeRibKind::ConstParamTy,
+                                                    |this| this.visit_ty(ty),
+                                                )
+                                            })
+                                        });
+                                    } else {
+                                        this.visit_ty(ty);
+                                    }
 
                                     // Only impose the restrictions of `ConstRibKind` for an
                                     // actual constant expression in a provided default.
@@ -3368,8 +3408,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                     let item_def_id = item_def_id.to_def_id();
                                     let res = Res::SelfTyAlias {
                                         alias_to: item_def_id,
-                                        forbid_generic: false,
-                                        is_trait_impl: trait_id.is_some()
+                                        is_trait_impl: trait_id.is_some(),
                                     };
                                     this.with_self_rib(res, |this| {
                                         if let Some(of_trait) = of_trait {
@@ -3422,6 +3461,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 ..
             }) => {
                 debug!("resolve_implementation AssocItemKind::Const");
+                let is_type_const = attr::contains_name(&item.attrs, sym::type_const);
                 self.with_generic_param_rib(
                     &generics.params,
                     RibKind::AssocItem,
@@ -3458,7 +3498,28 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                         );
 
                                         this.visit_generics(generics);
-                                        this.visit_ty(ty);
+                                        if is_type_const
+                                            && !this
+                                                .r
+                                                .tcx
+                                                .features()
+                                                .generic_const_parameter_types()
+                                        {
+                                            this.with_rib(TypeNS, RibKind::ConstParamTy, |this| {
+                                                this.with_rib(
+                                                    ValueNS,
+                                                    RibKind::ConstParamTy,
+                                                    |this| {
+                                                        this.with_lifetime_rib(
+                                                            LifetimeRibKind::ConstParamTy,
+                                                            |this| this.visit_ty(ty),
+                                                        )
+                                                    },
+                                                )
+                                            });
+                                        } else {
+                                            this.visit_ty(ty);
+                                        }
                                         if let Some(rhs) = rhs {
                                             // We allow arbitrary const expressions inside of associated consts,
                                             // even if they are potentially not const evaluatable.
@@ -3582,10 +3643,10 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             return;
         };
         ident.span.normalize_to_macros_2_0_and_adjust(module.expansion);
-        let key = BindingKey::new(ident, ns);
-        let mut binding = self.r.resolution(module, key).and_then(|r| r.best_binding());
-        debug!(?binding);
-        if binding.is_none() {
+        let key = BindingKey::new(Macros20NormalizedIdent::new(ident), ns);
+        let mut decl = self.r.resolution(module, key).and_then(|r| r.best_decl());
+        debug!(?decl);
+        if decl.is_none() {
             // We could not find the trait item in the correct namespace.
             // Check the other namespace to report an error.
             let ns = match ns {
@@ -3593,9 +3654,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 TypeNS => ValueNS,
                 _ => ns,
             };
-            let key = BindingKey::new(ident, ns);
-            binding = self.r.resolution(module, key).and_then(|r| r.best_binding());
-            debug!(?binding);
+            let key = BindingKey::new(Macros20NormalizedIdent::new(ident), ns);
+            decl = self.r.resolution(module, key).and_then(|r| r.best_decl());
+            debug!(?decl);
         }
 
         let feed_visibility = |this: &mut Self, def_id| {
@@ -3612,7 +3673,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             this.r.feed_visibility(this.r.feed(id), vis);
         };
 
-        let Some(binding) = binding else {
+        let Some(decl) = decl else {
             // We could not find the method: report an error.
             let candidate = self.find_similarly_named_assoc_item(ident.name, kind);
             let path = &self.current_trait_ref.as_ref().unwrap().1.path;
@@ -3622,7 +3683,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             return;
         };
 
-        let res = binding.res();
+        let res = decl.res();
         let Res::Def(def_kind, id_in_trait) = res else { bug!() };
         feed_visibility(self, id_in_trait);
 
@@ -3633,7 +3694,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     ResolutionError::TraitImplDuplicate {
                         name: ident,
                         old_span: *entry.get(),
-                        trait_item_span: binding.span,
+                        trait_item_span: decl.span,
                     },
                 );
                 return;
@@ -3673,7 +3734,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 kind,
                 code,
                 trait_path,
-                trait_item_span: binding.span,
+                trait_item_span: decl.span,
             },
         );
     }
@@ -4210,7 +4271,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
         let ls_binding = self.maybe_resolve_ident_in_lexical_scope(ident, ValueNS)?;
         let (res, binding) = match ls_binding {
-            LexicalScopeBinding::Item(binding)
+            LateDecl::Decl(binding)
                 if is_syntactic_ambiguity && binding.is_ambiguity_recursive() =>
             {
                 // For ambiguous bindings we don't know all their definitions and cannot check
@@ -4220,8 +4281,8 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.r.record_use(ident, binding, Used::Other);
                 return None;
             }
-            LexicalScopeBinding::Item(binding) => (binding.res(), Some(binding)),
-            LexicalScopeBinding::Res(res) => (res, None),
+            LateDecl::Decl(binding) => (binding.res(), Some(binding)),
+            LateDecl::RibDef(res) => (res, None),
         };
 
         match res {
@@ -4594,13 +4655,13 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     fn self_type_is_available(&mut self) -> bool {
         let binding = self
             .maybe_resolve_ident_in_lexical_scope(Ident::with_dummy_span(kw::SelfUpper), TypeNS);
-        if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
+        if let Some(LateDecl::RibDef(res)) = binding { res != Res::Err } else { false }
     }
 
     fn self_value_is_available(&mut self, self_span: Span) -> bool {
         let ident = Ident::new(kw::SelfLower, self_span);
         let binding = self.maybe_resolve_ident_in_lexical_scope(ident, ValueNS);
-        if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
+        if let Some(LateDecl::RibDef(res)) = binding { res != Res::Err } else { false }
     }
 
     /// A wrapper around [`Resolver::report_error`].
@@ -5309,9 +5370,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             (res == binding.res()).then_some((seg, binding))
         });
 
-        if let Some((seg, binding)) = unqualified {
+        if let Some((seg, decl)) = unqualified {
             self.r.potentially_unnecessary_qualifications.push(UnnecessaryQualification {
-                binding,
+                decl,
                 node_id: finalize.node_id,
                 path_span: finalize.path_span,
                 removal_span: path[0].ident.span.until(seg.ident.span),
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index f75ac400dc0b..a2805497e796 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -891,10 +891,8 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     fn lookup_doc_alias_name(&mut self, path: &[Segment], ns: Namespace) -> Option<(DefId, Ident)> {
         let find_doc_alias_name = |r: &mut Resolver<'ra, '_>, m: Module<'ra>, item_name: Symbol| {
             for resolution in r.resolutions(m).borrow().values() {
-                let Some(did) = resolution
-                    .borrow()
-                    .best_binding()
-                    .and_then(|binding| binding.res().opt_def_id())
+                let Some(did) =
+                    resolution.borrow().best_decl().and_then(|binding| binding.res().opt_def_id())
                 else {
                     continue;
                 };
@@ -1589,19 +1587,17 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             if let PathResult::Module(ModuleOrUniformRoot::Module(module)) =
                 self.resolve_path(mod_path, None, None, *source)
             {
-                let targets: Vec<_> = self
-                    .r
-                    .resolutions(module)
-                    .borrow()
-                    .iter()
-                    .filter_map(|(key, resolution)| {
-                        resolution
-                            .borrow()
-                            .best_binding()
-                            .map(|binding| binding.res())
-                            .and_then(|res| if filter_fn(res) { Some((*key, res)) } else { None })
-                    })
-                    .collect();
+                let targets: Vec<_> =
+                    self.r
+                        .resolutions(module)
+                        .borrow()
+                        .iter()
+                        .filter_map(|(key, resolution)| {
+                            resolution.borrow().best_decl().map(|binding| binding.res()).and_then(
+                                |res| if filter_fn(res) { Some((*key, res)) } else { None },
+                            )
+                        })
+                        .collect();
                 if let [target] = targets.as_slice() {
                     return Some(TypoSuggestion::single_item_from_ident(
                         target.0.ident.0,
@@ -2486,9 +2482,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             .resolutions(*module)
             .borrow()
             .iter()
-            .filter_map(|(key, res)| {
-                res.borrow().best_binding().map(|binding| (key, binding.res()))
-            })
+            .filter_map(|(key, res)| res.borrow().best_decl().map(|binding| (key, binding.res())))
             .filter(|(_, res)| match (kind, res) {
                 (AssocItemKind::Const(..), Res::Def(DefKind::AssocConst, _)) => true,
                 (AssocItemKind::Fn(_), Res::Def(DefKind::AssocFn, _)) => true,
@@ -2799,7 +2793,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
 
             in_module.for_each_child(self.r, |r, ident, _, name_binding| {
                 // abort if the module is already found or if name_binding is private external
-                if result.is_some() || !name_binding.vis.is_visible_locally() {
+                if result.is_some() || !name_binding.vis().is_visible_locally() {
                     return;
                 }
                 if let Some(module_def_id) = name_binding.res().module_like_def_id() {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 7cbf2088efce..d82fad3861d5 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -33,12 +33,12 @@ use std::sync::Arc;
 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
 use effective_visibilities::EffectiveVisibilitiesVisitor;
 use errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
-use imports::{Import, ImportData, ImportKind, NameResolution, PendingBinding};
+use imports::{Import, ImportData, ImportKind, NameResolution, PendingDecl};
 use late::{
     ForwardGenericParamBanReason, HasGenericParams, PathSource, PatternSource,
     UnnecessaryQualification,
 };
-use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
+use macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
 use rustc_arena::{DroplessArena, TypedArena};
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::{
@@ -123,10 +123,14 @@ enum Scope<'ra> {
     DeriveHelpersCompat,
     /// Textual `let`-like scopes introduced by `macro_rules!` items.
     MacroRules(MacroRulesScopeRef<'ra>),
-    /// Names declared in the given module.
+    /// Non-glob names declared in the given module.
     /// The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
     /// lint if it should be reported.
-    Module(Module<'ra>, Option<NodeId>),
+    ModuleNonGlobs(Module<'ra>, Option<NodeId>),
+    /// Glob names declared in the given module.
+    /// The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
+    /// lint if it should be reported.
+    ModuleGlobs(Module<'ra>, Option<NodeId>),
     /// Names introduced by `#[macro_use]` attributes on `extern crate` items.
     MacroUsePrelude,
     /// Built-in attributes.
@@ -149,6 +153,8 @@ enum Scope<'ra> {
 enum ScopeSet<'ra> {
     /// All scopes with the given namespace.
     All(Namespace),
+    /// Two scopes inside a module, for non-glob and glob bindings.
+    Module(Namespace, Module<'ra>),
     /// A module, then extern prelude (used for mixed 2015-2018 mode in macros).
     ModuleAndExternPrelude(Namespace, Module<'ra>),
     /// Just two extern prelude scopes.
@@ -418,22 +424,21 @@ impl<'a> From<&'a ast::PathSegment> for Segment {
     }
 }
 
-/// An intermediate resolution result.
-///
-/// This refers to the thing referred by a name. The difference between `Res` and `Item` is that
-/// items are visible in their whole block, while `Res`es only from the place they are defined
-/// forward.
+/// Name declaration used during late resolution.
 #[derive(Debug, Copy, Clone)]
-enum LexicalScopeBinding<'ra> {
-    Item(NameBinding<'ra>),
-    Res(Res),
+enum LateDecl<'ra> {
+    /// A regular name declaration.
+    Decl(Decl<'ra>),
+    /// A name definition from a rib, e.g. a local variable.
+    /// Omits most of the data from regular `Decl` for performance reasons.
+    RibDef(Res),
 }
 
-impl<'ra> LexicalScopeBinding<'ra> {
+impl<'ra> LateDecl<'ra> {
     fn res(self) -> Res {
         match self {
-            LexicalScopeBinding::Item(binding) => binding.res(),
-            LexicalScopeBinding::Res(res) => res,
+            LateDecl::Decl(binding) => binding.res(),
+            LateDecl::RibDef(res) => res,
         }
     }
 }
@@ -567,17 +572,17 @@ struct BindingKey {
 }
 
 impl BindingKey {
-    fn new(ident: Ident, ns: Namespace) -> Self {
-        BindingKey { ident: Macros20NormalizedIdent::new(ident), ns, disambiguator: 0 }
+    fn new(ident: Macros20NormalizedIdent, ns: Namespace) -> Self {
+        BindingKey { ident, ns, disambiguator: 0 }
     }
 
     fn new_disambiguated(
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         ns: Namespace,
         disambiguator: impl FnOnce() -> u32,
     ) -> BindingKey {
         let disambiguator = if ident.name == kw::Underscore { disambiguator() } else { 0 };
-        BindingKey { ident: Macros20NormalizedIdent::new(ident), ns, disambiguator }
+        BindingKey { ident, ns, disambiguator }
     }
 }
 
@@ -618,17 +623,16 @@ struct ModuleData<'ra> {
     globs: CmRefCell<Vec<Import<'ra>>>,
 
     /// Used to memoize the traits in this module for faster searches through all traits in scope.
-    traits:
-        CmRefCell<Option<Box<[(Macros20NormalizedIdent, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
+    traits: CmRefCell<Option<Box<[(Macros20NormalizedIdent, Decl<'ra>, Option<Module<'ra>>)]>>>,
 
     /// Span of the module itself. Used for error reporting.
     span: Span,
 
     expansion: ExpnId,
 
-    /// Binding for implicitly declared names that come with a module,
+    /// Declaration for implicitly declared names that come with a module,
     /// like `self` (not yet used), or `crate`/`$crate` (for root modules).
-    self_binding: Option<NameBinding<'ra>>,
+    self_decl: Option<Decl<'ra>>,
 }
 
 /// All modules are unique and allocated on a same arena,
@@ -657,7 +661,7 @@ impl<'ra> ModuleData<'ra> {
         expansion: ExpnId,
         span: Span,
         no_implicit_prelude: bool,
-        self_binding: Option<NameBinding<'ra>>,
+        self_decl: Option<Decl<'ra>>,
     ) -> Self {
         let is_foreign = match kind {
             ModuleKind::Def(_, def_id, _) => !def_id.is_local(),
@@ -676,7 +680,7 @@ impl<'ra> ModuleData<'ra> {
             traits: CmRefCell::new(None),
             span,
             expansion,
-            self_binding,
+            self_decl,
         }
     }
 }
@@ -685,11 +689,11 @@ impl<'ra> Module<'ra> {
     fn for_each_child<'tcx, R: AsRef<Resolver<'ra, 'tcx>>>(
         self,
         resolver: &R,
-        mut f: impl FnMut(&R, Macros20NormalizedIdent, Namespace, NameBinding<'ra>),
+        mut f: impl FnMut(&R, Macros20NormalizedIdent, Namespace, Decl<'ra>),
     ) {
         for (key, name_resolution) in resolver.as_ref().resolutions(self).borrow().iter() {
-            if let Some(binding) = name_resolution.borrow().best_binding() {
-                f(resolver, key.ident, key.ns, binding);
+            if let Some(decl) = name_resolution.borrow().best_decl() {
+                f(resolver, key.ident, key.ns, decl);
             }
         }
     }
@@ -697,11 +701,11 @@ impl<'ra> Module<'ra> {
     fn for_each_child_mut<'tcx, R: AsMut<Resolver<'ra, 'tcx>>>(
         self,
         resolver: &mut R,
-        mut f: impl FnMut(&mut R, Macros20NormalizedIdent, Namespace, NameBinding<'ra>),
+        mut f: impl FnMut(&mut R, Macros20NormalizedIdent, Namespace, Decl<'ra>),
     ) {
         for (key, name_resolution) in resolver.as_mut().resolutions(self).borrow().iter() {
-            if let Some(binding) = name_resolution.borrow().best_binding() {
-                f(resolver, key.ident, key.ns, binding);
+            if let Some(decl) = name_resolution.borrow().best_decl() {
+                f(resolver, key.ident, key.ns, decl);
             }
         }
     }
@@ -797,28 +801,28 @@ impl<'ra> fmt::Debug for Module<'ra> {
     }
 }
 
-/// Records a possibly-private value, type, or module definition.
-#[derive(Clone, Copy, Debug)]
-struct NameBindingData<'ra> {
-    kind: NameBindingKind<'ra>,
-    ambiguity: Option<(NameBinding<'ra>, AmbiguityKind)>,
+/// Data associated with any name declaration.
+#[derive(Clone, Debug)]
+struct DeclData<'ra> {
+    kind: DeclKind<'ra>,
+    ambiguity: CmCell<Option<Decl<'ra>>>,
     /// Produce a warning instead of an error when reporting ambiguities inside this binding.
     /// May apply to indirect ambiguities under imports, so `ambiguity.is_some()` is not required.
-    warn_ambiguity: bool,
+    warn_ambiguity: CmCell<bool>,
     expansion: LocalExpnId,
     span: Span,
-    vis: Visibility<DefId>,
+    vis: CmCell<Visibility<DefId>>,
 }
 
-/// All name bindings are unique and allocated on a same arena,
+/// All name declarations are unique and allocated on a same arena,
 /// so we can use referential equality to compare them.
-type NameBinding<'ra> = Interned<'ra, NameBindingData<'ra>>;
+type Decl<'ra> = Interned<'ra, DeclData<'ra>>;
 
 // Allows us to use Interned without actually enforcing (via Hash/PartialEq/...) uniqueness of the
 // contained data.
 // FIXME: We may wish to actually have at least debug-level assertions that Interned's guarantees
 // are upheld.
-impl std::hash::Hash for NameBindingData<'_> {
+impl std::hash::Hash for DeclData<'_> {
     fn hash<H>(&self, _: &mut H)
     where
         H: std::hash::Hasher,
@@ -827,23 +831,27 @@ impl std::hash::Hash for NameBindingData<'_> {
     }
 }
 
+/// Name declaration kind.
 #[derive(Clone, Copy, Debug)]
-enum NameBindingKind<'ra> {
-    Res(Res),
-    Import { binding: NameBinding<'ra>, import: Import<'ra> },
+enum DeclKind<'ra> {
+    /// The name declaration is a definition (possibly without a `DefId`),
+    /// can be provided by source code or built into the language.
+    Def(Res),
+    /// The name declaration is a link to another name declaration.
+    Import { source_decl: Decl<'ra>, import: Import<'ra> },
 }
 
-impl<'ra> NameBindingKind<'ra> {
-    /// Is this a name binding of an import?
+impl<'ra> DeclKind<'ra> {
+    /// Is this an import declaration?
     fn is_import(&self) -> bool {
-        matches!(*self, NameBindingKind::Import { .. })
+        matches!(*self, DeclKind::Import { .. })
     }
 }
 
 #[derive(Debug)]
 struct PrivacyError<'ra> {
     ident: Ident,
-    binding: NameBinding<'ra>,
+    decl: Decl<'ra>,
     dedup_span: Span,
     outermost_res: Option<(Res, Ident)>,
     parent_scope: ParentScope<'ra>,
@@ -906,92 +914,93 @@ impl AmbiguityKind {
 struct AmbiguityError<'ra> {
     kind: AmbiguityKind,
     ident: Ident,
-    b1: NameBinding<'ra>,
-    b2: NameBinding<'ra>,
+    b1: Decl<'ra>,
+    b2: Decl<'ra>,
     // `empty_module` in module scope serves as an unknown module here.
     scope1: Scope<'ra>,
     scope2: Scope<'ra>,
     warning: bool,
 }
 
-impl<'ra> NameBindingData<'ra> {
+impl<'ra> DeclData<'ra> {
+    fn vis(&self) -> Visibility<DefId> {
+        self.vis.get()
+    }
+
     fn res(&self) -> Res {
         match self.kind {
-            NameBindingKind::Res(res) => res,
-            NameBindingKind::Import { binding, .. } => binding.res(),
+            DeclKind::Def(res) => res,
+            DeclKind::Import { source_decl, .. } => source_decl.res(),
         }
     }
 
-    fn import_source(&self) -> NameBinding<'ra> {
+    fn import_source(&self) -> Decl<'ra> {
         match self.kind {
-            NameBindingKind::Import { binding, .. } => binding,
+            DeclKind::Import { source_decl, .. } => source_decl,
             _ => unreachable!(),
         }
     }
 
-    fn descent_to_ambiguity(
-        self: NameBinding<'ra>,
-    ) -> Option<(NameBinding<'ra>, NameBinding<'ra>, AmbiguityKind)> {
-        match self.ambiguity {
-            Some((ambig_binding, ambig_kind)) => Some((self, ambig_binding, ambig_kind)),
+    fn descent_to_ambiguity(self: Decl<'ra>) -> Option<(Decl<'ra>, Decl<'ra>)> {
+        match self.ambiguity.get() {
+            Some(ambig_binding) => Some((self, ambig_binding)),
             None => match self.kind {
-                NameBindingKind::Import { binding, .. } => binding.descent_to_ambiguity(),
+                DeclKind::Import { source_decl, .. } => source_decl.descent_to_ambiguity(),
                 _ => None,
             },
         }
     }
 
     fn is_ambiguity_recursive(&self) -> bool {
-        self.ambiguity.is_some()
+        self.ambiguity.get().is_some()
             || match self.kind {
-                NameBindingKind::Import { binding, .. } => binding.is_ambiguity_recursive(),
+                DeclKind::Import { source_decl, .. } => source_decl.is_ambiguity_recursive(),
                 _ => false,
             }
     }
 
     fn warn_ambiguity_recursive(&self) -> bool {
-        self.warn_ambiguity
+        self.warn_ambiguity.get()
             || match self.kind {
-                NameBindingKind::Import { binding, .. } => binding.warn_ambiguity_recursive(),
+                DeclKind::Import { source_decl, .. } => source_decl.warn_ambiguity_recursive(),
                 _ => false,
             }
     }
 
     fn is_possibly_imported_variant(&self) -> bool {
         match self.kind {
-            NameBindingKind::Import { binding, .. } => binding.is_possibly_imported_variant(),
-            NameBindingKind::Res(Res::Def(
-                DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..),
-                _,
-            )) => true,
-            NameBindingKind::Res(..) => false,
+            DeclKind::Import { source_decl, .. } => source_decl.is_possibly_imported_variant(),
+            DeclKind::Def(Res::Def(DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..), _)) => {
+                true
+            }
+            DeclKind::Def(..) => false,
         }
     }
 
     fn is_extern_crate(&self) -> bool {
         match self.kind {
-            NameBindingKind::Import { import, .. } => {
+            DeclKind::Import { import, .. } => {
                 matches!(import.kind, ImportKind::ExternCrate { .. })
             }
-            NameBindingKind::Res(Res::Def(_, def_id)) => def_id.is_crate_root(),
+            DeclKind::Def(Res::Def(_, def_id)) => def_id.is_crate_root(),
             _ => false,
         }
     }
 
     fn is_import(&self) -> bool {
-        matches!(self.kind, NameBindingKind::Import { .. })
+        matches!(self.kind, DeclKind::Import { .. })
     }
 
     /// The binding introduced by `#[macro_export] macro_rules` is a public import, but it might
     /// not be perceived as such by users, so treat it as a non-import in some diagnostics.
     fn is_import_user_facing(&self) -> bool {
-        matches!(self.kind, NameBindingKind::Import { import, .. }
+        matches!(self.kind, DeclKind::Import { import, .. }
             if !matches!(import.kind, ImportKind::MacroExport))
     }
 
     fn is_glob_import(&self) -> bool {
         match self.kind {
-            NameBindingKind::Import { import, .. } => import.is_glob(),
+            DeclKind::Import { import, .. } => import.is_glob(),
             _ => false,
         }
     }
@@ -1004,12 +1013,12 @@ impl<'ra> NameBindingData<'ra> {
         self.res().macro_kinds()
     }
 
-    fn reexport_chain(self: NameBinding<'ra>, r: &Resolver<'_, '_>) -> SmallVec<[Reexport; 2]> {
+    fn reexport_chain(self: Decl<'ra>, r: &Resolver<'_, '_>) -> SmallVec<[Reexport; 2]> {
         let mut reexport_chain = SmallVec::new();
         let mut next_binding = self;
-        while let NameBindingKind::Import { binding, import, .. } = next_binding.kind {
+        while let DeclKind::Import { source_decl, import, .. } = next_binding.kind {
             reexport_chain.push(import.simplify(r));
-            next_binding = binding;
+            next_binding = source_decl;
         }
         reexport_chain
     }
@@ -1020,16 +1029,12 @@ impl<'ra> NameBindingData<'ra> {
     // in some later round and screw up our previously found resolution.
     // See more detailed explanation in
     // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
-    fn may_appear_after(
-        &self,
-        invoc_parent_expansion: LocalExpnId,
-        binding: NameBinding<'_>,
-    ) -> bool {
-        // self > max(invoc, binding) => !(self <= invoc || self <= binding)
+    fn may_appear_after(&self, invoc_parent_expansion: LocalExpnId, decl: Decl<'_>) -> bool {
+        // self > max(invoc, decl) => !(self <= invoc || self <= decl)
         // Expansions are partially ordered, so "may appear after" is an inversion of
         // "certainly appears before or simultaneously" and includes unordered cases.
         let self_parent_expansion = self.expansion;
-        let other_parent_expansion = binding.expansion;
+        let other_parent_expansion = decl.expansion;
         let certainly_before_other_or_simultaneously =
             other_parent_expansion.is_descendant_of(self_parent_expansion);
         let certainly_before_invoc_or_simultaneously =
@@ -1042,9 +1047,9 @@ impl<'ra> NameBindingData<'ra> {
     // FIXME: How can we integrate it with the `update_resolution`?
     fn determined(&self) -> bool {
         match &self.kind {
-            NameBindingKind::Import { binding, import, .. } if import.is_glob() => {
+            DeclKind::Import { source_decl, import, .. } if import.is_glob() => {
                 import.parent_scope.module.unexpanded_invocations.borrow().is_empty()
-                    && binding.determined()
+                    && source_decl.determined()
             }
             _ => true,
         }
@@ -1052,30 +1057,30 @@ impl<'ra> NameBindingData<'ra> {
 }
 
 struct ExternPreludeEntry<'ra> {
-    /// Binding from an `extern crate` item.
-    /// The boolean flag is true is `item_binding` is non-redundant, happens either when
-    /// `flag_binding` is `None`, or when `extern crate` introducing `item_binding` used renaming.
-    item_binding: Option<(NameBinding<'ra>, /* introduced by item */ bool)>,
-    /// Binding from an `--extern` flag, lazily populated on first use.
-    flag_binding: Option<CacheCell<(PendingBinding<'ra>, /* finalized */ bool)>>,
+    /// Name declaration from an `extern crate` item.
+    /// The boolean flag is true is `item_decl` is non-redundant, happens either when
+    /// `flag_decl` is `None`, or when `extern crate` introducing `item_decl` used renaming.
+    item_decl: Option<(Decl<'ra>, /* introduced by item */ bool)>,
+    /// Name declaration from an `--extern` flag, lazily populated on first use.
+    flag_decl: Option<CacheCell<(PendingDecl<'ra>, /* finalized */ bool)>>,
 }
 
 impl ExternPreludeEntry<'_> {
     fn introduced_by_item(&self) -> bool {
-        matches!(self.item_binding, Some((_, true)))
+        matches!(self.item_decl, Some((_, true)))
     }
 
     fn flag() -> Self {
         ExternPreludeEntry {
-            item_binding: None,
-            flag_binding: Some(CacheCell::new((PendingBinding::Pending, false))),
+            item_decl: None,
+            flag_decl: Some(CacheCell::new((PendingDecl::Pending, false))),
         }
     }
 }
 
 struct DeriveData {
     resolutions: Vec<DeriveResolution>,
-    helper_attrs: Vec<(usize, Ident)>,
+    helper_attrs: Vec<(usize, Macros20NormalizedIdent)>,
     has_derive_copy: bool,
 }
 
@@ -1175,7 +1180,7 @@ pub struct Resolver<'ra, 'tcx> {
     local_module_map: FxIndexMap<LocalDefId, Module<'ra>>,
     /// Lazily populated cache of modules loaded from external crates.
     extern_module_map: CacheRefCell<FxIndexMap<DefId, Module<'ra>>>,
-    binding_parent_modules: FxHashMap<NameBinding<'ra>, Module<'ra>>,
+    decl_parent_modules: FxHashMap<Decl<'ra>, Module<'ra>>,
 
     /// Maps glob imports to the names of items actually imported.
     glob_map: FxIndexMap<LocalDefId, FxIndexSet<Symbol>>,
@@ -1200,14 +1205,14 @@ pub struct Resolver<'ra, 'tcx> {
     inaccessible_ctor_reexport: FxHashMap<Span, Span>,
 
     arenas: &'ra ResolverArenas<'ra>,
-    dummy_binding: NameBinding<'ra>,
-    builtin_types_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
-    builtin_attrs_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
-    registered_tool_bindings: FxHashMap<Ident, NameBinding<'ra>>,
+    dummy_decl: Decl<'ra>,
+    builtin_type_decls: FxHashMap<Symbol, Decl<'ra>>,
+    builtin_attr_decls: FxHashMap<Symbol, Decl<'ra>>,
+    registered_tool_decls: FxHashMap<Ident, Decl<'ra>>,
     macro_names: FxHashSet<Ident>,
     builtin_macros: FxHashMap<Symbol, SyntaxExtensionKind>,
     registered_tools: &'tcx RegisteredTools,
-    macro_use_prelude: FxIndexMap<Symbol, NameBinding<'ra>>,
+    macro_use_prelude: FxIndexMap<Symbol, Decl<'ra>>,
     /// Eagerly populated map of all local macro definitions.
     local_macro_map: FxHashMap<LocalDefId, &'ra MacroData>,
     /// Lazily populated cache of macro definitions loaded from external crates.
@@ -1223,7 +1228,7 @@ pub struct Resolver<'ra, 'tcx> {
     proc_macro_stubs: FxHashSet<LocalDefId>,
     /// Traces collected during macro resolution and validated when it's complete.
     single_segment_macro_resolutions:
-        CmRefCell<Vec<(Ident, MacroKind, ParentScope<'ra>, Option<NameBinding<'ra>>, Option<Span>)>>,
+        CmRefCell<Vec<(Ident, MacroKind, ParentScope<'ra>, Option<Decl<'ra>>, Option<Span>)>>,
     multi_segment_macro_resolutions:
         CmRefCell<Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'ra>, Option<Res>, Namespace)>>,
     builtin_attrs: Vec<(Ident, ParentScope<'ra>)>,
@@ -1240,7 +1245,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// `macro_rules` scopes produced by `macro_rules` item definitions.
     macro_rules_scopes: FxHashMap<LocalDefId, MacroRulesScopeRef<'ra>>,
     /// Helper attributes that are in scope for the given expansion.
-    helper_attrs: FxHashMap<LocalExpnId, Vec<(Ident, NameBinding<'ra>)>>,
+    helper_attrs: FxHashMap<LocalExpnId, Vec<(Macros20NormalizedIdent, Decl<'ra>)>>,
     /// Ready or in-progress results of resolving paths inside the `#[derive(...)]` attribute
     /// with the given `ExpnId`.
     derive_data: FxHashMap<LocalExpnId, DeriveData>,
@@ -1332,30 +1337,25 @@ pub struct ResolverArenas<'ra> {
 }
 
 impl<'ra> ResolverArenas<'ra> {
-    fn new_res_binding(
+    fn new_def_decl(
         &'ra self,
         res: Res,
         vis: Visibility<DefId>,
         span: Span,
         expansion: LocalExpnId,
-    ) -> NameBinding<'ra> {
-        self.alloc_name_binding(NameBindingData {
-            kind: NameBindingKind::Res(res),
-            ambiguity: None,
-            warn_ambiguity: false,
-            vis,
+    ) -> Decl<'ra> {
+        self.alloc_decl(DeclData {
+            kind: DeclKind::Def(res),
+            ambiguity: CmCell::new(None),
+            warn_ambiguity: CmCell::new(false),
+            vis: CmCell::new(vis),
             span,
             expansion,
         })
     }
 
-    fn new_pub_res_binding(
-        &'ra self,
-        res: Res,
-        span: Span,
-        expn_id: LocalExpnId,
-    ) -> NameBinding<'ra> {
-        self.new_res_binding(res, Visibility::Public, span, expn_id)
+    fn new_pub_def_decl(&'ra self, res: Res, span: Span, expn_id: LocalExpnId) -> Decl<'ra> {
+        self.new_def_decl(res, Visibility::Public, span, expn_id)
     }
 
     fn new_module(
@@ -1366,9 +1366,9 @@ impl<'ra> ResolverArenas<'ra> {
         span: Span,
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
-        let self_binding = match kind {
+        let self_decl = match kind {
             ModuleKind::Def(def_kind, def_id, _) => {
-                Some(self.new_pub_res_binding(Res::Def(def_kind, def_id), span, LocalExpnId::ROOT))
+                Some(self.new_pub_def_decl(Res::Def(def_kind, def_id), span, LocalExpnId::ROOT))
             }
             ModuleKind::Block => None,
         };
@@ -1378,11 +1378,11 @@ impl<'ra> ResolverArenas<'ra> {
             expn_id,
             span,
             no_implicit_prelude,
-            self_binding,
+            self_decl,
         ))))
     }
-    fn alloc_name_binding(&'ra self, name_binding: NameBindingData<'ra>) -> NameBinding<'ra> {
-        Interned::new_unchecked(self.dropless.alloc(name_binding))
+    fn alloc_decl(&'ra self, data: DeclData<'ra>) -> Decl<'ra> {
+        Interned::new_unchecked(self.dropless.alloc(data))
     }
     fn alloc_import(&'ra self, import: ImportData<'ra>) -> Import<'ra> {
         Interned::new_unchecked(self.imports.alloc(import))
@@ -1393,11 +1393,8 @@ impl<'ra> ResolverArenas<'ra> {
     fn alloc_macro_rules_scope(&'ra self, scope: MacroRulesScope<'ra>) -> MacroRulesScopeRef<'ra> {
         self.dropless.alloc(CacheCell::new(scope))
     }
-    fn alloc_macro_rules_binding(
-        &'ra self,
-        binding: MacroRulesBinding<'ra>,
-    ) -> &'ra MacroRulesBinding<'ra> {
-        self.dropless.alloc(binding)
+    fn alloc_macro_rules_decl(&'ra self, decl: MacroRulesDecl<'ra>) -> &'ra MacroRulesDecl<'ra> {
+        self.dropless.alloc(decl)
     }
     fn alloc_ast_paths(&'ra self, paths: &[ast::Path]) -> &'ra [ast::Path] {
         self.ast_paths.alloc_from_iter(paths.iter().cloned())
@@ -1613,7 +1610,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             local_module_map,
             extern_module_map: Default::default(),
             block_map: Default::default(),
-            binding_parent_modules: FxHashMap::default(),
+            decl_parent_modules: FxHashMap::default(),
             ast_transform_scopes: FxHashMap::default(),
 
             glob_map: Default::default(),
@@ -1622,29 +1619,29 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             inaccessible_ctor_reexport: Default::default(),
 
             arenas,
-            dummy_binding: arenas.new_pub_res_binding(Res::Err, DUMMY_SP, LocalExpnId::ROOT),
-            builtin_types_bindings: PrimTy::ALL
+            dummy_decl: arenas.new_pub_def_decl(Res::Err, DUMMY_SP, LocalExpnId::ROOT),
+            builtin_type_decls: PrimTy::ALL
                 .iter()
                 .map(|prim_ty| {
                     let res = Res::PrimTy(*prim_ty);
-                    let binding = arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT);
-                    (prim_ty.name(), binding)
+                    let decl = arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT);
+                    (prim_ty.name(), decl)
                 })
                 .collect(),
-            builtin_attrs_bindings: BUILTIN_ATTRIBUTES
+            builtin_attr_decls: BUILTIN_ATTRIBUTES
                 .iter()
                 .map(|builtin_attr| {
                     let res = Res::NonMacroAttr(NonMacroAttrKind::Builtin(builtin_attr.name));
-                    let binding = arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT);
-                    (builtin_attr.name, binding)
+                    let decl = arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT);
+                    (builtin_attr.name, decl)
                 })
                 .collect(),
-            registered_tool_bindings: registered_tools
+            registered_tool_decls: registered_tools
                 .iter()
                 .map(|ident| {
                     let res = Res::ToolMod;
-                    let binding = arenas.new_pub_res_binding(res, ident.span, LocalExpnId::ROOT);
-                    (*ident, binding)
+                    let decl = arenas.new_pub_def_decl(res, ident.span, LocalExpnId::ROOT);
+                    (*ident, decl)
                 })
                 .collect(),
             macro_names: FxHashSet::default(),
@@ -1926,9 +1923,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let scope_set = ScopeSet::All(TypeNS);
         self.cm().visit_scopes(scope_set, parent_scope, ctxt, None, |this, scope, _, _| {
             match scope {
-                Scope::Module(module, _) => {
+                Scope::ModuleNonGlobs(module, _) => {
                     this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
                 }
+                Scope::ModuleGlobs(..) => {
+                    // Already handled in `ModuleNonGlobs` (but see #144993).
+                }
                 Scope::StdLibPrelude => {
                     if let Some(module) = this.prelude {
                         this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
@@ -1985,18 +1985,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     fn find_transitive_imports(
         &mut self,
-        mut kind: &NameBindingKind<'_>,
+        mut kind: &DeclKind<'_>,
         trait_name: Ident,
     ) -> SmallVec<[LocalDefId; 1]> {
         let mut import_ids = smallvec![];
-        while let NameBindingKind::Import { import, binding, .. } = kind {
+        while let DeclKind::Import { import, source_decl, .. } = kind {
             if let Some(node_id) = import.id() {
                 let def_id = self.local_def_id(node_id);
                 self.maybe_unused_trait_imports.insert(def_id);
                 import_ids.push(def_id);
             }
             self.add_to_glob_map(*import, trait_name);
-            kind = &binding.kind;
+            kind = &source_decl.kind;
         }
         import_ids
     }
@@ -2044,25 +2044,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         false
     }
 
-    fn record_use(&mut self, ident: Ident, used_binding: NameBinding<'ra>, used: Used) {
-        self.record_use_inner(ident, used_binding, used, used_binding.warn_ambiguity);
+    fn record_use(&mut self, ident: Ident, used_decl: Decl<'ra>, used: Used) {
+        self.record_use_inner(ident, used_decl, used, used_decl.warn_ambiguity.get());
     }
 
     fn record_use_inner(
         &mut self,
         ident: Ident,
-        used_binding: NameBinding<'ra>,
+        used_decl: Decl<'ra>,
         used: Used,
         warn_ambiguity: bool,
     ) {
-        if let Some((b2, kind)) = used_binding.ambiguity {
+        if let Some(b2) = used_decl.ambiguity.get() {
             let ambiguity_error = AmbiguityError {
-                kind,
+                kind: AmbiguityKind::GlobVsGlob,
                 ident,
-                b1: used_binding,
+                b1: used_decl,
                 b2,
-                scope1: Scope::Module(self.empty_module, None),
-                scope2: Scope::Module(self.empty_module, None),
+                scope1: Scope::ModuleGlobs(self.empty_module, None),
+                scope2: Scope::ModuleGlobs(self.empty_module, None),
                 warning: warn_ambiguity,
             };
             if !self.matches_previous_ambiguity_error(&ambiguity_error) {
@@ -2070,7 +2070,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 self.ambiguity_errors.push(ambiguity_error);
             }
         }
-        if let NameBindingKind::Import { import, binding } = used_binding.kind {
+        if let DeclKind::Import { import, source_decl } = used_decl.kind {
             if let ImportKind::MacroUse { warn_private: true } = import.kind {
                 // Do not report the lint if the macro name resolves in stdlib prelude
                 // even without the problematic `macro_use` import.
@@ -2100,7 +2100,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // but not introduce it, as used if they are accessed from lexical scope.
             if used == Used::Scope
                 && let Some(entry) = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident))
-                && entry.item_binding == Some((used_binding, false))
+                && entry.item_decl == Some((used_decl, false))
             {
                 return;
             }
@@ -2114,9 +2114,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             self.add_to_glob_map(import, ident);
             self.record_use_inner(
                 ident,
-                binding,
+                source_decl,
                 Used::Other,
-                warn_ambiguity || binding.warn_ambiguity,
+                warn_ambiguity || source_decl.warn_ambiguity.get(),
             );
         }
     }
@@ -2227,18 +2227,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         vis.is_accessible_from(module.nearest_parent_mod(), self.tcx)
     }
 
-    fn set_binding_parent_module(&mut self, binding: NameBinding<'ra>, module: Module<'ra>) {
-        if let Some(old_module) = self.binding_parent_modules.insert(binding, module) {
+    fn set_decl_parent_module(&mut self, decl: Decl<'ra>, module: Module<'ra>) {
+        if let Some(old_module) = self.decl_parent_modules.insert(decl, module) {
             if module != old_module {
-                span_bug!(binding.span, "parent module is reset for binding");
+                span_bug!(decl.span, "parent module is reset for a name declaration");
             }
         }
     }
 
     fn disambiguate_macro_rules_vs_modularized(
         &self,
-        macro_rules: NameBinding<'ra>,
-        modularized: NameBinding<'ra>,
+        macro_rules: Decl<'ra>,
+        modularized: Decl<'ra>,
     ) -> bool {
         // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
         // is disambiguated to mitigate regressions from macro modularization.
@@ -2247,38 +2247,42 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // panic on index should be impossible, the only name_bindings passed in should be from
         // `resolve_ident_in_scope_set` which will always refer to a local binding from an
         // import or macro definition
-        let macro_rules = &self.binding_parent_modules[&macro_rules];
-        let modularized = &self.binding_parent_modules[&modularized];
+        let macro_rules = &self.decl_parent_modules[&macro_rules];
+        let modularized = &self.decl_parent_modules[&modularized];
         macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
             && modularized.is_ancestor_of(*macro_rules)
     }
 
     fn extern_prelude_get_item<'r>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
-        ident: Ident,
+        ident: Macros20NormalizedIdent,
         finalize: bool,
-    ) -> Option<NameBinding<'ra>> {
-        let entry = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident));
-        entry.and_then(|entry| entry.item_binding).map(|(binding, _)| {
+    ) -> Option<Decl<'ra>> {
+        let entry = self.extern_prelude.get(&ident);
+        entry.and_then(|entry| entry.item_decl).map(|(decl, _)| {
             if finalize {
-                self.get_mut().record_use(ident, binding, Used::Scope);
+                self.get_mut().record_use(ident.0, decl, Used::Scope);
             }
-            binding
+            decl
         })
     }
 
-    fn extern_prelude_get_flag(&self, ident: Ident, finalize: bool) -> Option<NameBinding<'ra>> {
-        let entry = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident));
-        entry.and_then(|entry| entry.flag_binding.as_ref()).and_then(|flag_binding| {
-            let (pending_binding, finalized) = flag_binding.get();
-            let binding = match pending_binding {
-                PendingBinding::Ready(binding) => {
+    fn extern_prelude_get_flag(
+        &self,
+        ident: Macros20NormalizedIdent,
+        finalize: bool,
+    ) -> Option<Decl<'ra>> {
+        let entry = self.extern_prelude.get(&ident);
+        entry.and_then(|entry| entry.flag_decl.as_ref()).and_then(|flag_decl| {
+            let (pending_decl, finalized) = flag_decl.get();
+            let decl = match pending_decl {
+                PendingDecl::Ready(decl) => {
                     if finalize && !finalized {
                         self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span);
                     }
-                    binding
+                    decl
                 }
-                PendingBinding::Pending => {
+                PendingDecl::Pending => {
                     debug_assert!(!finalized);
                     let crate_id = if finalize {
                         self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span)
@@ -2287,12 +2291,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     };
                     crate_id.map(|crate_id| {
                         let res = Res::Def(DefKind::Mod, crate_id.as_def_id());
-                        self.arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT)
+                        self.arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT)
                     })
                 }
             };
-            flag_binding.set((PendingBinding::Ready(binding), finalize || finalized));
-            binding.or_else(|| finalize.then_some(self.dummy_binding))
+            flag_decl.set((PendingDecl::Ready(decl), finalize || finalized));
+            decl.or_else(|| finalize.then_some(self.dummy_decl))
         })
     }
 
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 6bba985d87dd..32d686d4f702 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -29,7 +29,7 @@ use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::{self, AstPass, ExpnData, ExpnKind, LocalExpnId, MacroKind};
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, Macros20NormalizedIdent, Span, Symbol, kw, sym};
 
 use crate::Namespace::*;
 use crate::errors::{
@@ -38,21 +38,21 @@ use crate::errors::{
 };
 use crate::imports::Import;
 use crate::{
-    BindingKey, CacheCell, CmResolver, DeriveData, Determinacy, Finalize, InvocationParent,
-    MacroData, ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope,
-    PathResult, ResolutionError, Resolver, ScopeSet, Segment, Used,
+    BindingKey, CacheCell, CmResolver, Decl, DeclKind, DeriveData, Determinacy, Finalize,
+    InvocationParent, MacroData, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult,
+    ResolutionError, Resolver, ScopeSet, Segment, Used,
 };
 
 type Res = def::Res<NodeId>;
 
-/// Binding produced by a `macro_rules` item.
-/// Not modularized, can shadow previous `macro_rules` bindings, etc.
+/// Name declaration produced by a `macro_rules` item definition.
+/// Not modularized, can shadow previous `macro_rules` definitions, etc.
 #[derive(Debug)]
-pub(crate) struct MacroRulesBinding<'ra> {
-    pub(crate) binding: NameBinding<'ra>,
+pub(crate) struct MacroRulesDecl<'ra> {
+    pub(crate) decl: Decl<'ra>,
     /// `macro_rules` scope into which the `macro_rules` item was planted.
     pub(crate) parent_macro_rules_scope: MacroRulesScopeRef<'ra>,
-    pub(crate) ident: Ident,
+    pub(crate) ident: Macros20NormalizedIdent,
 }
 
 /// The scope introduced by a `macro_rules!` macro.
@@ -65,7 +65,7 @@ pub(crate) enum MacroRulesScope<'ra> {
     /// Empty "root" scope at the crate start containing no names.
     Empty,
     /// The scope introduced by a `macro_rules!` macro definition.
-    Binding(&'ra MacroRulesBinding<'ra>),
+    Def(&'ra MacroRulesDecl<'ra>),
     /// The scope introduced by a macro invocation that can potentially
     /// create a `macro_rules!` macro definition.
     Invocation(LocalExpnId),
@@ -403,13 +403,10 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
                     ) {
                         Ok((Some(ext), _)) => {
                             if !ext.helper_attrs.is_empty() {
-                                let last_seg = resolution.path.segments.last().unwrap();
-                                let span = last_seg.ident.span.normalize_to_macros_2_0();
-                                entry.helper_attrs.extend(
-                                    ext.helper_attrs
-                                        .iter()
-                                        .map(|name| (i, Ident::new(*name, span))),
-                                );
+                                let span = resolution.path.segments.last().unwrap().ident.span;
+                                entry.helper_attrs.extend(ext.helper_attrs.iter().map(|name| {
+                                    (i, Macros20NormalizedIdent::new(Ident::new(*name, span)))
+                                }));
                             }
                             entry.has_derive_copy |= ext.builtin_name == Some(sym::Copy);
                             ext
@@ -431,8 +428,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
             .iter()
             .map(|(_, ident)| {
                 let res = Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper);
-                let binding = self.arenas.new_pub_res_binding(res, ident.span, expn_id);
-                (*ident, binding)
+                (*ident, self.arenas.new_pub_def_decl(res, ident.span, expn_id))
             })
             .collect();
         self.helper_attrs.insert(expn_id, helper_attrs);
@@ -531,7 +527,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         target_trait.for_each_child(self, |this, ident, ns, _binding| {
             // FIXME: Adjust hygiene for idents from globs, like for glob imports.
             if let Some(overriding_keys) = this.impl_binding_keys.get(&impl_def_id)
-                && overriding_keys.contains(&BindingKey::new(ident.0, ns))
+                && overriding_keys.contains(&BindingKey::new(ident, ns))
             {
                 // The name is overridden, do not produce it from the glob delegation.
             } else {
@@ -1062,18 +1058,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     fn prohibit_imported_non_macro_attrs(
         &self,
-        binding: Option<NameBinding<'ra>>,
+        decl: Option<Decl<'ra>>,
         res: Option<Res>,
         span: Span,
     ) {
         if let Some(Res::NonMacroAttr(kind)) = res {
-            if kind != NonMacroAttrKind::Tool && binding.is_none_or(|b| b.is_import()) {
-                let binding_span = binding.map(|binding| binding.span);
+            if kind != NonMacroAttrKind::Tool && decl.is_none_or(|b| b.is_import()) {
                 self.dcx().emit_err(errors::CannotUseThroughAnImport {
                     span,
                     article: kind.article(),
                     descr: kind.descr(),
-                    binding_span,
+                    binding_span: decl.map(|d| d.span),
                 });
             }
         }
@@ -1084,12 +1079,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         path: &ast::Path,
         parent_scope: &ParentScope<'ra>,
         invoc_in_mod_inert_attr: Option<(LocalDefId, NodeId)>,
-        binding: Option<NameBinding<'ra>>,
+        decl: Option<Decl<'ra>>,
     ) {
         if let Some((mod_def_id, node_id)) = invoc_in_mod_inert_attr
-            && let Some(binding) = binding
+            && let Some(decl) = decl
             // This is a `macro_rules` itself, not some import.
-            && let NameBindingKind::Res(res) = binding.kind
+            && let DeclKind::Def(res) = decl.kind
             && let Res::Def(DefKind::Macro(kinds), def_id) = res
             && kinds.contains(MacroKinds::BANG)
             // And the `macro_rules` is defined inside the attribute's module,
diff --git a/compiler/rustc_resolve/src/rustdoc.rs b/compiler/rustc_resolve/src/rustdoc.rs
index 7f7c423acb40..9f74a7801d2e 100644
--- a/compiler/rustc_resolve/src/rustdoc.rs
+++ b/compiler/rustc_resolve/src/rustdoc.rs
@@ -410,8 +410,17 @@ pub fn may_be_doc_link(link_type: LinkType) -> bool {
 /// Simplified version of `preprocessed_markdown_links` from rustdoc.
 /// Must return at least the same links as it, but may add some more links on top of that.
 pub(crate) fn attrs_to_preprocessed_links<A: AttributeExt + Clone>(attrs: &[A]) -> Vec<Box<str>> {
-    let (doc_fragments, _) = attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), true);
-    let doc = prepare_to_doc_link_resolution(&doc_fragments).into_values().next().unwrap();
+    let (doc_fragments, other_attrs) =
+        attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), false);
+    let mut doc =
+        prepare_to_doc_link_resolution(&doc_fragments).into_values().next().unwrap_or_default();
+
+    for attr in other_attrs {
+        if let Some(note) = attr.deprecation_note() {
+            doc += note.as_str();
+            doc += "\n";
+        }
+    }
 
     parse_links(&doc)
 }
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index fe96dabf6330..8c492fcf8f15 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -196,6 +196,8 @@ pub enum Offload {
     Device,
     /// Second step in the offload pipeline, generates the host code to call kernels.
     Host(String),
+    /// Test is similar to Host, but allows testing without a device artifact.
+    Test,
 }
 
 /// The different settings that the `-Z autodiff` flag can have.
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index f11ad12fb9dd..21fa3321a30a 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -794,7 +794,8 @@ mod desc {
     pub(crate) const parse_list_with_polarity: &str =
         "a comma-separated list of strings, with elements beginning with + or -";
     pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`, `NoTT`";
-    pub(crate) const parse_offload: &str = "a comma separated list of settings: `Enable`";
+    pub(crate) const parse_offload: &str =
+        "a comma separated list of settings: `Host=<Absolute-Path>`, `Device`, `Test`";
     pub(crate) const parse_comma_list: &str = "a comma-separated list of strings";
     pub(crate) const parse_opt_comma_list: &str = parse_comma_list;
     pub(crate) const parse_number: &str = "a number";
@@ -1471,6 +1472,13 @@ pub mod parse {
                     }
                     Offload::Device
                 }
+                "Test" => {
+                    if let Some(_) = arg {
+                        // Test does not accept a value
+                        return false;
+                    }
+                    Offload::Test
+                }
                 _ => {
                     // FIXME(ZuseZ4): print an error saying which value is not recognized
                     return false;
diff --git a/compiler/rustc_span/src/caching_source_map_view.rs b/compiler/rustc_span/src/caching_source_map_view.rs
index 41cfaa3ee34e..11507a3d9e45 100644
--- a/compiler/rustc_span/src/caching_source_map_view.rs
+++ b/compiler/rustc_span/src/caching_source_map_view.rs
@@ -2,7 +2,7 @@ use std::ops::Range;
 use std::sync::Arc;
 
 use crate::source_map::SourceMap;
-use crate::{BytePos, Pos, RelativeBytePos, SourceFile, SpanData, StableSourceFileId};
+use crate::{BytePos, Pos, RelativeBytePos, SourceFile, SpanData};
 
 #[derive(Clone)]
 struct CacheEntry {
@@ -114,7 +114,7 @@ impl<'sm> CachingSourceMapView<'sm> {
     pub fn span_data_to_lines_and_cols(
         &mut self,
         span_data: &SpanData,
-    ) -> Option<(StableSourceFileId, usize, BytePos, usize, BytePos)> {
+    ) -> Option<(&SourceFile, usize, BytePos, usize, BytePos)> {
         self.time_stamp += 1;
 
         // Check if lo and hi are in the cached lines.
@@ -136,7 +136,7 @@ impl<'sm> CachingSourceMapView<'sm> {
             let lo = &self.line_cache[lo_cache_idx as usize];
             let hi = &self.line_cache[hi_cache_idx as usize];
             return Some((
-                lo.file.stable_id,
+                &lo.file,
                 lo.line_number,
                 span_data.lo - lo.line.start,
                 hi.line_number,
@@ -224,7 +224,7 @@ impl<'sm> CachingSourceMapView<'sm> {
         assert_eq!(lo.file_index, hi.file_index);
 
         Some((
-            lo.file.stable_id,
+            &lo.file,
             lo.line_number,
             span_data.lo - lo.line.start,
             hi.line_number,
diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs
index 484e626d4638..a0ccf8d7e798 100644
--- a/compiler/rustc_span/src/def_id.rs
+++ b/compiler/rustc_span/src/def_id.rs
@@ -81,7 +81,7 @@ impl fmt::Display for CrateNum {
 /// because it depends on the set of crates in the entire crate graph of a
 /// compilation session. Again, using the same crate with a different version
 /// number would fix the issue with a high probability -- but that might be
-/// easier said then done if the crates in questions are dependencies of
+/// easier said than done if the crates in questions are dependencies of
 /// third-party crates.
 ///
 /// That being said, given a high quality hash function, the collision
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index d3e0e303d0c6..1c430099835b 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -2831,7 +2831,7 @@ pub trait HashStableContext {
     fn span_data_to_lines_and_cols(
         &mut self,
         span: &SpanData,
-    ) -> Option<(StableSourceFileId, usize, BytePos, usize, BytePos)>;
+    ) -> Option<(&SourceFile, usize, BytePos, usize, BytePos)>;
     fn hashing_controls(&self) -> HashingControls;
 }
 
@@ -2849,6 +2849,8 @@ where
     /// codepoint offsets. For the purpose of the hash that's sufficient.
     /// Also, hashing filenames is expensive so we avoid doing it twice when the
     /// span starts and ends in the same file, which is almost always the case.
+    ///
+    /// IMPORTANT: changes to this method should be reflected in implementations of `SpanEncoder`.
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         const TAG_VALID_SPAN: u8 = 0;
         const TAG_INVALID_SPAN: u8 = 1;
@@ -2867,15 +2869,17 @@ where
             return;
         }
 
-        if let Some(parent) = span.parent {
-            let def_span = ctx.def_span(parent).data_untracked();
-            if def_span.contains(span) {
-                // This span is enclosed in a definition: only hash the relative position.
-                Hash::hash(&TAG_RELATIVE_SPAN, hasher);
-                (span.lo - def_span.lo).to_u32().hash_stable(ctx, hasher);
-                (span.hi - def_span.lo).to_u32().hash_stable(ctx, hasher);
-                return;
-            }
+        let parent = span.parent.map(|parent| ctx.def_span(parent).data_untracked());
+        if let Some(parent) = parent
+            && parent.contains(span)
+        {
+            // This span is enclosed in a definition: only hash the relative position.
+            // This catches a subset of the cases from the `file.contains(parent.lo)`,
+            // But we can do this check cheaply without the expensive `span_data_to_lines_and_cols` query.
+            Hash::hash(&TAG_RELATIVE_SPAN, hasher);
+            (span.lo - parent.lo).to_u32().hash_stable(ctx, hasher);
+            (span.hi - parent.lo).to_u32().hash_stable(ctx, hasher);
+            return;
         }
 
         // If this is not an empty or invalid span, we want to hash the last
@@ -2887,8 +2891,19 @@ where
             return;
         };
 
+        if let Some(parent) = parent
+            && file.contains(parent.lo)
+        {
+            // This span is relative to another span in the same file,
+            // only hash the relative position.
+            Hash::hash(&TAG_RELATIVE_SPAN, hasher);
+            Hash::hash(&(span.lo.0.wrapping_sub(parent.lo.0)), hasher);
+            Hash::hash(&(span.hi.0.wrapping_sub(parent.lo.0)), hasher);
+            return;
+        }
+
         Hash::hash(&TAG_VALID_SPAN, hasher);
-        Hash::hash(&file, hasher);
+        Hash::hash(&file.stable_id, hasher);
 
         // Hash both the length and the end location (line/column) of a span. If we
         // hash only the length, for example, then two otherwise equal spans with
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 72709753b1df..b473d36a45fc 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -284,6 +284,7 @@ symbols! {
         IteratorItem,
         IteratorMap,
         Layout,
+        Leaf,
         Left,
         LinkedList,
         LintDiagnostic,
@@ -302,6 +303,7 @@ symbols! {
         Ordering,
         OsStr,
         OsString,
+        Other,
         Output,
         Param,
         ParamSet,
@@ -380,6 +382,7 @@ symbols! {
         TryCapturePrintable,
         TryFrom,
         TryInto,
+        Tuple,
         Ty,
         TyCtxt,
         TyKind,
@@ -1788,6 +1791,8 @@ symbols! {
         ptr_slice_from_raw_parts_mut,
         ptr_swap,
         ptr_swap_nonoverlapping,
+        ptr_without_provenance,
+        ptr_without_provenance_mut,
         ptr_write,
         ptr_write_bytes,
         ptr_write_unaligned,
@@ -2039,7 +2044,6 @@ symbols! {
         self_in_typedefs,
         self_struct_ctor,
         semiopaque,
-        semitransparent,
         sha2,
         sha3,
         sha512_sm_x86,
@@ -2317,6 +2321,7 @@ symbols! {
         type_const,
         type_id,
         type_id_eq,
+        type_info,
         type_ir,
         type_ir_infer_ctxt_like,
         type_ir_inherent,
@@ -2324,6 +2329,7 @@ symbols! {
         type_length_limit,
         type_macros,
         type_name,
+        type_of,
         type_privacy_lints,
         typed_swap_nonoverlapping,
         u8,
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 092d99e91118..6faa57252ca2 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -381,15 +381,14 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
     pub fn new(
         cx: &impl HasDataLayout,
         layout: TyAndLayout<'a, Ty>,
-        scalar_attrs: impl Fn(&TyAndLayout<'a, Ty>, Scalar, Size) -> ArgAttributes,
+        scalar_attrs: impl Fn(Scalar, Size) -> ArgAttributes,
     ) -> Self {
         let mode = match layout.backend_repr {
-            BackendRepr::Scalar(scalar) => {
-                PassMode::Direct(scalar_attrs(&layout, scalar, Size::ZERO))
-            }
+            _ if layout.is_zst() => PassMode::Ignore,
+            BackendRepr::Scalar(scalar) => PassMode::Direct(scalar_attrs(scalar, Size::ZERO)),
             BackendRepr::ScalarPair(a, b) => PassMode::Pair(
-                scalar_attrs(&layout, a, Size::ZERO),
-                scalar_attrs(&layout, b, a.size(cx).align_to(b.align(cx).abi)),
+                scalar_attrs(a, Size::ZERO),
+                scalar_attrs(b, a.size(cx).align_to(b.align(cx).abi)),
             ),
             BackendRepr::SimdVector { .. } => PassMode::Direct(ArgAttributes::new()),
             BackendRepr::Memory { .. } => Self::indirect_pass_mode(&layout),
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index a972299deeac..20fbb687b308 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -163,6 +163,7 @@ impl Target {
         forward!(relro_level);
         forward!(archive_format);
         forward!(allow_asm);
+        forward!(static_initializer_must_be_acyclic);
         forward!(main_needs_argc_argv);
         forward!(has_thread_local);
         forward!(obj_is_bitcode);
@@ -360,6 +361,7 @@ impl ToJson for Target {
         target_option_val!(relro_level);
         target_option_val!(archive_format);
         target_option_val!(allow_asm);
+        target_option_val!(static_initializer_must_be_acyclic);
         target_option_val!(main_needs_argc_argv);
         target_option_val!(has_thread_local);
         target_option_val!(obj_is_bitcode);
@@ -581,6 +583,7 @@ struct TargetSpecJson {
     relro_level: Option<RelroLevel>,
     archive_format: Option<StaticCow<str>>,
     allow_asm: Option<bool>,
+    static_initializer_must_be_acyclic: Option<bool>,
     main_needs_argc_argv: Option<bool>,
     has_thread_local: Option<bool>,
     obj_is_bitcode: Option<bool>,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index b06339f59425..89c9fdc935cc 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2394,6 +2394,9 @@ pub struct TargetOptions {
     pub archive_format: StaticCow<str>,
     /// Is asm!() allowed? Defaults to true.
     pub allow_asm: bool,
+    /// Static initializers must be acyclic.
+    /// Defaults to false
+    pub static_initializer_must_be_acyclic: bool,
     /// Whether the runtime startup code requires the `main` function be passed
     /// `argc` and `argv` values.
     pub main_needs_argc_argv: bool,
@@ -2777,6 +2780,7 @@ impl Default for TargetOptions {
             archive_format: "gnu".into(),
             main_needs_argc_argv: true,
             allow_asm: true,
+            static_initializer_must_be_acyclic: false,
             has_thread_local: false,
             obj_is_bitcode: false,
             min_atomic_width: None,
diff --git a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
index be09681b1f35..87c2693e9877 100644
--- a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
+++ b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
@@ -59,6 +59,9 @@ pub(crate) fn target() -> Target {
             // Support using `self-contained` linkers like the llvm-bitcode-linker
             link_self_contained: LinkSelfContainedDefault::True,
 
+            // Static initializers must not have cycles on this target
+            static_initializer_must_be_acyclic: true,
+
             ..Default::default()
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs
index b4f394643a9d..b83f5544a351 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs
@@ -17,7 +17,8 @@ pub(crate) fn target() -> Target {
             std: None, // ?
         },
         pointer_width: 64,
-        data_layout: "E-m:a-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(),
+        data_layout: "E-m:a-Fi64-i64:64-i128:128-n32:64-f64:32:64-S128-v256:256:256-v512:512:512"
+            .into(),
         arch: Arch::PowerPC64,
         options: base,
     }
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 28d8e84137a2..40cc4f40a333 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -588,7 +588,7 @@ const NVPTX_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
 static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     // tidy-alphabetical-start
     ("a", Stable, &["zaamo", "zalrsc"]),
-    ("b", Unstable(sym::riscv_target_feature), &["zba", "zbb", "zbs"]),
+    ("b", Stable, &["zba", "zbb", "zbs"]),
     ("c", Stable, &["zca"]),
     ("d", Unstable(sym::riscv_target_feature), &["f"]),
     ("e", Unstable(sym::riscv_target_feature), &[]),
@@ -646,14 +646,14 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("unaligned-scalar-mem", Unstable(sym::riscv_target_feature), &[]),
     ("unaligned-vector-mem", Unstable(sym::riscv_target_feature), &[]),
     ("v", Unstable(sym::riscv_target_feature), &["zvl128b", "zve64d"]),
-    ("za64rs", Unstable(sym::riscv_target_feature), &["za128rs"]), // Za64rs ⊃ Za128rs
-    ("za128rs", Unstable(sym::riscv_target_feature), &[]),
-    ("zaamo", Unstable(sym::riscv_target_feature), &[]),
-    ("zabha", Unstable(sym::riscv_target_feature), &["zaamo"]),
-    ("zacas", Unstable(sym::riscv_target_feature), &["zaamo"]),
-    ("zalrsc", Unstable(sym::riscv_target_feature), &[]),
-    ("zama16b", Unstable(sym::riscv_target_feature), &[]),
-    ("zawrs", Unstable(sym::riscv_target_feature), &[]),
+    ("za64rs", Stable, &["za128rs"]), // Za64rs ⊃ Za128rs
+    ("za128rs", Stable, &[]),
+    ("zaamo", Stable, &[]),
+    ("zabha", Stable, &["zaamo"]),
+    ("zacas", Stable, &["zaamo"]),
+    ("zalrsc", Stable, &[]),
+    ("zama16b", Stable, &[]),
+    ("zawrs", Stable, &[]),
     ("zba", Stable, &[]),
     ("zbb", Stable, &[]),
     ("zbc", Stable, &["zbkc"]), // Zbc ⊃ Zbkc
@@ -661,9 +661,9 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("zbkc", Stable, &[]),
     ("zbkx", Stable, &[]),
     ("zbs", Stable, &[]),
-    ("zca", Unstable(sym::riscv_target_feature), &[]),
-    ("zcb", Unstable(sym::riscv_target_feature), &["zca"]),
-    ("zcmop", Unstable(sym::riscv_target_feature), &["zca"]),
+    ("zca", Stable, &[]),
+    ("zcb", Stable, &["zca"]),
+    ("zcmop", Stable, &["zca"]),
     ("zdinx", Unstable(sym::riscv_target_feature), &["zfinx"]),
     ("zfa", Unstable(sym::riscv_target_feature), &["f"]),
     ("zfbfmin", Unstable(sym::riscv_target_feature), &["f"]), // and a subset of Zfhmin
@@ -672,22 +672,22 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("zfinx", Unstable(sym::riscv_target_feature), &["zicsr"]),
     ("zhinx", Unstable(sym::riscv_target_feature), &["zhinxmin"]),
     ("zhinxmin", Unstable(sym::riscv_target_feature), &["zfinx"]),
-    ("zic64b", Unstable(sym::riscv_target_feature), &[]),
-    ("zicbom", Unstable(sym::riscv_target_feature), &[]),
-    ("zicbop", Unstable(sym::riscv_target_feature), &[]),
-    ("zicboz", Unstable(sym::riscv_target_feature), &[]),
-    ("ziccamoa", Unstable(sym::riscv_target_feature), &[]),
-    ("ziccif", Unstable(sym::riscv_target_feature), &[]),
-    ("zicclsm", Unstable(sym::riscv_target_feature), &[]),
-    ("ziccrse", Unstable(sym::riscv_target_feature), &[]),
-    ("zicntr", Unstable(sym::riscv_target_feature), &["zicsr"]),
-    ("zicond", Unstable(sym::riscv_target_feature), &[]),
-    ("zicsr", Unstable(sym::riscv_target_feature), &[]),
-    ("zifencei", Unstable(sym::riscv_target_feature), &[]),
-    ("zihintntl", Unstable(sym::riscv_target_feature), &[]),
-    ("zihintpause", Unstable(sym::riscv_target_feature), &[]),
-    ("zihpm", Unstable(sym::riscv_target_feature), &["zicsr"]),
-    ("zimop", Unstable(sym::riscv_target_feature), &[]),
+    ("zic64b", Stable, &[]),
+    ("zicbom", Stable, &[]),
+    ("zicbop", Stable, &[]),
+    ("zicboz", Stable, &[]),
+    ("ziccamoa", Stable, &[]),
+    ("ziccif", Stable, &[]),
+    ("zicclsm", Stable, &[]),
+    ("ziccrse", Stable, &[]),
+    ("zicntr", Stable, &["zicsr"]),
+    ("zicond", Stable, &[]),
+    ("zicsr", Stable, &[]),
+    ("zifencei", Stable, &[]),
+    ("zihintntl", Stable, &[]),
+    ("zihintpause", Stable, &[]),
+    ("zihpm", Stable, &["zicsr"]),
+    ("zimop", Stable, &[]),
     ("zk", Stable, &["zkn", "zkr", "zkt"]),
     ("zkn", Stable, &["zbkb", "zbkc", "zbkx", "zkne", "zknd", "zknh"]),
     ("zknd", Stable, &["zkne_or_zknd"]),
@@ -699,7 +699,7 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("zksed", Stable, &[]),
     ("zksh", Stable, &[]),
     ("zkt", Stable, &[]),
-    ("ztso", Unstable(sym::riscv_target_feature), &[]),
+    ("ztso", Stable, &[]),
     ("zvbb", Unstable(sym::riscv_target_feature), &["zvkb"]), // Zvbb ⊃ Zvkb
     ("zvbc", Unstable(sym::riscv_target_feature), &["zve64x"]),
     ("zve32f", Unstable(sym::riscv_target_feature), &["zve32x", "f"]),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index cea69c699628..47810e2578df 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -1879,7 +1879,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             && let Some(length_val) = sz.found.try_to_target_usize(self.tcx)
         {
             Some(TypeErrorAdditionalDiags::ConsiderSpecifyingLength {
-                span: length_arg.span(),
+                span: length_arg.span,
                 length: length_val,
             })
         } else {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index d96a1b0a8c0e..0f021946e06a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -33,6 +33,7 @@ use rustc_middle::ty::{
     TypeVisitableExt, Upcast,
 };
 use rustc_middle::{bug, span_bug};
+use rustc_span::def_id::CrateNum;
 use rustc_span::{BytePos, DUMMY_SP, STDLIB_STABLE_CRATES, Span, Symbol, sym};
 use tracing::{debug, instrument};
 
@@ -1287,10 +1288,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     self.tcx.def_span(def.did()),
                     format!("`{self_ty}` needs to implement `From<{ty}>`"),
                 );
-                err.span_note(
-                    self.tcx.def_span(found.did()),
-                    format!("alternatively, `{ty}` needs to implement `Into<{self_ty}>`"),
-                );
             }
             (ty::Adt(def, _), None) if def.did().is_local() => {
                 let trait_path = self.tcx.short_string(
@@ -2172,6 +2169,13 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         self.suggest_function_pointers_impl(None, &exp_found, err);
                     }
 
+                    if let ty::Adt(def, _) = trait_pred.self_ty().skip_binder().peel_refs().kind()
+                        && let crates = self.tcx.duplicate_crate_names(def.did().krate)
+                        && !crates.is_empty()
+                    {
+                        self.note_two_crate_versions(def.did().krate, MultiSpan::new(), err);
+                        err.help("you can use `cargo tree` to explore your dependency tree");
+                    }
                     true
                 })
             }) {
@@ -2282,6 +2286,14 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     }
                 ));
             }
+
+            if let ty::Adt(def, _) = trait_pred.self_ty().skip_binder().peel_refs().kind()
+                && let crates = self.tcx.duplicate_crate_names(def.did().krate)
+                && !crates.is_empty()
+            {
+                self.note_two_crate_versions(def.did().krate, MultiSpan::new(), err);
+                err.help("you can use `cargo tree` to explore your dependency tree");
+            }
             true
         };
 
@@ -2445,11 +2457,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
     pub fn note_two_crate_versions(
         &self,
-        did: DefId,
+        krate: CrateNum,
         sp: impl Into<MultiSpan>,
         err: &mut Diag<'_>,
     ) {
-        let crate_name = self.tcx.crate_name(did.krate);
+        let crate_name = self.tcx.crate_name(krate);
         let crate_msg = format!(
             "there are multiple different versions of crate `{crate_name}` in the dependency graph"
         );
@@ -2514,7 +2526,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         for (similar_item, _) in similar_items {
             err.span_help(self.tcx.def_span(similar_item), "item with same name found");
-            self.note_two_crate_versions(similar_item, MultiSpan::new(), err);
+            self.note_two_crate_versions(similar_item.krate, MultiSpan::new(), err);
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index 3ba984b90a1d..a7a685d62b34 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -442,7 +442,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     );
                 }
             }
-            self.note_two_crate_versions(expected_did, span, err);
+            self.note_two_crate_versions(expected_did.krate, span, err);
             err.help("you can use `cargo tree` to explore your dependency tree");
         }
         suggested
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index d14ff2c3b7e2..511e9e85b5f6 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4069,15 +4069,46 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ))
                 && expr.span.hi() != rcvr.span.hi()
             {
-                err.span_suggestion_verbose(
-                    expr.span.with_lo(rcvr.span.hi()),
-                    format!(
-                        "consider removing this method call, as the receiver has type `{ty}` and \
-                         `{pred}` trivially holds",
-                    ),
-                    "",
-                    Applicability::MaybeIncorrect,
-                );
+                let should_sugg = match tcx.hir_node(call_hir_id) {
+                    Node::Expr(hir::Expr {
+                        kind: hir::ExprKind::MethodCall(_, call_receiver, _, _),
+                        ..
+                    }) if let Some((DefKind::AssocFn, did)) =
+                        typeck_results.type_dependent_def(call_hir_id)
+                        && call_receiver.hir_id == arg_hir_id =>
+                    {
+                        // Avoid suggesting removing a method call if the argument is the receiver of the parent call and
+                        // removing the receiver would make the method inaccessible. i.e. `x.a().b()`, suggesting removing
+                        // `.a()` could change the type and make `.b()` unavailable.
+                        if tcx.inherent_impl_of_assoc(did).is_some() {
+                            // if we're calling an inherent impl method, just try to make sure that the receiver type stays the same.
+                            Some(ty) == typeck_results.node_type_opt(arg_hir_id)
+                        } else {
+                            // we're calling a trait method, so we just check removing the method call still satisfies the trait.
+                            let trait_id = tcx
+                                .trait_of_assoc(did)
+                                .unwrap_or_else(|| tcx.impl_trait_id(tcx.parent(did)));
+                            let args = typeck_results.node_args(call_hir_id);
+                            let tr = ty::TraitRef::from_assoc(tcx, trait_id, args)
+                                .with_replaced_self_ty(tcx, ty);
+                            self.type_implements_trait(tr.def_id, tr.args, param_env)
+                                .must_apply_modulo_regions()
+                        }
+                    }
+                    _ => true,
+                };
+
+                if should_sugg {
+                    err.span_suggestion_verbose(
+                        expr.span.with_lo(rcvr.span.hi()),
+                        format!(
+                            "consider removing this method call, as the receiver has type `{ty}` and \
+                            `{pred}` trivially holds",
+                        ),
+                        "",
+                        Applicability::MaybeIncorrect,
+                    );
+                }
             }
             if let hir::Expr { kind: hir::ExprKind::Block(block, _), .. } = expr {
                 let inner_expr = expr.peel_blocks();
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index cdbf2b0aeb83..944d57bf95d1 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -144,7 +144,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
     pub fn instantiate_nested_goals(&self, span: Span) -> Vec<InspectGoal<'a, 'tcx>> {
         let infcx = self.goal.infcx;
         let param_env = self.goal.goal.param_env;
-        let mut orig_values = self.goal.orig_values.to_vec();
+        let mut orig_values = self.goal.orig_values.clone();
 
         let mut instantiated_goals = vec![];
         for step in &self.steps {
@@ -186,7 +186,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
     pub fn instantiate_impl_args(&self, span: Span) -> ty::GenericArgsRef<'tcx> {
         let infcx = self.goal.infcx;
         let param_env = self.goal.goal.param_env;
-        let mut orig_values = self.goal.orig_values.to_vec();
+        let mut orig_values = self.goal.orig_values.clone();
 
         for step in &self.steps {
             match **step {
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 394095508393..d383cb9d91dd 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -1051,7 +1051,53 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
             | ty::ConstKind::Placeholder(..) => {
                 // These variants are trivially WF, so nothing to do here.
             }
-            ty::ConstKind::Value(..) => {
+            ty::ConstKind::Value(val) => {
+                // FIXME(mgca): no need to feature-gate once valtree lifetimes are not erased
+                if tcx.features().min_generic_const_args() {
+                    match val.ty.kind() {
+                        ty::Adt(adt_def, args) => {
+                            let adt_val = val.destructure_adt_const();
+                            let variant_def = adt_def.variant(adt_val.variant);
+                            let cause = self.cause(ObligationCauseCode::WellFormed(None));
+                            self.out.extend(variant_def.fields.iter().zip(adt_val.fields).map(
+                                |(field_def, &field_val)| {
+                                    let field_ty =
+                                        tcx.type_of(field_def.did).instantiate(tcx, args);
+                                    let predicate = ty::PredicateKind::Clause(
+                                        ty::ClauseKind::ConstArgHasType(field_val, field_ty),
+                                    );
+                                    traits::Obligation::with_depth(
+                                        tcx,
+                                        cause.clone(),
+                                        self.recursion_depth,
+                                        self.param_env,
+                                        predicate,
+                                    )
+                                },
+                            ));
+                        }
+                        ty::Tuple(field_tys) => {
+                            let field_vals = val.to_branch();
+                            let cause = self.cause(ObligationCauseCode::WellFormed(None));
+                            self.out.extend(field_tys.iter().zip(field_vals).map(
+                                |(field_ty, &field_val)| {
+                                    let predicate = ty::PredicateKind::Clause(
+                                        ty::ClauseKind::ConstArgHasType(field_val, field_ty),
+                                    );
+                                    traits::Obligation::with_depth(
+                                        tcx,
+                                        cause.clone(),
+                                        self.recursion_depth,
+                                        self.param_env,
+                                        predicate,
+                                    )
+                                },
+                            ));
+                        }
+                        _ => {}
+                    }
+                }
+
                 // FIXME: Enforce that values are structurally-matchable.
             }
         }
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index 58cb2eb6556e..08ae561c972c 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -155,14 +155,14 @@ mod rustc {
                     .enumerate()
                     .find(|(_, field_def)| name == field_def.name)
                     .unwrap_or_else(|| panic!("There were no fields named `{name}`."));
-                fields[field_idx].to_leaf() == ScalarInt::TRUE
+                fields[field_idx].try_to_leaf().map(|leaf| leaf == ScalarInt::TRUE)
             };
 
             Some(Self {
-                alignment: get_field(sym::alignment),
-                lifetimes: get_field(sym::lifetimes),
-                safety: get_field(sym::safety),
-                validity: get_field(sym::validity),
+                alignment: get_field(sym::alignment)?,
+                lifetimes: get_field(sym::lifetimes)?,
+                safety: get_field(sym::safety)?,
+                validity: get_field(sym::validity)?,
             })
         }
     }
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 0676fa99d826..ad621c67772c 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -549,15 +549,9 @@ fn fn_abi_new_uncached<'tcx>(
             layout
         };
 
-        let mut arg = ArgAbi::new(cx, layout, |layout, scalar, offset| {
-            arg_attrs_for_rust_scalar(*cx, scalar, *layout, offset, is_return, drop_target_pointee)
-        });
-
-        if arg.layout.is_zst() {
-            arg.mode = PassMode::Ignore;
-        }
-
-        Ok(arg)
+        Ok(ArgAbi::new(cx, layout, |scalar, offset| {
+            arg_attrs_for_rust_scalar(*cx, scalar, layout, offset, is_return, drop_target_pointee)
+        }))
     };
 
     let mut fn_abi = FnAbi {
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index 47e753d78731..12d222258b0c 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -38,7 +38,7 @@ impl<I: Interner, V: Eq> Eq for CanonicalQueryInput<I, V> {}
 pub struct Canonical<I: Interner, V> {
     pub value: V,
     pub max_universe: UniverseIndex,
-    pub variables: I::CanonicalVarKinds,
+    pub var_kinds: I::CanonicalVarKinds,
 }
 
 impl<I: Interner, V: Eq> Eq for Canonical<I, V> {}
@@ -68,17 +68,17 @@ impl<I: Interner, V> Canonical<I, V> {
     /// let b: Canonical<I, (T, Ty<I>)> = a.unchecked_map(|v| (v, ty));
     /// ```
     pub fn unchecked_map<W>(self, map_op: impl FnOnce(V) -> W) -> Canonical<I, W> {
-        let Canonical { max_universe, variables, value } = self;
-        Canonical { max_universe, variables, value: map_op(value) }
+        let Canonical { max_universe, var_kinds, value } = self;
+        Canonical { max_universe, var_kinds, value: map_op(value) }
     }
 }
 
 impl<I: Interner, V: fmt::Display> fmt::Display for Canonical<I, V> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { value, max_universe, variables } = self;
+        let Self { value, max_universe, var_kinds } = self;
         write!(
             f,
-            "Canonical {{ value: {value}, max_universe: {max_universe:?}, variables: {variables:?} }}",
+            "Canonical {{ value: {value}, max_universe: {max_universe:?}, var_kinds: {var_kinds:?} }}",
         )
     }
 }
@@ -311,30 +311,30 @@ impl<I: Interner> CanonicalVarValues<I> {
 
     pub fn instantiate(
         cx: I,
-        variables: I::CanonicalVarKinds,
+        var_kinds: I::CanonicalVarKinds,
         mut f: impl FnMut(&[I::GenericArg], CanonicalVarKind<I>) -> I::GenericArg,
     ) -> CanonicalVarValues<I> {
         // Instantiating `CanonicalVarValues` is really hot, but limited to less than
         // 4 most of the time. Avoid creating a `Vec` here.
-        if variables.len() <= 4 {
+        if var_kinds.len() <= 4 {
             let mut var_values = ArrayVec::<_, 4>::new();
-            for info in variables.iter() {
+            for info in var_kinds.iter() {
                 var_values.push(f(&var_values, info));
             }
             CanonicalVarValues { var_values: cx.mk_args(&var_values) }
         } else {
-            CanonicalVarValues::instantiate_cold(cx, variables, f)
+            CanonicalVarValues::instantiate_cold(cx, var_kinds, f)
         }
     }
 
     #[cold]
     fn instantiate_cold(
         cx: I,
-        variables: I::CanonicalVarKinds,
+        var_kinds: I::CanonicalVarKinds,
         mut f: impl FnMut(&[I::GenericArg], CanonicalVarKind<I>) -> I::GenericArg,
     ) -> CanonicalVarValues<I> {
-        let mut var_values = Vec::with_capacity(variables.len());
-        for info in variables.iter() {
+        let mut var_values = Vec::with_capacity(var_kinds.len());
+        for info in var_kinds.iter() {
             var_values.push(f(&var_values, info));
         }
         CanonicalVarValues { var_values: cx.mk_args(&var_values) }
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 16f837141e97..4323b1ca6469 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -646,8 +646,6 @@ pub trait Features<I: Interner>: Copy {
 
     fn coroutine_clone(self) -> bool;
 
-    fn associated_const_equality(self) -> bool;
-
     fn feature_bound_holds_in_crate(self, symbol: I::Symbol) -> bool;
 }
 
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index 4954ebc51cfc..3610605462ba 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -155,11 +155,10 @@ impl<I: Interner> Relate<I> for ty::FnSig<I> {
         let cx = relation.cx();
 
         if a.c_variadic != b.c_variadic {
-            return Err(TypeError::VariadicMismatch({
-                let a = a.c_variadic;
-                let b = b.c_variadic;
-                ExpectedFound::new(a, b)
-            }));
+            return Err(TypeError::VariadicMismatch(ExpectedFound::new(
+                a.c_variadic,
+                b.c_variadic,
+            )));
         }
 
         if a.safety != b.safety {
@@ -217,11 +216,7 @@ impl<I: Interner> Relate<I> for ty::AliasTy<I> {
         b: ty::AliasTy<I>,
     ) -> RelateResult<I, ty::AliasTy<I>> {
         if a.def_id != b.def_id {
-            Err(TypeError::ProjectionMismatched({
-                let a = a.def_id;
-                let b = b.def_id;
-                ExpectedFound::new(a, b)
-            }))
+            Err(TypeError::ProjectionMismatched(ExpectedFound::new(a.def_id, b.def_id)))
         } else {
             let cx = relation.cx();
             let args = if let Some(variances) = cx.opt_alias_variances(a.kind(cx), a.def_id) {
@@ -241,11 +236,7 @@ impl<I: Interner> Relate<I> for ty::AliasTerm<I> {
         b: ty::AliasTerm<I>,
     ) -> RelateResult<I, ty::AliasTerm<I>> {
         if a.def_id != b.def_id {
-            Err(TypeError::ProjectionMismatched({
-                let a = a.def_id;
-                let b = b.def_id;
-                ExpectedFound::new(a, b)
-            }))
+            Err(TypeError::ProjectionMismatched(ExpectedFound::new(a.def_id, b.def_id)))
         } else {
             let args = match a.kind(relation.cx()) {
                 ty::AliasTermKind::OpaqueTy => relate_args_with_variances(
@@ -276,11 +267,7 @@ impl<I: Interner> Relate<I> for ty::ExistentialProjection<I> {
         b: ty::ExistentialProjection<I>,
     ) -> RelateResult<I, ty::ExistentialProjection<I>> {
         if a.def_id != b.def_id {
-            Err(TypeError::ProjectionMismatched({
-                let a = a.def_id;
-                let b = b.def_id;
-                ExpectedFound::new(a, b)
-            }))
+            Err(TypeError::ProjectionMismatched(ExpectedFound::new(a.def_id, b.def_id)))
         } else {
             let term = relation.relate_with_variance(
                 ty::Invariant,
diff --git a/library/Cargo.lock b/library/Cargo.lock
index 5e49843dae06..f6c14bc58a04 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -283,12 +283,11 @@ dependencies = [
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.5"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+checksum = "8be87abb9e40db7466e0681dc8ecd9dcfd40360cb10b4c8fe24a7c4c3669b198"
 dependencies = [
  "rustc-std-workspace-core",
- "rustc-std-workspace-std",
 ]
 
 [[package]]
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index c5f16f3708d7..5dd828bd54e1 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -5,8 +5,8 @@
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
 pub use core::alloc::*;
-use core::hint;
 use core::ptr::{self, NonNull};
+use core::{cmp, hint};
 
 unsafe extern "Rust" {
     // These are the magic symbols to call the global allocator. rustc generates
@@ -182,7 +182,7 @@ pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
 impl Global {
     #[inline]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
+    fn alloc_impl_runtime(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
             0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)),
             // SAFETY: `layout` is non-zero in size,
@@ -194,10 +194,26 @@ impl Global {
         }
     }
 
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    fn deallocate_impl_runtime(ptr: NonNull<u8>, layout: Layout) {
+        if layout.size() != 0 {
+            // SAFETY:
+            // * We have checked that `layout` is non-zero in size.
+            // * The caller is obligated to provide a layout that "fits", and in this case,
+            //   "fit" always means a layout that is equal to the original, because our
+            //   `allocate()`, `grow()`, and `shrink()` implementations never returns a larger
+            //   allocation than requested.
+            // * Other conditions must be upheld by the caller, as per `Allocator::deallocate()`'s
+            //   safety documentation.
+            unsafe { dealloc(ptr.as_ptr(), layout) }
+        }
+    }
+
     // SAFETY: Same as `Allocator::grow`
     #[inline]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    unsafe fn grow_impl(
+    fn grow_impl_runtime(
         &self,
         ptr: NonNull<u8>,
         old_layout: Layout,
@@ -241,69 +257,16 @@ impl Global {
             },
         }
     }
-}
 
-#[unstable(feature = "allocator_api", issue = "32838")]
-unsafe impl Allocator for Global {
+    // SAFETY: Same as `Allocator::grow`
     #[inline]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-        self.alloc_impl(layout, false)
-    }
-
-    #[inline]
-    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-        self.alloc_impl(layout, true)
-    }
-
-    #[inline]
-    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
-        if layout.size() != 0 {
-            // SAFETY:
-            // * We have checked that `layout` is non-zero in size.
-            // * The caller is obligated to provide a layout that "fits", and in this case,
-            //   "fit" always means a layout that is equal to the original, because our
-            //   `allocate()`, `grow()`, and `shrink()` implementations never returns a larger
-            //   allocation than requested.
-            // * Other conditions must be upheld by the caller, as per `Allocator::deallocate()`'s
-            //   safety documentation.
-            unsafe { dealloc(ptr.as_ptr(), layout) }
-        }
-    }
-
-    #[inline]
-    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    unsafe fn grow(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        // SAFETY: all conditions must be upheld by the caller
-        unsafe { self.grow_impl(ptr, old_layout, new_layout, false) }
-    }
-
-    #[inline]
-    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    unsafe fn grow_zeroed(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        // SAFETY: all conditions must be upheld by the caller
-        unsafe { self.grow_impl(ptr, old_layout, new_layout, true) }
-    }
-
-    #[inline]
-    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    unsafe fn shrink(
+    fn shrink_impl_runtime(
         &self,
         ptr: NonNull<u8>,
         old_layout: Layout,
         new_layout: Layout,
+        _zeroed: bool,
     ) -> Result<NonNull<[u8]>, AllocError> {
         debug_assert!(
             new_layout.size() <= old_layout.size(),
@@ -340,6 +303,180 @@ unsafe impl Allocator for Global {
             },
         }
     }
+
+    // SAFETY: Same as `Allocator::allocate`
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
+        core::intrinsics::const_eval_select(
+            (layout, zeroed),
+            Global::alloc_impl_const,
+            Global::alloc_impl_runtime,
+        )
+    }
+
+    // SAFETY: Same as `Allocator::deallocate`
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const unsafe fn deallocate_impl(&self, ptr: NonNull<u8>, layout: Layout) {
+        core::intrinsics::const_eval_select(
+            (ptr, layout),
+            Global::deallocate_impl_const,
+            Global::deallocate_impl_runtime,
+        )
+    }
+
+    // SAFETY: Same as `Allocator::grow`
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const unsafe fn grow_impl(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+        zeroed: bool,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        core::intrinsics::const_eval_select(
+            (self, ptr, old_layout, new_layout, zeroed),
+            Global::grow_shrink_impl_const,
+            Global::grow_impl_runtime,
+        )
+    }
+
+    // SAFETY: Same as `Allocator::shrink`
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const unsafe fn shrink_impl(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        core::intrinsics::const_eval_select(
+            (self, ptr, old_layout, new_layout, false),
+            Global::grow_shrink_impl_const,
+            Global::shrink_impl_runtime,
+        )
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const fn alloc_impl_const(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
+        match layout.size() {
+            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)),
+            // SAFETY: `layout` is non-zero in size,
+            size => unsafe {
+                let raw_ptr = core::intrinsics::const_allocate(layout.size(), layout.align());
+                let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
+                if zeroed {
+                    // SAFETY: the pointer returned by `const_allocate` is valid to write to.
+                    ptr.write_bytes(0, size);
+                }
+                Ok(NonNull::slice_from_raw_parts(ptr, size))
+            },
+        }
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const fn deallocate_impl_const(ptr: NonNull<u8>, layout: Layout) {
+        if layout.size() != 0 {
+            // SAFETY: We checked for nonzero size; other preconditions must be upheld by caller.
+            unsafe {
+                core::intrinsics::const_deallocate(ptr.as_ptr(), layout.size(), layout.align());
+            }
+        }
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const fn grow_shrink_impl_const(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+        zeroed: bool,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        let new_ptr = self.alloc_impl(new_layout, zeroed)?;
+        // SAFETY: both pointers are valid and this operations is in bounds.
+        unsafe {
+            ptr::copy_nonoverlapping(
+                ptr.as_ptr(),
+                new_ptr.as_mut_ptr(),
+                cmp::min(old_layout.size(), new_layout.size()),
+            );
+        }
+        unsafe {
+            self.deallocate_impl(ptr, old_layout);
+        }
+        Ok(new_ptr)
+    }
+}
+
+#[unstable(feature = "allocator_api", issue = "32838")]
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+unsafe impl const Allocator for Global {
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        self.alloc_impl(layout, false)
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        self.alloc_impl(layout, true)
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        // SAFETY: all conditions must be upheld by the caller
+        unsafe { self.deallocate_impl(ptr, layout) }
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    unsafe fn grow(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        // SAFETY: all conditions must be upheld by the caller
+        unsafe { self.grow_impl(ptr, old_layout, new_layout, false) }
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    unsafe fn grow_zeroed(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        // SAFETY: all conditions must be upheld by the caller
+        unsafe { self.grow_impl(ptr, old_layout, new_layout, true) }
+    }
+
+    #[inline]
+    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+    unsafe fn shrink(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        // SAFETY: all conditions must be upheld by the caller
+        unsafe { self.shrink_impl(ptr, old_layout, new_layout) }
+    }
 }
 
 /// The allocator for `Box`.
diff --git a/library/alloc/src/borrow.rs b/library/alloc/src/borrow.rs
index aa973e0bb024..d1c7cd47da0f 100644
--- a/library/alloc/src/borrow.rs
+++ b/library/alloc/src/borrow.rs
@@ -16,19 +16,6 @@ use crate::fmt;
 #[cfg(not(no_global_oom_handling))]
 use crate::string::String;
 
-// FIXME(inference): const bounds removed due to inference regressions found by crater;
-//   see https://github.com/rust-lang/rust/issues/147964
-// #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized + ToOwned> Borrow<B> for Cow<'a, B>
-// where
-//     B::Owned: [const] Borrow<B>,
-{
-    fn borrow(&self) -> &B {
-        &**self
-    }
-}
-
 /// A generalization of `Clone` to borrowed data.
 ///
 /// Some types make it possible to go from borrowed to owned, usually by
@@ -192,6 +179,19 @@ where
     Owned(#[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned>::Owned),
 }
 
+// FIXME(inference): const bounds removed due to inference regressions found by crater;
+//   see https://github.com/rust-lang/rust/issues/147964
+// #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, B: ?Sized + ToOwned> Borrow<B> for Cow<'a, B>
+// where
+//     B::Owned: [const] Borrow<B>,
+{
+    fn borrow(&self) -> &B {
+        &**self
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<B: ?Sized + ToOwned> Clone for Cow<'_, B> {
     fn clone(&self) -> Self {
diff --git a/library/alloc/src/collections/mod.rs b/library/alloc/src/collections/mod.rs
index 212d7c8465b6..e09326759fd1 100644
--- a/library/alloc/src/collections/mod.rs
+++ b/library/alloc/src/collections/mod.rs
@@ -84,13 +84,14 @@ impl TryReserveError {
         reason = "Uncertain how much info should be exposed",
         issue = "48043"
     )]
-    pub fn kind(&self) -> TryReserveErrorKind {
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    pub const fn kind(&self) -> TryReserveErrorKind {
         self.kind.clone()
     }
 }
 
 /// Details of the allocation that caused a `TryReserveError`
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Debug)]
 #[unstable(
     feature = "try_reserve_kind",
     reason = "Uncertain how much info should be exposed",
@@ -120,6 +121,24 @@ pub enum TryReserveErrorKind {
     },
 }
 
+#[unstable(
+    feature = "try_reserve_kind",
+    reason = "Uncertain how much info should be exposed",
+    issue = "48043"
+)]
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[cfg(not(test))]
+impl const Clone for TryReserveErrorKind {
+    fn clone(&self) -> Self {
+        match self {
+            TryReserveErrorKind::CapacityOverflow => TryReserveErrorKind::CapacityOverflow,
+            TryReserveErrorKind::AllocError { layout, non_exhaustive: () } => {
+                TryReserveErrorKind::AllocError { layout: *layout, non_exhaustive: () }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 pub use realalloc::collections::TryReserveErrorKind;
 
diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs
index eee7be674c95..a43853604a2d 100644
--- a/library/alloc/src/collections/vec_deque/drain.rs
+++ b/library/alloc/src/collections/vec_deque/drain.rs
@@ -25,10 +25,10 @@ pub struct Drain<
     // drain_start is stored in deque.len
     pub(super) drain_len: usize,
     // index into the logical array, not the physical one (always lies in [0..deque.len))
-    idx: usize,
+    pub(super) idx: usize,
     // number of elements after the drained range
     pub(super) tail_len: usize,
-    remaining: usize,
+    pub(super) remaining: usize,
     // Needed to make Drain covariant over T
     _marker: PhantomData<&'a T>,
 }
@@ -53,7 +53,7 @@ impl<'a, T, A: Allocator> Drain<'a, T, A> {
 
     // Only returns pointers to the slices, as that's all we need
     // to drop them. May only be called if `self.remaining != 0`.
-    unsafe fn as_slices(&self) -> (*mut [T], *mut [T]) {
+    pub(super) unsafe fn as_slices(&self) -> (*mut [T], *mut [T]) {
         unsafe {
             let deque = self.deque.as_ref();
 
diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs
index f73ba795cbea..184e8b769347 100644
--- a/library/alloc/src/collections/vec_deque/spec_extend.rs
+++ b/library/alloc/src/collections/vec_deque/spec_extend.rs
@@ -1,7 +1,7 @@
 use core::iter::{Copied, Rev, TrustedLen};
 use core::slice;
 
-use super::VecDeque;
+use super::{Drain, VecDeque};
 use crate::alloc::Allocator;
 #[cfg(not(test))]
 use crate::vec;
@@ -77,8 +77,8 @@ where
 }
 
 #[cfg(not(test))]
-impl<T, A: Allocator> SpecExtend<T, vec::IntoIter<T>> for VecDeque<T, A> {
-    fn spec_extend(&mut self, mut iterator: vec::IntoIter<T>) {
+impl<T, A1: Allocator, A2: Allocator> SpecExtend<T, vec::IntoIter<T, A2>> for VecDeque<T, A1> {
+    fn spec_extend(&mut self, mut iterator: vec::IntoIter<T, A2>) {
         let slice = iterator.as_slice();
         self.reserve(slice.len());
 
@@ -153,23 +153,27 @@ where
 }
 
 #[cfg(not(test))]
-impl<T, A: Allocator> SpecExtendFront<T, vec::IntoIter<T>> for VecDeque<T, A> {
+impl<T, A1: Allocator, A2: Allocator> SpecExtendFront<T, vec::IntoIter<T, A2>> for VecDeque<T, A1> {
     #[track_caller]
-    fn spec_extend_front(&mut self, mut iterator: vec::IntoIter<T>) {
+    fn spec_extend_front(&mut self, mut iterator: vec::IntoIter<T, A2>) {
         let slice = iterator.as_slice();
-        // SAFETY: elements in the slice are forgotten after this call
+        self.reserve(slice.len());
+        // SAFETY: `slice.len()` space was just reserved and elements in the slice are forgotten after this call
         unsafe { prepend_reversed(self, slice) };
         iterator.forget_remaining_elements();
     }
 }
 
 #[cfg(not(test))]
-impl<T, A: Allocator> SpecExtendFront<T, Rev<vec::IntoIter<T>>> for VecDeque<T, A> {
+impl<T, A1: Allocator, A2: Allocator> SpecExtendFront<T, Rev<vec::IntoIter<T, A2>>>
+    for VecDeque<T, A1>
+{
     #[track_caller]
-    fn spec_extend_front(&mut self, iterator: Rev<vec::IntoIter<T>>) {
+    fn spec_extend_front(&mut self, iterator: Rev<vec::IntoIter<T, A2>>) {
         let mut iterator = iterator.into_inner();
         let slice = iterator.as_slice();
-        // SAFETY: elements in the slice are forgotten after this call
+        self.reserve(slice.len());
+        // SAFETY: `slice.len()` space was just reserved and elements in the slice are forgotten after this call
         unsafe { prepend(self, slice) };
         iterator.forget_remaining_elements();
     }
@@ -182,7 +186,8 @@ where
     #[track_caller]
     fn spec_extend_front(&mut self, iter: Copied<slice::Iter<'a, T>>) {
         let slice = iter.into_inner().as_slice();
-        // SAFETY: T is Copy because Copied<slice::Iter<'a, T>> is Iterator
+        self.reserve(slice.len());
+        // SAFETY: `slice.len()` space was just reserved and T is Copy because Copied<slice::Iter<'a, T>> is Iterator
         unsafe { prepend_reversed(self, slice) };
     }
 }
@@ -194,17 +199,69 @@ where
     #[track_caller]
     fn spec_extend_front(&mut self, iter: Rev<Copied<slice::Iter<'a, T>>>) {
         let slice = iter.into_inner().into_inner().as_slice();
-        // SAFETY: T is Copy because Rev<Copied<slice::Iter<'a, T>>> is Iterator
+        self.reserve(slice.len());
+        // SAFETY: `slice.len()` space was just reserved and T is Copy because Rev<Copied<slice::Iter<'a, T>>> is Iterator
         unsafe { prepend(self, slice) };
     }
 }
 
+impl<'a, T, A1: Allocator, A2: Allocator> SpecExtendFront<T, Drain<'a, T, A2>> for VecDeque<T, A1> {
+    #[track_caller]
+    fn spec_extend_front(&mut self, mut iter: Drain<'a, T, A2>) {
+        if iter.remaining == 0 {
+            return;
+        }
+
+        self.reserve(iter.remaining);
+        unsafe {
+            // SAFETY: iter.remaining != 0.
+            let (left, right) = iter.as_slices();
+            // SAFETY:
+            // - `iter.remaining` space was reserved, `iter.remaining == left.len() + right.len()`.
+            // - The elements in `left` and `right` are forgotten after these calls.
+            prepend_reversed(self, &*left);
+            prepend_reversed(self, &*right);
+        }
+
+        iter.idx += iter.remaining;
+        iter.remaining = 0;
+    }
+}
+
+impl<'a, T, A1: Allocator, A2: Allocator> SpecExtendFront<T, Rev<Drain<'a, T, A2>>>
+    for VecDeque<T, A1>
+{
+    #[track_caller]
+    fn spec_extend_front(&mut self, iter: Rev<Drain<'a, T, A2>>) {
+        let mut iter = iter.into_inner();
+
+        if iter.remaining == 0 {
+            return;
+        }
+
+        self.reserve(iter.remaining);
+        unsafe {
+            // SAFETY: iter.remaining != 0.
+            let (left, right) = iter.as_slices();
+            // SAFETY:
+            // - `iter.remaining` space was reserved, `iter.remaining == left.len() + right.len()`.
+            // - The elements in `left` and `right` are forgotten after these calls.
+            prepend(self, &*right);
+            prepend(self, &*left);
+        }
+
+        iter.idx += iter.remaining;
+        iter.remaining = 0;
+    }
+}
+
+/// Prepends elements of `slice` to `deque` using a copy.
+///
 /// # Safety
 ///
-/// Elements of `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.
+/// - `deque` must have space for `slice.len()` new elements.
+/// - Elements of `slice` will be copied into the deque, make sure to forget the elements if `T` is not `Copy`.
 unsafe fn prepend<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
-    deque.reserve(slice.len());
-
     unsafe {
         deque.head = deque.wrap_sub(deque.head, slice.len());
         deque.copy_slice(deque.head, slice);
@@ -212,12 +269,13 @@ unsafe fn prepend<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
     }
 }
 
+/// Prepends elements of `slice` to `deque` in reverse order using a copy.
+///
 /// # Safety
 ///
-/// Elements of `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.
+/// - `deque` must have space for `slice.len()` new elements.
+/// - Elements of `slice` will be copied into the deque, make sure to forget the elements if `T` is not `Copy`.
 unsafe fn prepend_reversed<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
-    deque.reserve(slice.len());
-
     unsafe {
         deque.head = deque.wrap_sub(deque.head, slice.len());
         deque.copy_slice_reversed(deque.head, slice);
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index b659e904c8a0..3ca9f3ae0bc9 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -101,10 +101,15 @@
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(coerce_unsized)]
+#![feature(const_clone)]
+#![feature(const_cmp)]
 #![feature(const_convert)]
 #![feature(const_default)]
+#![feature(const_destruct)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
+#![feature(const_option_ops)]
+#![feature(const_try)]
 #![feature(copied_into_inner)]
 #![feature(core_intrinsics)]
 #![feature(deprecated_suggestion)]
@@ -119,6 +124,7 @@
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
 #![feature(formatting_options)]
+#![feature(freeze)]
 #![feature(generic_atomic)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(inplace_iteration)]
@@ -126,6 +132,7 @@
 #![feature(iter_next_chunk)]
 #![feature(layout_for_ptr)]
 #![feature(legacy_receiver_trait)]
+#![feature(likely_unlikely)]
 #![feature(local_waker)]
 #![feature(maybe_uninit_uninit_array_transpose)]
 #![feature(panic_internals)]
@@ -171,6 +178,7 @@
 #![feature(const_trait_impl)]
 #![feature(coroutine_trait)]
 #![feature(decl_macro)]
+#![feature(derive_const)]
 #![feature(dropck_eyepatch)]
 #![feature(fundamental)]
 #![feature(hashmap_internals)]
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 15b0823df9ec..1e76710d3536 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -4,7 +4,7 @@
 // Note: This module is also included in the alloctests crate using #[path] to
 // run the tests. See the comment there for an explanation why this is the case.
 
-use core::marker::PhantomData;
+use core::marker::{Destruct, PhantomData};
 use core::mem::{ManuallyDrop, MaybeUninit, SizedTypeProperties};
 use core::ptr::{self, Alignment, NonNull, Unique};
 use core::{cmp, hint};
@@ -24,7 +24,7 @@ mod tests;
 // only one location which panics rather than a bunch throughout the module.
 #[cfg(not(no_global_oom_handling))]
 #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
-fn capacity_overflow() -> ! {
+const fn capacity_overflow() -> ! {
     panic!("capacity overflow");
 }
 
@@ -165,6 +165,30 @@ const fn min_non_zero_cap(size: usize) -> usize {
     }
 }
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
+const impl<T, A: [const] Allocator + [const] Destruct> RawVec<T, A> {
+    /// Like `with_capacity`, but parameterized over the choice of
+    /// allocator for the returned `RawVec`.
+    #[cfg(not(no_global_oom_handling))]
+    #[inline]
+    pub(crate) fn with_capacity_in(capacity: usize, alloc: A) -> Self {
+        Self {
+            inner: RawVecInner::with_capacity_in(capacity, alloc, T::LAYOUT),
+            _marker: PhantomData,
+        }
+    }
+
+    /// A specialized version of `self.reserve(len, 1)` which requires the
+    /// caller to ensure `len == self.capacity()`.
+    #[cfg(not(no_global_oom_handling))]
+    #[inline(never)]
+    pub(crate) fn grow_one(&mut self) {
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.grow_one(T::LAYOUT) }
+    }
+}
+
 impl<T, A: Allocator> RawVec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     pub(crate) const MIN_NON_ZERO_CAP: usize = min_non_zero_cap(size_of::<T>());
@@ -178,17 +202,6 @@ impl<T, A: Allocator> RawVec<T, A> {
         Self { inner: RawVecInner::new_in(alloc, Alignment::of::<T>()), _marker: PhantomData }
     }
 
-    /// Like `with_capacity`, but parameterized over the choice of
-    /// allocator for the returned `RawVec`.
-    #[cfg(not(no_global_oom_handling))]
-    #[inline]
-    pub(crate) fn with_capacity_in(capacity: usize, alloc: A) -> Self {
-        Self {
-            inner: RawVecInner::with_capacity_in(capacity, alloc, T::LAYOUT),
-            _marker: PhantomData,
-        }
-    }
-
     /// Like `try_with_capacity`, but parameterized over the choice of
     /// allocator for the returned `RawVec`.
     #[inline]
@@ -327,15 +340,6 @@ impl<T, A: Allocator> RawVec<T, A> {
         unsafe { self.inner.reserve(len, additional, T::LAYOUT) }
     }
 
-    /// A specialized version of `self.reserve(len, 1)` which requires the
-    /// caller to ensure `len == self.capacity()`.
-    #[cfg(not(no_global_oom_handling))]
-    #[inline(never)]
-    pub(crate) fn grow_one(&mut self) {
-        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
-        unsafe { self.inner.grow_one(T::LAYOUT) }
-    }
-
     /// The same as `reserve`, but returns on errors instead of panicking or aborting.
     pub(crate) fn try_reserve(
         &mut self,
@@ -405,14 +409,9 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
     }
 }
 
-impl<A: Allocator> RawVecInner<A> {
-    #[inline]
-    const fn new_in(alloc: A, align: Alignment) -> Self {
-        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero()));
-        // `cap: 0` means "unallocated". zero-sized types are ignored.
-        Self { ptr, cap: ZERO_CAP, alloc }
-    }
-
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
+const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     fn with_capacity_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
@@ -428,24 +427,6 @@ impl<A: Allocator> RawVecInner<A> {
         }
     }
 
-    #[inline]
-    fn try_with_capacity_in(
-        capacity: usize,
-        alloc: A,
-        elem_layout: Layout,
-    ) -> Result<Self, TryReserveError> {
-        Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc, elem_layout)
-    }
-
-    #[cfg(not(no_global_oom_handling))]
-    #[inline]
-    fn with_capacity_zeroed_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
-        match Self::try_allocate_in(capacity, AllocInit::Zeroed, alloc, elem_layout) {
-            Ok(res) => res,
-            Err(err) => handle_error(err),
-        }
-    }
-
     fn try_allocate_in(
         capacity: usize,
         init: AllocInit,
@@ -484,6 +465,118 @@ impl<A: Allocator> RawVecInner<A> {
         })
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    #[cfg(not(no_global_oom_handling))]
+    #[inline]
+    unsafe fn grow_one(&mut self, elem_layout: Layout) {
+        // SAFETY: Precondition passed to caller
+        if let Err(err) = unsafe { self.grow_amortized(self.cap.as_inner(), 1, elem_layout) } {
+            handle_error(err);
+        }
+    }
+
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - The sum of `len` and `additional` must be greater than the current capacity
+    unsafe fn grow_amortized(
+        &mut self,
+        len: usize,
+        additional: usize,
+        elem_layout: Layout,
+    ) -> Result<(), TryReserveError> {
+        // This is ensured by the calling contexts.
+        debug_assert!(additional > 0);
+
+        if elem_layout.size() == 0 {
+            // Since we return a capacity of `usize::MAX` when `elem_size` is
+            // 0, getting to here necessarily means the `RawVec` is overfull.
+            return Err(CapacityOverflow.into());
+        }
+
+        // Nothing we can really do about these checks, sadly.
+        let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
+
+        // This guarantees exponential growth. The doubling cannot overflow
+        // because `cap <= isize::MAX` and the type of `cap` is `usize`.
+        let cap = cmp::max(self.cap.as_inner() * 2, required_cap);
+        let cap = cmp::max(min_non_zero_cap(elem_layout.size()), cap);
+
+        // SAFETY:
+        // - cap >= len + additional
+        // - other preconditions passed to caller
+        let ptr = unsafe { self.finish_grow(cap, elem_layout)? };
+
+        // SAFETY: `finish_grow` would have failed if `cap > isize::MAX`
+        unsafe { self.set_ptr_and_cap(ptr, cap) };
+        Ok(())
+    }
+
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - `cap` must be greater than the current capacity
+    // not marked inline(never) since we want optimizers to be able to observe the specifics of this
+    // function, see tests/codegen-llvm/vec-reserve-extend.rs.
+    #[cold]
+    unsafe fn finish_grow(
+        &self,
+        cap: usize,
+        elem_layout: Layout,
+    ) -> Result<NonNull<[u8]>, TryReserveError> {
+        let new_layout = layout_array(cap, elem_layout)?;
+
+        let memory = if let Some((ptr, old_layout)) = unsafe { self.current_memory(elem_layout) } {
+            // FIXME(const-hack): switch to `debug_assert_eq`
+            debug_assert!(old_layout.align() == new_layout.align());
+            unsafe {
+                // The allocator checks for alignment equality
+                hint::assert_unchecked(old_layout.align() == new_layout.align());
+                self.alloc.grow(ptr, old_layout, new_layout)
+            }
+        } else {
+            self.alloc.allocate(new_layout)
+        };
+
+        // FIXME(const-hack): switch back to `map_err`
+        match memory {
+            Ok(memory) => Ok(memory),
+            Err(_) => Err(AllocError { layout: new_layout, non_exhaustive: () }.into()),
+        }
+    }
+}
+
+impl<A: Allocator> RawVecInner<A> {
+    #[inline]
+    const fn new_in(alloc: A, align: Alignment) -> Self {
+        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero()));
+        // `cap: 0` means "unallocated". zero-sized types are ignored.
+        Self { ptr, cap: ZERO_CAP, alloc }
+    }
+
+    #[inline]
+    fn try_with_capacity_in(
+        capacity: usize,
+        alloc: A,
+        elem_layout: Layout,
+    ) -> Result<Self, TryReserveError> {
+        Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc, elem_layout)
+    }
+
+    #[cfg(not(no_global_oom_handling))]
+    #[inline]
+    fn with_capacity_zeroed_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
+        match Self::try_allocate_in(capacity, AllocInit::Zeroed, alloc, elem_layout) {
+            Ok(res) => res,
+            Err(err) => handle_error(err),
+        }
+    }
+
     #[inline]
     unsafe fn from_raw_parts_in(ptr: *mut u8, cap: Cap, alloc: A) -> Self {
         Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap, alloc }
@@ -519,7 +612,8 @@ impl<A: Allocator> RawVecInner<A> {
     ///   initially construct `self`
     /// - `elem_layout`'s size must be a multiple of its alignment
     #[inline]
-    unsafe fn current_memory(&self, elem_layout: Layout) -> Option<(NonNull<u8>, Layout)> {
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const unsafe fn current_memory(&self, elem_layout: Layout) -> Option<(NonNull<u8>, Layout)> {
         if elem_layout.size() == 0 || self.cap.as_inner() == 0 {
             None
         } else {
@@ -566,19 +660,6 @@ impl<A: Allocator> RawVecInner<A> {
         }
     }
 
-    /// # Safety
-    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
-    ///   initially construct `self`
-    /// - `elem_layout`'s size must be a multiple of its alignment
-    #[cfg(not(no_global_oom_handling))]
-    #[inline]
-    unsafe fn grow_one(&mut self, elem_layout: Layout) {
-        // SAFETY: Precondition passed to caller
-        if let Err(err) = unsafe { self.grow_amortized(self.cap.as_inner(), 1, elem_layout) } {
-            handle_error(err);
-        }
-    }
-
     /// # Safety
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
@@ -651,12 +732,13 @@ impl<A: Allocator> RawVecInner<A> {
     }
 
     #[inline]
-    fn needs_to_grow(&self, len: usize, additional: usize, elem_layout: Layout) -> bool {
+    const fn needs_to_grow(&self, len: usize, additional: usize, elem_layout: Layout) -> bool {
         additional > self.capacity(elem_layout.size()).wrapping_sub(len)
     }
 
     #[inline]
-    unsafe fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) {
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    const unsafe fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) {
         // Allocators currently return a `NonNull<[u8]>` whose length matches
         // the size requested. If that ever changes, the capacity here should
         // change to `ptr.len() / size_of::<T>()`.
@@ -664,44 +746,6 @@ impl<A: Allocator> RawVecInner<A> {
         self.cap = unsafe { Cap::new_unchecked(cap) };
     }
 
-    /// # Safety
-    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
-    ///   initially construct `self`
-    /// - `elem_layout`'s size must be a multiple of its alignment
-    /// - The sum of `len` and `additional` must be greater than the current capacity
-    unsafe fn grow_amortized(
-        &mut self,
-        len: usize,
-        additional: usize,
-        elem_layout: Layout,
-    ) -> Result<(), TryReserveError> {
-        // This is ensured by the calling contexts.
-        debug_assert!(additional > 0);
-
-        if elem_layout.size() == 0 {
-            // Since we return a capacity of `usize::MAX` when `elem_size` is
-            // 0, getting to here necessarily means the `RawVec` is overfull.
-            return Err(CapacityOverflow.into());
-        }
-
-        // Nothing we can really do about these checks, sadly.
-        let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
-
-        // This guarantees exponential growth. The doubling cannot overflow
-        // because `cap <= isize::MAX` and the type of `cap` is `usize`.
-        let cap = cmp::max(self.cap.as_inner() * 2, required_cap);
-        let cap = cmp::max(min_non_zero_cap(elem_layout.size()), cap);
-
-        // SAFETY:
-        // - cap >= len + additional
-        // - other preconditions passed to caller
-        let ptr = unsafe { self.finish_grow(cap, elem_layout)? };
-
-        // SAFETY: `finish_grow` would have failed if `cap > isize::MAX`
-        unsafe { self.set_ptr_and_cap(ptr, cap) };
-        Ok(())
-    }
-
     /// # Safety
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
@@ -729,35 +773,6 @@ impl<A: Allocator> RawVecInner<A> {
         Ok(())
     }
 
-    /// # Safety
-    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
-    ///   initially construct `self`
-    /// - `elem_layout`'s size must be a multiple of its alignment
-    /// - `cap` must be greater than the current capacity
-    // not marked inline(never) since we want optimizers to be able to observe the specifics of this
-    // function, see tests/codegen-llvm/vec-reserve-extend.rs.
-    #[cold]
-    unsafe fn finish_grow(
-        &self,
-        cap: usize,
-        elem_layout: Layout,
-    ) -> Result<NonNull<[u8]>, TryReserveError> {
-        let new_layout = layout_array(cap, elem_layout)?;
-
-        let memory = if let Some((ptr, old_layout)) = unsafe { self.current_memory(elem_layout) } {
-            debug_assert_eq!(old_layout.align(), new_layout.align());
-            unsafe {
-                // The allocator checks for alignment equality
-                hint::assert_unchecked(old_layout.align() == new_layout.align());
-                self.alloc.grow(ptr, old_layout, new_layout)
-            }
-        } else {
-            self.alloc.allocate(new_layout)
-        };
-
-        memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into())
-    }
-
     /// # Safety
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
@@ -839,7 +854,8 @@ impl<A: Allocator> RawVecInner<A> {
 #[cfg(not(no_global_oom_handling))]
 #[cold]
 #[optimize(size)]
-fn handle_error(e: TryReserveError) -> ! {
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const fn handle_error(e: TryReserveError) -> ! {
     match e.kind() {
         CapacityOverflow => capacity_overflow(),
         AllocError { layout, .. } => handle_alloc_error(layout),
@@ -847,6 +863,11 @@ fn handle_error(e: TryReserveError) -> ! {
 }
 
 #[inline]
-fn layout_array(cap: usize, elem_layout: Layout) -> Result<Layout, TryReserveError> {
-    elem_layout.repeat(cap).map(|(layout, _pad)| layout).map_err(|_| CapacityOverflow.into())
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const fn layout_array(cap: usize, elem_layout: Layout) -> Result<Layout, TryReserveError> {
+    // FIXME(const-hack) return to using `map` and `map_err` once `const_closures` is implemented
+    match elem_layout.repeat(cap) {
+        Ok((layout, _pad)) => Ok(layout),
+        Err(_) => Err(CapacityOverflow.into()),
+    }
 }
diff --git a/library/alloc/src/task.rs b/library/alloc/src/task.rs
index b4116f4988b6..aa1901314e37 100644
--- a/library/alloc/src/task.rs
+++ b/library/alloc/src/task.rs
@@ -127,6 +127,44 @@ impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker {
     }
 }
 
+/// Converts a closure into a [`Waker`].
+///
+/// The closure gets called every time the waker is woken.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(waker_fn)]
+/// use std::task::waker_fn;
+///
+/// let waker = waker_fn(|| println!("woken"));
+///
+/// waker.wake_by_ref(); // Prints "woken".
+/// waker.wake();        // Prints "woken".
+/// ```
+#[cfg(target_has_atomic = "ptr")]
+#[unstable(feature = "waker_fn", issue = "149580")]
+pub fn waker_fn<F: Fn() + Send + Sync + 'static>(f: F) -> Waker {
+    struct WakeFn<F> {
+        f: F,
+    }
+
+    impl<F> Wake for WakeFn<F>
+    where
+        F: Fn(),
+    {
+        fn wake(self: Arc<Self>) {
+            (self.f)()
+        }
+
+        fn wake_by_ref(self: &Arc<Self>) {
+            (self.f)()
+        }
+    }
+
+    Waker::from(Arc::new(WakeFn { f }))
+}
+
 // NB: This private function for constructing a RawWaker is used, rather than
 // inlining this into the `From<Arc<W>> for RawWaker` impl, to ensure that
 // the safety of `From<Arc<W>> for Waker` does not depend on the correct
@@ -306,6 +344,45 @@ impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker {
     }
 }
 
+/// Converts a closure into a [`LocalWaker`].
+///
+/// The closure gets called every time the local waker is woken.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(local_waker)]
+/// #![feature(waker_fn)]
+/// use std::task::local_waker_fn;
+///
+/// let waker = local_waker_fn(|| println!("woken"));
+///
+/// waker.wake_by_ref(); // Prints "woken".
+/// waker.wake();        // Prints "woken".
+/// ```
+// #[unstable(feature = "local_waker", issue = "118959")]
+#[unstable(feature = "waker_fn", issue = "149580")]
+pub fn local_waker_fn<F: Fn() + Send + Sync + 'static>(f: F) -> LocalWaker {
+    struct LocalWakeFn<F> {
+        f: F,
+    }
+
+    impl<F> LocalWake for LocalWakeFn<F>
+    where
+        F: Fn(),
+    {
+        fn wake(self: Rc<Self>) {
+            (self.f)()
+        }
+
+        fn wake_by_ref(self: &Rc<Self>) {
+            (self.f)()
+        }
+    }
+
+    LocalWaker::from(Rc::new(LocalWakeFn { f }))
+}
+
 // NB: This private function for constructing a RawWaker is used, rather than
 // inlining this into the `From<Rc<W>> for RawWaker` impl, to ensure that
 // the safety of `From<Rc<W>> for Waker` does not depend on the correct
diff --git a/library/alloc/src/vec/in_place_drop.rs b/library/alloc/src/vec/in_place_drop.rs
index 997c4c7525b5..c8cc758ac15c 100644
--- a/library/alloc/src/vec/in_place_drop.rs
+++ b/library/alloc/src/vec/in_place_drop.rs
@@ -1,6 +1,5 @@
 use core::marker::PhantomData;
 use core::ptr::{self, NonNull, drop_in_place};
-use core::slice::{self};
 
 use crate::alloc::Global;
 use crate::raw_vec::RawVec;
@@ -22,7 +21,7 @@ impl<T> Drop for InPlaceDrop<T> {
     #[inline]
     fn drop(&mut self) {
         unsafe {
-            ptr::drop_in_place(slice::from_raw_parts_mut(self.inner, self.len()));
+            ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.inner, self.len()));
         }
     }
 }
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index f8a96e358d6d..379e964f0a0c 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -81,12 +81,14 @@ use core::cmp::Ordering;
 use core::hash::{Hash, Hasher};
 #[cfg(not(no_global_oom_handling))]
 use core::iter;
-use core::marker::PhantomData;
+#[cfg(not(no_global_oom_handling))]
+use core::marker::Destruct;
+use core::marker::{Freeze, PhantomData};
 use core::mem::{self, Assume, ManuallyDrop, MaybeUninit, SizedTypeProperties, TransmuteFrom};
 use core::ops::{self, Index, IndexMut, Range, RangeBounds};
 use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
-use core::{fmt, intrinsics, ub_checks};
+use core::{fmt, hint, intrinsics, ub_checks};
 
 #[stable(feature = "extract_if", since = "1.87.0")]
 pub use self::extract_if::ExtractIf;
@@ -519,7 +521,8 @@ impl<T> Vec<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     #[rustc_diagnostic_item = "vec_with_capacity"]
-    pub fn with_capacity(capacity: usize) -> Self {
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    pub const fn with_capacity(capacity: usize) -> Self {
         Self::with_capacity_in(capacity, Global)
     }
 
@@ -881,29 +884,28 @@ impl<T> Vec<T> {
         // SAFETY: A `Vec` always has a non-null pointer.
         (unsafe { NonNull::new_unchecked(ptr) }, len, capacity)
     }
+
+    /// Interns the `Vec<T>`, making the underlying memory read-only. This method should be
+    /// called during compile time. (This is a no-op if called during runtime)
+    ///
+    /// This method must be called if the memory used by `Vec` needs to appear in the final
+    /// values of constants.
+    #[unstable(feature = "const_heap", issue = "79597")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    pub const fn const_make_global(mut self) -> &'static [T]
+    where
+        T: Freeze,
+    {
+        unsafe { core::intrinsics::const_make_global(self.as_mut_ptr().cast()) };
+        let me = ManuallyDrop::new(self);
+        unsafe { slice::from_raw_parts(me.as_ptr(), me.len) }
+    }
 }
 
-impl<T, A: Allocator> Vec<T, A> {
-    /// Constructs a new, empty `Vec<T, A>`.
-    ///
-    /// The vector will not allocate until elements are pushed onto it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(allocator_api)]
-    ///
-    /// use std::alloc::System;
-    ///
-    /// # #[allow(unused_mut)]
-    /// let mut vec: Vec<i32, _> = Vec::new_in(System);
-    /// ```
-    #[inline]
-    #[unstable(feature = "allocator_api", issue = "32838")]
-    pub const fn new_in(alloc: A) -> Self {
-        Vec { buf: RawVec::new_in(alloc), len: 0 }
-    }
-
+#[cfg(not(no_global_oom_handling))]
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
+const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     /// Constructs a new, empty `Vec<T, A>` with at least the specified capacity
     /// with the provided allocator.
     ///
@@ -959,13 +961,109 @@ impl<T, A: Allocator> Vec<T, A> {
     /// let vec_units = Vec::<(), System>::with_capacity_in(10, System);
     /// assert_eq!(vec_units.capacity(), usize::MAX);
     /// ```
-    #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
     }
 
+    /// Appends an element to the back of a collection.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut vec = vec![1, 2];
+    /// vec.push(3);
+    /// assert_eq!(vec, [1, 2, 3]);
+    /// ```
+    ///
+    /// # Time complexity
+    ///
+    /// Takes amortized *O*(1) time. If the vector's length would exceed its
+    /// capacity after the push, *O*(*capacity*) time is taken to copy the
+    /// vector's elements to a larger allocation. This expensive operation is
+    /// offset by the *capacity* *O*(1) insertions it allows.
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_confusables("push_back", "put", "append")]
+    pub fn push(&mut self, value: T) {
+        let _ = self.push_mut(value);
+    }
+
+    /// Appends an element to the back of a collection, returning a reference to it.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(push_mut)]
+    ///
+    ///
+    /// let mut vec = vec![1, 2];
+    /// let last = vec.push_mut(3);
+    /// assert_eq!(*last, 3);
+    /// assert_eq!(vec, [1, 2, 3]);
+    ///
+    /// let last = vec.push_mut(3);
+    /// *last += 1;
+    /// assert_eq!(vec, [1, 2, 3, 4]);
+    /// ```
+    ///
+    /// # Time complexity
+    ///
+    /// Takes amortized *O*(1) time. If the vector's length would exceed its
+    /// capacity after the push, *O*(*capacity*) time is taken to copy the
+    /// vector's elements to a larger allocation. This expensive operation is
+    /// offset by the *capacity* *O*(1) insertions it allows.
+    #[inline]
+    #[unstable(feature = "push_mut", issue = "135974")]
+    #[must_use = "if you don't need a reference to the value, use `Vec::push` instead"]
+    pub fn push_mut(&mut self, value: T) -> &mut T {
+        // Inform codegen that the length does not change across grow_one().
+        let len = self.len;
+        // This will panic or abort if we would allocate > isize::MAX bytes
+        // or if the length increment would overflow for zero-sized types.
+        if len == self.buf.capacity() {
+            self.buf.grow_one();
+        }
+        unsafe {
+            let end = self.as_mut_ptr().add(len);
+            ptr::write(end, value);
+            self.len = len + 1;
+            // SAFETY: We just wrote a value to the pointer that will live the lifetime of the reference.
+            &mut *end
+        }
+    }
+}
+
+impl<T, A: Allocator> Vec<T, A> {
+    /// Constructs a new, empty `Vec<T, A>`.
+    ///
+    /// The vector will not allocate until elements are pushed onto it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(allocator_api)]
+    ///
+    /// use std::alloc::System;
+    ///
+    /// # #[allow(unused_mut)]
+    /// let mut vec: Vec<i32, _> = Vec::new_in(System);
+    /// ```
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub const fn new_in(alloc: A) -> Self {
+        Vec { buf: RawVec::new_in(alloc), len: 0 }
+    }
+
     /// Constructs a new, empty `Vec<T, A>` with at least the specified capacity
     /// with the provided allocator.
     ///
@@ -1649,7 +1747,11 @@ impl<T, A: Allocator> Vec<T, A> {
         // * We only construct `&mut` references to `self.buf` through `&mut self` methods; borrow-
         //   check ensures that it is not possible to mutably alias `self.buf` within the
         //   returned lifetime.
-        unsafe { slice::from_raw_parts(self.as_ptr(), self.len) }
+        unsafe {
+            // normally this would use `slice::from_raw_parts`, but it's
+            // instantiated often enough that avoiding the UB check is worth it
+            &*core::intrinsics::aggregate_raw_ptr::<*const [T], _, _>(self.as_ptr(), self.len)
+        }
     }
 
     /// Extracts a mutable slice of the entire vector.
@@ -1681,7 +1783,11 @@ impl<T, A: Allocator> Vec<T, A> {
         // * We only construct references to `self.buf` through `&self` and `&mut self` methods;
         //   borrow-check ensures that it is not possible to construct a reference to `self.buf`
         //   within the returned lifetime.
-        unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
+        unsafe {
+            // normally this would use `slice::from_raw_parts_mut`, but it's
+            // instantiated often enough that avoiding the UB check is worth it
+            &mut *core::intrinsics::aggregate_raw_ptr::<*mut [T], _, _>(self.as_mut_ptr(), self.len)
+        }
     }
 
     /// Returns a raw pointer to the vector's buffer, or a dangling raw pointer
@@ -2292,13 +2398,8 @@ impl<T, A: Allocator> Vec<T, A> {
             return;
         }
 
-        // Avoid double drop if the drop guard is not executed,
-        // since we may make some holes during the process.
-        unsafe { self.set_len(0) };
-
         // Vec: [Kept, Kept, Hole, Hole, Hole, Hole, Unchecked, Unchecked]
-        //      |<-              processed len   ->| ^- next to check
-        //                  |<-  deleted cnt     ->|
+        //      |            ^- write                ^- read             |
         //      |<-              original_len                          ->|
         // Kept: Elements which predicate returns true on.
         // Hole: Moved or dropped element slot.
@@ -2307,77 +2408,77 @@ impl<T, A: Allocator> Vec<T, A> {
         // This drop guard will be invoked when predicate or `drop` of element panicked.
         // It shifts unchecked elements to cover holes and `set_len` to the correct length.
         // In cases when predicate and `drop` never panick, it will be optimized out.
-        struct BackshiftOnDrop<'a, T, A: Allocator> {
+        struct PanicGuard<'a, T, A: Allocator> {
             v: &'a mut Vec<T, A>,
-            processed_len: usize,
-            deleted_cnt: usize,
+            read: usize,
+            write: usize,
             original_len: usize,
         }
 
-        impl<T, A: Allocator> Drop for BackshiftOnDrop<'_, T, A> {
+        impl<T, A: Allocator> Drop for PanicGuard<'_, T, A> {
+            #[cold]
             fn drop(&mut self) {
-                if self.deleted_cnt > 0 {
-                    // SAFETY: Trailing unchecked items must be valid since we never touch them.
-                    unsafe {
-                        ptr::copy(
-                            self.v.as_ptr().add(self.processed_len),
-                            self.v.as_mut_ptr().add(self.processed_len - self.deleted_cnt),
-                            self.original_len - self.processed_len,
-                        );
-                    }
+                let remaining = self.original_len - self.read;
+                // SAFETY: Trailing unchecked items must be valid since we never touch them.
+                unsafe {
+                    ptr::copy(
+                        self.v.as_ptr().add(self.read),
+                        self.v.as_mut_ptr().add(self.write),
+                        remaining,
+                    );
                 }
                 // SAFETY: After filling holes, all items are in contiguous memory.
                 unsafe {
-                    self.v.set_len(self.original_len - self.deleted_cnt);
+                    self.v.set_len(self.write + remaining);
                 }
             }
         }
 
-        let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };
-
-        fn process_loop<F, T, A: Allocator, const DELETED: bool>(
-            original_len: usize,
-            f: &mut F,
-            g: &mut BackshiftOnDrop<'_, T, A>,
-        ) where
-            F: FnMut(&mut T) -> bool,
-        {
-            while g.processed_len != original_len {
-                // SAFETY: Unchecked element must be valid.
-                let cur = unsafe { &mut *g.v.as_mut_ptr().add(g.processed_len) };
-                if !f(cur) {
-                    // Advance early to avoid double drop if `drop_in_place` panicked.
-                    g.processed_len += 1;
-                    g.deleted_cnt += 1;
-                    // SAFETY: We never touch this element again after dropped.
-                    unsafe { ptr::drop_in_place(cur) };
-                    // We already advanced the counter.
-                    if DELETED {
-                        continue;
-                    } else {
-                        break;
-                    }
-                }
-                if DELETED {
-                    // SAFETY: `deleted_cnt` > 0, so the hole slot must not overlap with current element.
-                    // We use copy for move, and never touch this element again.
-                    unsafe {
-                        let hole_slot = g.v.as_mut_ptr().add(g.processed_len - g.deleted_cnt);
-                        ptr::copy_nonoverlapping(cur, hole_slot, 1);
-                    }
-                }
-                g.processed_len += 1;
+        let mut read = 0;
+        loop {
+            // SAFETY: read < original_len
+            let cur = unsafe { self.get_unchecked_mut(read) };
+            if hint::unlikely(!f(cur)) {
+                break;
+            }
+            read += 1;
+            if read == original_len {
+                // All elements are kept, return early.
+                return;
             }
         }
 
-        // Stage 1: Nothing was deleted.
-        process_loop::<F, T, A, false>(original_len, &mut f, &mut g);
+        // Critical section starts here and at least one element is going to be removed.
+        // Advance `g.read` early to avoid double drop if `drop_in_place` panicked.
+        let mut g = PanicGuard { v: self, read: read + 1, write: read, original_len };
+        // SAFETY: previous `read` is always less than original_len.
+        unsafe { ptr::drop_in_place(&mut *g.v.as_mut_ptr().add(read)) };
 
-        // Stage 2: Some elements were deleted.
-        process_loop::<F, T, A, true>(original_len, &mut f, &mut g);
+        while g.read < g.original_len {
+            // SAFETY: `read` is always less than original_len.
+            let cur = unsafe { &mut *g.v.as_mut_ptr().add(g.read) };
+            if !f(cur) {
+                // Advance `read` early to avoid double drop if `drop_in_place` panicked.
+                g.read += 1;
+                // SAFETY: We never touch this element again after dropped.
+                unsafe { ptr::drop_in_place(cur) };
+            } else {
+                // SAFETY: `read` > `write`, so the slots don't overlap.
+                // We use copy for move, and never touch the source element again.
+                unsafe {
+                    let hole = g.v.as_mut_ptr().add(g.write);
+                    ptr::copy_nonoverlapping(cur, hole, 1);
+                }
+                g.write += 1;
+                g.read += 1;
+            }
+        }
 
-        // All item are processed. This can be optimized to `set_len` by LLVM.
-        drop(g);
+        // We are leaving the critical section and no panic happened,
+        // Commit the length change and forget the guard.
+        // SAFETY: `write` is always less than or equal to original_len.
+        unsafe { g.v.set_len(g.write) };
+        mem::forget(g);
     }
 
     /// Removes all but the first of consecutive elements in the vector that resolve to the same
@@ -2551,34 +2652,6 @@ impl<T, A: Allocator> Vec<T, A> {
         }
     }
 
-    /// Appends an element to the back of a collection.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2];
-    /// vec.push(3);
-    /// assert_eq!(vec, [1, 2, 3]);
-    /// ```
-    ///
-    /// # Time complexity
-    ///
-    /// Takes amortized *O*(1) time. If the vector's length would exceed its
-    /// capacity after the push, *O*(*capacity*) time is taken to copy the
-    /// vector's elements to a larger allocation. This expensive operation is
-    /// offset by the *capacity* *O*(1) insertions it allows.
-    #[cfg(not(no_global_oom_handling))]
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_confusables("push_back", "put", "append")]
-    pub fn push(&mut self, value: T) {
-        let _ = self.push_mut(value);
-    }
-
     /// Appends an element and returns a reference to it if there is sufficient spare capacity,
     /// otherwise an error is returned with the element.
     ///
@@ -2632,55 +2705,6 @@ impl<T, A: Allocator> Vec<T, A> {
         }
     }
 
-    /// Appends an element to the back of a collection, returning a reference to it.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity exceeds `isize::MAX` _bytes_.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(push_mut)]
-    ///
-    ///
-    /// let mut vec = vec![1, 2];
-    /// let last = vec.push_mut(3);
-    /// assert_eq!(*last, 3);
-    /// assert_eq!(vec, [1, 2, 3]);
-    ///
-    /// let last = vec.push_mut(3);
-    /// *last += 1;
-    /// assert_eq!(vec, [1, 2, 3, 4]);
-    /// ```
-    ///
-    /// # Time complexity
-    ///
-    /// Takes amortized *O*(1) time. If the vector's length would exceed its
-    /// capacity after the push, *O*(*capacity*) time is taken to copy the
-    /// vector's elements to a larger allocation. This expensive operation is
-    /// offset by the *capacity* *O*(1) insertions it allows.
-    #[cfg(not(no_global_oom_handling))]
-    #[inline]
-    #[unstable(feature = "push_mut", issue = "135974")]
-    #[must_use = "if you don't need a reference to the value, use `Vec::push` instead"]
-    pub fn push_mut(&mut self, value: T) -> &mut T {
-        // Inform codegen that the length does not change across grow_one().
-        let len = self.len;
-        // This will panic or abort if we would allocate > isize::MAX bytes
-        // or if the length increment would overflow for zero-sized types.
-        if len == self.buf.capacity() {
-            self.buf.grow_one();
-        }
-        unsafe {
-            let end = self.as_mut_ptr().add(len);
-            ptr::write(end, value);
-            self.len = len + 1;
-            // SAFETY: We just wrote a value to the pointer that will live the lifetime of the reference.
-            &mut *end
-        }
-    }
-
     /// Removes the last element from a vector and returns it, or [`None`] if it
     /// is empty.
     ///
diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs
index f5bcd3ec9d82..7c908841c90e 100644
--- a/library/alloc/src/vec/spec_extend.rs
+++ b/library/alloc/src/vec/spec_extend.rs
@@ -28,8 +28,8 @@ where
     }
 }
 
-impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
-    fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
+impl<T, A1: Allocator, A2: Allocator> SpecExtend<T, IntoIter<T, A2>> for Vec<T, A1> {
+    fn spec_extend(&mut self, mut iterator: IntoIter<T, A2>) {
         unsafe {
             self.append_elements(iterator.as_slice() as _);
         }
diff --git a/library/alloctests/benches/btree/map.rs b/library/alloctests/benches/btree/map.rs
index 778065fd9657..c2bf43caf131 100644
--- a/library/alloctests/benches/btree/map.rs
+++ b/library/alloctests/benches/btree/map.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use std::ops::RangeBounds;
 
 use rand::Rng;
+use rand::distr::{Distribution, Uniform};
 use rand::seq::SliceRandom;
 use test::{Bencher, black_box};
 
@@ -106,7 +107,8 @@ macro_rules! map_find_rand_bench {
 
             // setup
             let mut rng = crate::bench_rng();
-            let mut keys: Vec<_> = (0..n).map(|_| rng.random::<u32>() % n).collect();
+            let mut keys: Vec<_> =
+                Uniform::new(0, n).unwrap().sample_iter(&mut rng).take(n as usize).collect();
 
             for &k in &keys {
                 map.insert(k, k);
diff --git a/library/alloctests/lib.rs b/library/alloctests/lib.rs
index cd02c0a53857..b85fc8eb9970 100644
--- a/library/alloctests/lib.rs
+++ b/library/alloctests/lib.rs
@@ -20,6 +20,13 @@
 #![feature(assert_matches)]
 #![feature(box_vec_non_null)]
 #![feature(char_internals)]
+#![feature(const_alloc_error)]
+#![feature(const_cmp)]
+#![feature(const_convert)]
+#![feature(const_destruct)]
+#![feature(const_heap)]
+#![feature(const_option_ops)]
+#![feature(const_try)]
 #![feature(copied_into_inner)]
 #![feature(core_intrinsics)]
 #![feature(exact_size_is_empty)]
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 34c65bf787c8..c7fdc2054f71 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -1,5 +1,6 @@
 #![feature(allocator_api)]
 #![feature(alloc_layout_extra)]
+#![feature(const_heap)]
 #![feature(deque_extend_front)]
 #![feature(iter_array_chunks)]
 #![feature(assert_matches)]
@@ -20,6 +21,8 @@
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(binary_heap_drain_sorted)]
 #![feature(slice_ptr_get)]
+#![feature(slice_range)]
+#![feature(slice_partial_sort_unstable)]
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]
diff --git a/library/alloctests/tests/sort/mod.rs b/library/alloctests/tests/sort/mod.rs
index 0e2494ca9d34..e2e141a02b59 100644
--- a/library/alloctests/tests/sort/mod.rs
+++ b/library/alloctests/tests/sort/mod.rs
@@ -12,6 +12,7 @@ pub trait Sort {
 
 mod ffi_types;
 mod known_good_stable_sort;
+mod partial;
 mod patterns;
 mod tests;
 mod zipf;
diff --git a/library/alloctests/tests/sort/partial.rs b/library/alloctests/tests/sort/partial.rs
new file mode 100644
index 000000000000..679841b91e8d
--- /dev/null
+++ b/library/alloctests/tests/sort/partial.rs
@@ -0,0 +1,88 @@
+use std::fmt::Debug;
+use std::ops::{Range, RangeBounds};
+use std::slice;
+
+use super::patterns;
+
+fn check_is_partial_sorted<T: Ord + Clone + Debug, R: RangeBounds<usize>>(v: &mut [T], range: R) {
+    let Range { start, end } = slice::range(range, ..v.len());
+    v.partial_sort_unstable(start..end);
+
+    let max_before = v[..start].iter().max().into_iter();
+    let sorted_range = v[start..end].into_iter();
+    let min_after = v[end..].iter().min().into_iter();
+    let seq = max_before.chain(sorted_range).chain(min_after);
+    assert!(seq.is_sorted());
+}
+
+fn check_is_partial_sorted_ranges<T: Ord + Clone + Debug>(v: &[T]) {
+    let len = v.len();
+
+    check_is_partial_sorted::<T, _>(&mut v.to_vec(), ..);
+    check_is_partial_sorted::<T, _>(&mut v.to_vec(), 0..0);
+    check_is_partial_sorted::<T, _>(&mut v.to_vec(), len..len);
+
+    if len > 0 {
+        check_is_partial_sorted::<T, _>(&mut v.to_vec(), len - 1..len - 1);
+        check_is_partial_sorted::<T, _>(&mut v.to_vec(), 0..1);
+        check_is_partial_sorted::<T, _>(&mut v.to_vec(), len - 1..len);
+
+        for mid in 1..len {
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), 0..mid);
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), mid..len);
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), mid..mid);
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), mid - 1..mid + 1);
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), mid - 1..mid);
+            check_is_partial_sorted::<T, _>(&mut v.to_vec(), mid..mid + 1);
+        }
+
+        let quarters = [0, len / 4, len / 2, (3 * len) / 4, len];
+        for &start in &quarters {
+            for &end in &quarters {
+                if start < end {
+                    check_is_partial_sorted::<T, _>(&mut v.to_vec(), start..end);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn basic_impl() {
+    check_is_partial_sorted::<i32, _>(&mut [], ..);
+    check_is_partial_sorted::<(), _>(&mut [], ..);
+    check_is_partial_sorted::<(), _>(&mut [()], ..);
+    check_is_partial_sorted::<(), _>(&mut [(), ()], ..);
+    check_is_partial_sorted::<(), _>(&mut [(), (), ()], ..);
+    check_is_partial_sorted::<i32, _>(&mut [], ..);
+
+    check_is_partial_sorted::<i32, _>(&mut [77], ..);
+    check_is_partial_sorted::<i32, _>(&mut [2, 3], ..);
+    check_is_partial_sorted::<i32, _>(&mut [2, 3, 6], ..);
+    check_is_partial_sorted::<i32, _>(&mut [2, 3, 99, 6], ..);
+    check_is_partial_sorted::<i32, _>(&mut [2, 7709, 400, 90932], ..);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], ..);
+
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 0..0);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 0..1);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 0..5);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 0..7);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 7..7);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 6..7);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 5..7);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 5..5);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 4..5);
+    check_is_partial_sorted::<i32, _>(&mut [15, -1, 3, -1, -3, -1, 7], 4..6);
+}
+
+#[test]
+fn random_patterns() {
+    check_is_partial_sorted_ranges(&patterns::random(10));
+    check_is_partial_sorted_ranges(&patterns::random(50));
+
+    // Longer tests would take hours to run under Miri.
+    if !cfg!(miri) {
+        check_is_partial_sorted_ranges(&patterns::random(100));
+        check_is_partial_sorted_ranges(&patterns::random(1000));
+    }
+}
diff --git a/library/alloctests/tests/sort/patterns.rs b/library/alloctests/tests/sort/patterns.rs
index 0f1ec664d3d4..1ed645cf99dc 100644
--- a/library/alloctests/tests/sort/patterns.rs
+++ b/library/alloctests/tests/sort/patterns.rs
@@ -27,21 +27,20 @@ where
 {
     // :.:.:.::
 
-    let mut rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
+    let rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
 
     // Abstracting over ranges in Rust :(
     let dist = Uniform::try_from(range).unwrap();
-    (0..len).map(|_| dist.sample(&mut rng)).collect()
+    rng.sample_iter(dist).take(len).collect()
 }
 
 pub fn random_zipf(len: usize, exponent: f64) -> Vec<i32> {
     // https://en.wikipedia.org/wiki/Zipf's_law
 
-    let mut rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
+    let rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
 
-    // Abstracting over ranges in Rust :(
     let dist = ZipfDistribution::new(len, exponent).unwrap();
-    (0..len).map(|_| dist.sample(&mut rng) as i32).collect()
+    rng.sample_iter(dist).map(|val| val as i32).take(len).collect()
 }
 
 pub fn random_sorted(len: usize, sorted_percent: f64) -> Vec<i32> {
@@ -68,7 +67,7 @@ pub fn all_equal(len: usize) -> Vec<i32> {
     // ......
     // ::::::
 
-    (0..len).map(|_| 66).collect::<Vec<_>>()
+    vec![66; len]
 }
 
 pub fn ascending(len: usize) -> Vec<i32> {
@@ -206,6 +205,6 @@ fn rand_root_seed() -> u64 {
 }
 
 fn random_vec(len: usize) -> Vec<i32> {
-    let mut rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
-    (0..len).map(|_| rng.random::<i32>()).collect()
+    let rng: XorShiftRng = rand::SeedableRng::seed_from_u64(get_or_init_rand_seed());
+    rng.random_iter().take(len).collect()
 }
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
index cd5b14f6eff3..c8f9504ae14e 100644
--- a/library/alloctests/tests/vec.rs
+++ b/library/alloctests/tests/vec.rs
@@ -2749,3 +2749,19 @@ fn zst_collections_iter_nth_back_regression() {
     list.push_back(Thing);
     let _ = list.into_iter().nth_back(1);
 }
+
+#[test]
+fn const_heap() {
+    const X: &'static [u32] = {
+        let mut v = Vec::with_capacity(6);
+        let mut x = 1;
+        while x < 42 {
+            v.push(x);
+            x *= 2;
+        }
+        assert!(v.len() == 6);
+        v.const_make_global()
+    };
+
+    assert_eq!([1, 2, 4, 8, 16, 32], X);
+}
diff --git a/library/alloctests/tests/vec_deque.rs b/library/alloctests/tests/vec_deque.rs
index 82803c7a0dab..e9f860f8df9b 100644
--- a/library/alloctests/tests/vec_deque.rs
+++ b/library/alloctests/tests/vec_deque.rs
@@ -2156,6 +2156,116 @@ fn test_extend_front_specialization_copy_slice() {
     assert_eq!(v.as_slices(), ([5].as_slice(), [4, 3, 2].as_slice()));
 }
 
+#[test]
+fn test_extend_front_specialization_deque_drain() {
+    // trigger 8 code paths: all combinations of prepend and extend_front, wrap and no wrap (src deque), wrap and no wrap (dst deque)
+
+    /// Get deque containing `[1, 2, 3, 4]`, possibly wrapping in the middle (between the 2 and 3).
+    fn test_deque(wrap: bool) -> VecDeque<i32> {
+        if wrap {
+            let mut v = VecDeque::with_capacity(4);
+            v.extend([3, 4]);
+            v.prepend([1, 2]);
+            assert_eq!(v.as_slices(), ([1, 2].as_slice(), [3, 4].as_slice()));
+            v
+        } else {
+            VecDeque::from([1, 2, 3, 4])
+        }
+    }
+
+    // prepend, v2.head == 0
+
+    let mut v1 = VecDeque::with_capacity(7);
+
+    let mut v2 = test_deque(false);
+    v1.prepend(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    assert_eq!(v1, [1, 2, 3, 4]);
+    v1.pop_back();
+
+    let mut v2 = test_deque(false);
+    // this should wrap around the physical buffer
+    v1.prepend(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    // check it really wrapped
+    assert_eq!(v1.as_slices(), ([1].as_slice(), [2, 3, 4, 1, 2, 3].as_slice()));
+
+    // extend_front, v2.head == 0
+
+    let mut v1 = VecDeque::with_capacity(7);
+
+    let mut v2 = test_deque(false);
+    v1.extend_front(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    assert_eq!(v1, [4, 3, 2, 1]);
+    v1.pop_back();
+
+    let mut v2 = test_deque(false);
+    // this should wrap around the physical buffer
+    v1.extend_front(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    // check it really wrapped
+    assert_eq!(v1.as_slices(), ([4].as_slice(), [3, 2, 1, 4, 3, 2].as_slice()));
+
+    // prepend, v2.head != 0
+
+    let mut v1 = VecDeque::with_capacity(7);
+
+    let mut v2 = test_deque(true);
+    v1.prepend(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    assert_eq!(v1, [1, 2, 3, 4]);
+    v1.pop_back();
+
+    let mut v2 = test_deque(true);
+    // this should wrap around the physical buffer
+    v1.prepend(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    // check it really wrapped
+    assert_eq!(v1.as_slices(), ([1].as_slice(), [2, 3, 4, 1, 2, 3].as_slice()));
+
+    // extend_front, v2.head != 0
+
+    let mut v1 = VecDeque::with_capacity(7);
+
+    let mut v2 = test_deque(true);
+    v1.extend_front(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    assert_eq!(v1, [4, 3, 2, 1]);
+    v1.pop_back();
+
+    let mut v2 = test_deque(true);
+    // this should wrap around the physical buffer
+    v1.extend_front(v2.drain(..));
+    // drain removes all elements but keeps the buffer
+    assert_eq!(v2, []);
+    assert!(v2.capacity() >= 4);
+
+    // check it really wrapped
+    assert_eq!(v1.as_slices(), ([4].as_slice(), [3, 2, 1, 4, 3, 2].as_slice()));
+}
+
 #[test]
 fn test_splice() {
     let mut v = VecDeque::from(vec![1, 2, 3, 4, 5]);
diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 38995cf0f0ff..699a9c417dde 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -203,7 +203,7 @@ jobs:
     # Unlike rustfmt, stable clippy does not work on code with nightly features.
     - name: Install nightly `clippy`
       run: |
-        rustup set profile minimal
+        rustup update nightly --no-self-update
         rustup default nightly
         rustup component add clippy
     - uses: Swatinem/rust-cache@v2
@@ -247,16 +247,7 @@ jobs:
     - uses: taiki-e/install-action@cargo-binstall
 
     - name: Set up dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y valgrind gdb libc6-dbg # Needed for gungraun
-        rustup update "$BENCHMARK_RUSTC" --no-self-update
-        rustup default "$BENCHMARK_RUSTC"
-        # Install the version of gungraun-runner that is specified in Cargo.toml
-        gungraun_version="$(cargo metadata --format-version=1 --features icount |
-           jq -r '.packages[] | select(.name == "gungraun").version')"
-        cargo binstall -y gungraun-runner --version "$gungraun_version"
-        sudo apt-get install valgrind
+      run: ./ci/install-bench-deps.sh
     - uses: Swatinem/rust-cache@v2
       with:
         key: ${{ matrix.target }}
@@ -276,13 +267,7 @@ jobs:
         path: ${{ env.BASELINE_NAME }}.tar.xz
 
     - name: Run wall time benchmarks
-      run: |
-        # Always use the same seed for benchmarks. Ideally we should switch to a
-        # non-random generator.
-        export LIBM_SEED=benchesbenchesbenchesbencheswoo!
-        cargo bench --package libm-test \
-          --no-default-features \
-          --features short-benchmarks,build-musl,libm/force-soft-floats
+      run: ./ci/bench-runtime.sh
 
     - name: Print test logs if available
       if: always()
diff --git a/library/compiler-builtins/ci/bench-runtime.sh b/library/compiler-builtins/ci/bench-runtime.sh
new file mode 100755
index 000000000000..d272cf33463e
--- /dev/null
+++ b/library/compiler-builtins/ci/bench-runtime.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+# Run wall time benchmarks as we do on CI.
+
+# Always use the same seed for benchmarks. Ideally we should switch to a
+# non-random generator.
+export LIBM_SEED=benchesbenchesbenchesbencheswoo!
+cargo bench --package libm-test \
+    --no-default-features \
+    --features short-benchmarks,build-musl,libm/force-soft-floats
diff --git a/library/compiler-builtins/ci/install-bench-deps.sh b/library/compiler-builtins/ci/install-bench-deps.sh
new file mode 100755
index 000000000000..61f4723c0358
--- /dev/null
+++ b/library/compiler-builtins/ci/install-bench-deps.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+# Install needed dependencies for gungraun.
+
+sudo apt-get update
+sudo apt-get install -y valgrind gdb libc6-dbg # Needed for gungraun
+rustup update "$BENCHMARK_RUSTC" --no-self-update
+rustup default "$BENCHMARK_RUSTC"
+# Install the version of gungraun-runner that is specified in Cargo.toml
+gungraun_version="$(cargo metadata --format-version=1 --features icount |
+    jq -r '.packages[] | select(.name == "gungraun").version')"
+cargo binstall -y gungraun-runner --version "$gungraun_version"
diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64.rs b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
index 039fab2061c5..1b230a214eef 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
@@ -4,7 +4,7 @@ use core::intrinsics;
 
 intrinsics! {
     #[unsafe(naked)]
-    #[cfg(target_os = "uefi")]
+    #[cfg(any(all(windows, target_env = "gnu"), target_os = "uefi"))]
     pub unsafe extern "custom" fn __chkstk() {
         core::arch::naked_asm!(
             ".p2align 2",
diff --git a/library/compiler-builtins/libm/src/libm_helper.rs b/library/compiler-builtins/libm/src/libm_helper.rs
index dfa1ff77bf2e..0bb669398657 100644
--- a/library/compiler-builtins/libm/src/libm_helper.rs
+++ b/library/compiler-builtins/libm/src/libm_helper.rs
@@ -168,7 +168,7 @@ libm_helper! {
         (fn remquo(x: f64, y: f64) -> (f64, i32);   => remquo);
         (fn rint(x: f64) -> (f64);                  => rint);
         (fn round(x: f64) -> (f64);                 => round);
-        (fn roundevem(x: f64) -> (f64);             => roundeven);
+        (fn roundeven(x: f64) -> (f64);             => roundeven);
         (fn scalbn(x: f64, n: i32) -> (f64);        => scalbn);
         (fn sin(x: f64) -> (f64);                   => sin);
         (fn sincos(x: f64) -> (f64, f64);           => sincos);
diff --git a/library/compiler-builtins/libm/src/math/arch/x86/detect.rs b/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
index 5391a68228ed..ca785470b806 100644
--- a/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
+++ b/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
@@ -39,6 +39,8 @@ pub fn get_cpu_features() -> Flags {
 /// Implementation is taken from [std-detect][std-detect].
 ///
 /// [std-detect]: https://github.com/rust-lang/stdarch/blob/690b3a6334d482874163bd6fcef408e0518febe9/crates/std_detect/src/detect/os/x86.rs#L142
+// FIXME(msrv): Remove unsafe block around __cpuid once https://github.com/rust-lang/stdarch/pull/1935 is available in MSRV.
+#[allow(unused_unsafe)]
 fn load_x86_features() -> Flags {
     let mut value = Flags::empty();
 
@@ -57,7 +59,7 @@ fn load_x86_features() -> Flags {
     //   (in that order)
     let mut vendor_id = [0u8; 12];
     let max_basic_leaf;
-    {
+    unsafe {
         let CpuidResult { eax, ebx, ecx, edx } = __cpuid(0);
         max_basic_leaf = eax;
         vendor_id[0..4].copy_from_slice(&ebx.to_ne_bytes());
@@ -72,7 +74,7 @@ fn load_x86_features() -> Flags {
 
     // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
     // Contains information about most x86 features.
-    let CpuidResult { ecx, edx, .. } = __cpuid(0x0000_0001_u32);
+    let CpuidResult { ecx, edx, .. } = unsafe { __cpuid(0x0000_0001_u32) };
     let proc_info_ecx = Flags::from_bits(ecx);
     let proc_info_edx = Flags::from_bits(edx);
 
@@ -82,23 +84,23 @@ fn load_x86_features() -> Flags {
     let mut extended_features_edx = Flags::empty();
     let mut extended_features_eax_leaf_1 = Flags::empty();
     if max_basic_leaf >= 7 {
-        let CpuidResult { ebx, edx, .. } = __cpuid(0x0000_0007_u32);
+        let CpuidResult { ebx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
         extended_features_ebx = Flags::from_bits(ebx);
         extended_features_edx = Flags::from_bits(edx);
 
-        let CpuidResult { eax, .. } = __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32);
+        let CpuidResult { eax, .. } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
         extended_features_eax_leaf_1 = Flags::from_bits(eax)
     }
 
     // EAX = 0x8000_0000, ECX = 0: Get Highest Extended Function Supported
     // - EAX returns the max leaf value for extended information, that is,
     //   `cpuid` calls in range [0x8000_0000; u32::MAX]:
-    let extended_max_basic_leaf = __cpuid(0x8000_0000_u32).eax;
+    let extended_max_basic_leaf = unsafe { __cpuid(0x8000_0000_u32) }.eax;
 
     // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature Bits"
     let mut extended_proc_info_ecx = Flags::empty();
     if extended_max_basic_leaf >= 1 {
-        let CpuidResult { ecx, .. } = __cpuid(0x8000_0001_u32);
+        let CpuidResult { ecx, .. } = unsafe { __cpuid(0x8000_0001_u32) };
         extended_proc_info_ecx = Flags::from_bits(ecx);
     }
 
diff --git a/library/compiler-builtins/rust-version b/library/compiler-builtins/rust-version
index 7345c25066a8..6a2835bc2d9e 100644
--- a/library/compiler-builtins/rust-version
+++ b/library/compiler-builtins/rust-version
@@ -1 +1 @@
-2dc30247c5d8293aaa31e1d7dae2ed2fde908ada
+23d01cd2412583491621ab1ca4f1b01e37d11e39
diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index 680b1ec105a2..959407b75348 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -102,7 +102,8 @@ impl fmt::Display for AllocError {
 ///
 /// [*currently allocated*]: #currently-allocated-memory
 #[unstable(feature = "allocator_api", issue = "32838")]
-pub unsafe trait Allocator {
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+pub const unsafe trait Allocator {
     /// Attempts to allocate a block of memory.
     ///
     /// On success, returns a [`NonNull<[u8]>`][NonNull] meeting the size and alignment guarantees of `layout`.
@@ -368,9 +369,10 @@ pub unsafe trait Allocator {
 }
 
 #[unstable(feature = "allocator_api", issue = "32838")]
-unsafe impl<A> Allocator for &A
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+unsafe impl<A> const Allocator for &A
 where
-    A: Allocator + ?Sized,
+    A: [const] Allocator + ?Sized,
 {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 9a3f7166f1fc..661ea4ab6a27 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -27,10 +27,9 @@
 //!
 //! ## `Cell<T>`
 //!
-//! [`Cell<T>`] implements interior mutability by moving values in and out of the cell. That is, an
-//! `&mut T` to the inner value can never be obtained, and the value itself cannot be directly
-//! obtained without replacing it with something else. Both of these rules ensure that there is
-//! never more than one reference pointing to the inner value. This type provides the following
+//! [`Cell<T>`] implements interior mutability by moving values in and out of the cell. That is, a
+//! `&T` to the inner value can never be obtained, and the value itself cannot be directly
+//! obtained without replacing it with something else. This type provides the following
 //! methods:
 //!
 //!  - For types that implement [`Copy`], the [`get`](Cell::get) method retrieves the current
diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index e3d4b5c3331c..85b09ee06f1f 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -285,7 +285,7 @@ pub const unsafe trait TrivialClone: [const] Clone {}
 /// Derive macro generating an impl of the trait `Clone`.
 #[rustc_builtin_macro]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-#[allow_internal_unstable(core_intrinsics, derive_clone_copy, trivial_clone)]
+#[allow_internal_unstable(core_intrinsics, derive_clone_copy_internals, trivial_clone)]
 pub macro Clone($item:item) {
     /* compiler built-in */
 }
@@ -350,7 +350,7 @@ impl_use_cloned! {
 #[doc(hidden)]
 #[allow(missing_debug_implementations)]
 #[unstable(
-    feature = "derive_clone_copy",
+    feature = "derive_clone_copy_internals",
     reason = "deriving hack, should not be public",
     issue = "none"
 )]
@@ -360,7 +360,7 @@ pub struct AssertParamIsClone<T: Clone + PointeeSized> {
 #[doc(hidden)]
 #[allow(missing_debug_implementations)]
 #[unstable(
-    feature = "derive_clone_copy",
+    feature = "derive_clone_copy_internals",
     reason = "deriving hack, should not be public",
     issue = "none"
 )]
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index feb9c4319604..78ea1f111325 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -351,7 +351,7 @@ pub const trait Eq: [const] PartialEq<Self> + PointeeSized {
 /// Derive macro generating an impl of the trait [`Eq`].
 #[rustc_builtin_macro]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-#[allow_internal_unstable(core_intrinsics, derive_eq, structural_match)]
+#[allow_internal_unstable(core_intrinsics, derive_eq_internals, structural_match)]
 #[allow_internal_unstable(coverage_attribute)]
 pub macro Eq($item:item) {
     /* compiler built-in */
@@ -363,7 +363,11 @@ pub macro Eq($item:item) {
 // This struct should never appear in user code.
 #[doc(hidden)]
 #[allow(missing_debug_implementations)]
-#[unstable(feature = "derive_eq", reason = "deriving hack, should not be public", issue = "none")]
+#[unstable(
+    feature = "derive_eq_internals",
+    reason = "deriving hack, should not be public",
+    issue = "none"
+)]
 pub struct AssertParamIsEq<T: Eq + PointeeSized> {
     _field: crate::marker::PhantomData<T>,
 }
@@ -1186,7 +1190,7 @@ pub macro Ord($item:item) {
 /// every `a`. This isn't always the case for types that implement `PartialOrd`, for example:
 ///
 /// ```
-/// let a = f64::sqrt(-1.0);
+/// let a = f64::NAN;
 /// assert_eq!(a <= a, false);
 /// ```
 ///
diff --git a/library/core/src/error.rs b/library/core/src/error.rs
index 9ca91ee009ee..011d6ac4a1c7 100644
--- a/library/core/src/error.rs
+++ b/library/core/src/error.rs
@@ -205,6 +205,56 @@ pub trait Error: Debug + Display {
     ///     assert!(request_ref::<MyLittleTeaPot>(dyn_error).is_none());
     /// }
     /// ```
+    ///
+    /// # Delegating Impls
+    ///
+    /// <div class="warning">
+    ///
+    /// **Warning**: We recommend implementors avoid delegating implementations of `provide` to
+    /// source error implementations.
+    ///
+    /// </div>
+    ///
+    /// This method should expose context from the current piece of the source chain only, not from
+    /// sources that are exposed in the chain of sources. Delegating `provide` implementations cause
+    /// the same context to be provided by multiple errors in the chain of sources which can cause
+    /// unintended duplication of information in error reports or require heuristics to deduplicate.
+    ///
+    /// In other words, the following implementation pattern for `provide` is discouraged and should
+    /// not be used for [`Error`] types exposed in public APIs to third parties.
+    ///
+    /// ```rust
+    /// # #![feature(error_generic_member_access)]
+    /// # use core::fmt;
+    /// # use core::error::Request;
+    /// # #[derive(Debug)]
+    /// struct MyError {
+    ///     source: Error,
+    /// }
+    /// # #[derive(Debug)]
+    /// # struct Error;
+    /// # impl fmt::Display for Error {
+    /// #     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    /// #         write!(f, "Example Source Error")
+    /// #     }
+    /// # }
+    /// # impl fmt::Display for MyError {
+    /// #     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    /// #         write!(f, "Example Error")
+    /// #     }
+    /// # }
+    /// # impl std::error::Error for Error { }
+    ///
+    /// impl std::error::Error for MyError {
+    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+    ///         Some(&self.source)
+    ///     }
+    ///
+    ///     fn provide<'a>(&'a self, request: &mut Request<'a>) {
+    ///         self.source.provide(request) // <--- Discouraged
+    ///     }
+    /// }
+    /// ```
     #[unstable(feature = "error_generic_member_access", issue = "99301")]
     #[allow(unused_variables)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {}
diff --git a/library/core/src/hash/sip.rs b/library/core/src/hash/sip.rs
index 780e522c48eb..4f2e8a22d180 100644
--- a/library/core/src/hash/sip.rs
+++ b/library/core/src/hash/sip.rs
@@ -10,7 +10,7 @@ use crate::{cmp, ptr};
 /// This is currently the default hashing function used by standard library
 /// (e.g., `collections::HashMap` uses it by default).
 ///
-/// See: <https://131002.net/siphash>
+/// See: <https://github.com/veorq/SipHash>
 #[unstable(feature = "hashmap_internals", issue = "none")]
 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
 #[derive(Debug, Clone, Default)]
@@ -21,7 +21,7 @@ pub struct SipHasher13 {
 
 /// An implementation of SipHash 2-4.
 ///
-/// See: <https://131002.net/siphash/>
+/// See: <https://github.com/veorq/SipHash>
 #[unstable(feature = "hashmap_internals", issue = "none")]
 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
 #[derive(Debug, Clone, Default)]
@@ -31,7 +31,7 @@ struct SipHasher24 {
 
 /// An implementation of SipHash 2-4.
 ///
-/// See: <https://131002.net/siphash/>
+/// See: <https://github.com/veorq/SipHash>
 ///
 /// SipHash is a general-purpose hashing function: it runs at a good
 /// speed (competitive with Spooky and City) and permits strong _keyed_
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 0ae8d3d4a4ce..20f34036b25c 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2738,10 +2738,6 @@ pub unsafe fn vtable_align(ptr: *const ()) -> usize;
 /// Determining whether `T` can be coerced to the trait object type `U` requires trait resolution by the compiler.
 /// In some cases, that resolution can exceed the recursion limit,
 /// and compilation will fail instead of this function returning `None`.
-///
-/// # Safety
-///
-/// `ptr` must point to a vtable.
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
@@ -2849,6 +2845,15 @@ pub const unsafe fn size_of_val<T: ?Sized>(ptr: *const T) -> usize;
 #[rustc_intrinsic_const_stable_indirect]
 pub const unsafe fn align_of_val<T: ?Sized>(ptr: *const T) -> usize;
 
+/// Compute the type information of a concrete type.
+/// It can only be called at compile time, the backends do
+/// not implement it.
+#[rustc_intrinsic]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+pub const fn type_of(_id: crate::any::TypeId) -> crate::mem::type_info::Type {
+    panic!("`TypeId::info` can only be called at compile-time")
+}
+
 /// Gets a static string slice containing the name of a type.
 ///
 /// Note that, unlike most intrinsics, this can only be called at compile-time
diff --git a/library/core/src/iter/adapters/peekable.rs b/library/core/src/iter/adapters/peekable.rs
index ee40d2b74c64..b9bdb827209b 100644
--- a/library/core/src/iter/adapters/peekable.rs
+++ b/library/core/src/iter/adapters/peekable.rs
@@ -337,7 +337,6 @@ impl<I: Iterator> Peekable<I> {
     ///
     /// Parse the leading decimal number from an iterator of characters.
     /// ```
-    /// #![feature(peekable_next_if_map)]
     /// let mut iter = "125 GOTO 10".chars().peekable();
     /// let mut line_num = 0_u32;
     /// while let Some(digit) = iter.next_if_map(|c| c.to_digit(10).ok_or(c)) {
@@ -349,7 +348,6 @@ impl<I: Iterator> Peekable<I> {
     ///
     /// Matching custom types.
     /// ```
-    /// #![feature(peekable_next_if_map)]
     ///
     /// #[derive(Debug, PartialEq, Eq)]
     /// enum Node {
@@ -408,7 +406,7 @@ impl<I: Iterator> Peekable<I> {
     ///#     ],
     ///# )
     /// ```
-    #[unstable(feature = "peekable_next_if_map", issue = "143702")]
+    #[stable(feature = "peekable_next_if_map", since = "CURRENT_RUSTC_VERSION")]
     pub fn next_if_map<R>(&mut self, f: impl FnOnce(I::Item) -> Result<R, I::Item>) -> Option<R> {
         let unpeek = if let Some(item) = self.next() {
             match f(item) {
@@ -437,7 +435,6 @@ impl<I: Iterator> Peekable<I> {
     ///
     /// Parse the leading decimal number from an iterator of characters.
     /// ```
-    /// #![feature(peekable_next_if_map)]
     /// let mut iter = "125 GOTO 10".chars().peekable();
     /// let mut line_num = 0_u32;
     /// while let Some(digit) = iter.next_if_map_mut(|c| c.to_digit(10)) {
@@ -446,7 +443,7 @@ impl<I: Iterator> Peekable<I> {
     /// assert_eq!(line_num, 125);
     /// assert_eq!(iter.collect::<String>(), " GOTO 10");
     /// ```
-    #[unstable(feature = "peekable_next_if_map", issue = "143702")]
+    #[stable(feature = "peekable_next_if_map", since = "CURRENT_RUSTC_VERSION")]
     pub fn next_if_map_mut<R>(&mut self, f: impl FnOnce(&mut I::Item) -> Option<R>) -> Option<R> {
         let unpeek = if let Some(mut item) = self.next() {
             match f(&mut item) {
diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs
index 7dabaece9556..da0b05063657 100644
--- a/library/core/src/iter/traits/double_ended.rs
+++ b/library/core/src/iter/traits/double_ended.rs
@@ -334,8 +334,18 @@ pub trait DoubleEndedIterator: Iterator {
     /// ```
     /// let a = [1, 2, 3];
     ///
-    /// assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));
+    /// assert_eq!(a.into_iter().rfind(|&x| x == 2), Some(2));
+    /// assert_eq!(a.into_iter().rfind(|&x| x == 5), None);
+    /// ```
     ///
+    /// Iterating over references:
+    ///
+    /// ```
+    /// let a = [1, 2, 3];
+    ///
+    /// // `iter()` yields references i.e. `&i32` and `rfind()` takes a
+    /// // reference to each element.
+    /// assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));
     /// assert_eq!(a.iter().rfind(|&&x| x == 5), None);
     /// ```
     ///
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index 84da778c3b91..419f66089b10 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -238,8 +238,7 @@ pub trait Iterator {
     ///
     /// # Panics
     ///
-    /// This function might panic if the iterator has more than [`usize::MAX`]
-    /// elements.
+    /// This function might panic if the iterator is infinite.
     ///
     /// # Examples
     ///
@@ -1907,9 +1906,12 @@ pub trait Iterator {
 
     /// Transforms an iterator into a collection.
     ///
-    /// `collect()` can take anything iterable, and turn it into a relevant
-    /// collection. This is one of the more powerful methods in the standard
-    /// library, used in a variety of contexts.
+    /// `collect()` takes ownership of an iterator and produces whichever
+    /// collection type you request. The iterator itself carries no knowledge of
+    /// the eventual container; the target collection is chosen entirely by the
+    /// type you ask `collect()` to return. This makes `collect()` one of the
+    /// more powerful methods in the standard library, and it shows up in a wide
+    /// variety of contexts.
     ///
     /// The most basic pattern in which `collect()` is used is to turn one
     /// collection into another. You take a collection, call [`iter`] on it,
@@ -2863,6 +2865,17 @@ pub trait Iterator {
     /// assert_eq!(a.into_iter().find(|&x| x == 5), None);
     /// ```
     ///
+    /// Iterating over references:
+    ///
+    /// ```
+    /// let a = [1, 2, 3];
+    ///
+    /// // `iter()` yields references i.e. `&i32` and `find()` takes a
+    /// // reference to each element.
+    /// assert_eq!(a.iter().find(|&&x| x == 2), Some(&2));
+    /// assert_eq!(a.iter().find(|&&x| x == 5), None);
+    /// ```
+    ///
     /// Stopping at the first `true`:
     ///
     /// ```
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 962b0cea4a4f..dfc9a7b5dbc3 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -124,6 +124,7 @@
 #![feature(str_internals)]
 #![feature(str_split_inclusive_remainder)]
 #![feature(str_split_remainder)]
+#![feature(type_info)]
 #![feature(ub_checks)]
 #![feature(unsafe_pinned)]
 #![feature(utf16_extra)]
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index a12ee60277f0..338c5688bf10 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -168,7 +168,7 @@ macro_rules! assert_ne {
 /// ```
 #[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(panic_internals)]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro assert_matches {
     ($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => {
         match $left {
@@ -401,7 +401,7 @@ macro_rules! debug_assert_ne {
 /// ```
 #[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(assert_matches)]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro debug_assert_matches($($arg:tt)*) {
     if $crate::cfg!(debug_assertions) {
         $crate::assert_matches::assert_matches!($($arg)*);
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 68f22767d6cf..68f5649210de 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -163,7 +163,7 @@ pub trait Sized: MetaSized {
 }
 
 /// Types with a size that can be determined from pointer metadata.
-#[unstable(feature = "sized_hierarchy", issue = "none")]
+#[unstable(feature = "sized_hierarchy", issue = "144404")]
 #[lang = "meta_sized"]
 #[diagnostic::on_unimplemented(
     message = "the size for values of type `{Self}` cannot be known",
@@ -181,7 +181,7 @@ pub trait MetaSized: PointeeSized {
 }
 
 /// Types that may or may not have a size.
-#[unstable(feature = "sized_hierarchy", issue = "none")]
+#[unstable(feature = "sized_hierarchy", issue = "144404")]
 #[lang = "pointee_sized"]
 #[diagnostic::on_unimplemented(
     message = "values of type `{Self}` may or may not have a size",
@@ -466,7 +466,7 @@ pub trait Copy: Clone {
 /// Derive macro generating an impl of the trait `Copy`.
 #[rustc_builtin_macro]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-#[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
+#[allow_internal_unstable(core_intrinsics, derive_clone_copy_internals)]
 pub macro Copy($item:item) {
     /* compiler built-in */
 }
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index 4f7edce1e977..1671c8219de1 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -37,6 +37,9 @@ pub use drop_guard::DropGuard;
 #[doc(inline)]
 pub use crate::intrinsics::transmute;
 
+#[unstable(feature = "type_info", issue = "146922")]
+pub mod type_info;
+
 /// Takes ownership and "forgets" about the value **without running its destructor**.
 ///
 /// Any resources the value manages, such as heap memory or a file handle, will linger
diff --git a/library/core/src/mem/type_info.rs b/library/core/src/mem/type_info.rs
new file mode 100644
index 000000000000..7938e2b52ed0
--- /dev/null
+++ b/library/core/src/mem/type_info.rs
@@ -0,0 +1,71 @@
+//! MVP for exposing compile-time information about types in a
+//! runtime or const-eval processable way.
+
+use crate::any::TypeId;
+use crate::intrinsics::type_of;
+
+/// Compile-time type information.
+#[derive(Debug)]
+#[non_exhaustive]
+#[lang = "type_info"]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Type {
+    /// Per-type information
+    pub kind: TypeKind,
+    /// Size of the type. `None` if it is unsized
+    pub size: Option<usize>,
+}
+
+impl TypeId {
+    /// Compute the type information of a concrete type.
+    /// It can only be called at compile time.
+    #[unstable(feature = "type_info", issue = "146922")]
+    #[rustc_const_unstable(feature = "type_info", issue = "146922")]
+    pub const fn info(self) -> Type {
+        type_of(self)
+    }
+}
+
+impl Type {
+    /// Returns the type information of the generic type parameter.
+    #[unstable(feature = "type_info", issue = "146922")]
+    #[rustc_const_unstable(feature = "type_info", issue = "146922")]
+    // FIXME(reflection): don't require the 'static bound
+    pub const fn of<T: 'static>() -> Self {
+        const { TypeId::of::<T>().info() }
+    }
+}
+
+/// Compile-time type information.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub enum TypeKind {
+    /// Tuples.
+    Tuple(Tuple),
+    /// Primitives
+    /// FIXME(#146922): disambiguate further
+    Leaf,
+    /// FIXME(#146922): add all the common types
+    Other,
+}
+
+/// Compile-time type information about tuples.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Tuple {
+    /// All fields of a tuple.
+    pub fields: &'static [Field],
+}
+
+/// Compile-time type information about fields of tuples, structs and enum variants.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Field {
+    /// The field's type.
+    pub ty: TypeId,
+    /// Offset in bytes from the parent type
+    pub offset: usize,
+}
diff --git a/library/core/src/panic.rs b/library/core/src/panic.rs
index 81520c3ecd1b..cf0750446680 100644
--- a/library/core/src/panic.rs
+++ b/library/core/src/panic.rs
@@ -20,7 +20,7 @@ use crate::any::Any;
 #[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
 #[allow_internal_unstable(panic_internals, const_format_args)]
 #[rustc_diagnostic_item = "core_panic_2015_macro"]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro panic_2015 {
     () => (
         $crate::panicking::panic("explicit panic")
@@ -47,7 +47,7 @@ pub macro panic_2015 {
 #[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
 #[allow_internal_unstable(panic_internals, const_format_args)]
 #[rustc_diagnostic_item = "core_panic_2021_macro"]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro panic_2021 {
     () => (
         $crate::panicking::panic("explicit panic")
@@ -67,7 +67,7 @@ pub macro panic_2021 {
 #[unstable(feature = "edition_panic", issue = "none", reason = "use unreachable!() instead")]
 #[allow_internal_unstable(panic_internals)]
 #[rustc_diagnostic_item = "unreachable_2015_macro"]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro unreachable_2015 {
     () => (
         $crate::panicking::panic("internal error: entered unreachable code")
@@ -85,7 +85,7 @@ pub macro unreachable_2015 {
 #[doc(hidden)]
 #[unstable(feature = "edition_panic", issue = "none", reason = "use unreachable!() instead")]
 #[allow_internal_unstable(panic_internals)]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro unreachable_2021 {
     () => (
         $crate::panicking::panic("internal error: entered unreachable code")
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 74ecb5ee4946..4791f5612bfa 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -2027,7 +2027,7 @@ unsafe impl<T: ?Sized> PinCoerceUnsized for *mut T {}
 ///
 /// [`Box::pin`]: ../../std/boxed/struct.Box.html#method.pin
 #[stable(feature = "pin_macro", since = "1.68.0")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 #[allow_internal_unstable(super_let)]
 #[rustc_diagnostic_item = "pin_macro"]
 // `super` gets removed by rustfmt
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 29fe77390a16..ad74a8628c61 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -880,6 +880,7 @@ pub const fn null_mut<T: PointeeSized + Thin>() -> *mut T {
 #[must_use]
 #[stable(feature = "strict_provenance", since = "1.84.0")]
 #[rustc_const_stable(feature = "strict_provenance", since = "1.84.0")]
+#[rustc_diagnostic_item = "ptr_without_provenance"]
 pub const fn without_provenance<T>(addr: usize) -> *const T {
     without_provenance_mut(addr)
 }
@@ -918,6 +919,7 @@ pub const fn dangling<T>() -> *const T {
 #[must_use]
 #[stable(feature = "strict_provenance", since = "1.84.0")]
 #[rustc_const_stable(feature = "strict_provenance", since = "1.84.0")]
+#[rustc_diagnostic_item = "ptr_without_provenance_mut"]
 #[allow(integer_to_ptr_transmutes)] // Expected semantics here.
 pub const fn without_provenance_mut<T>(addr: usize) -> *mut T {
     // An int-to-pointer transmute currently has exactly the intended semantics: it creates a
@@ -2660,7 +2662,7 @@ impl<F: FnPtr> fmt::Debug for F {
 /// same requirements apply to field projections, even inside `addr_of!`. (In particular, it makes
 /// no difference whether the pointer is null or dangling.)
 #[stable(feature = "raw_ref_macros", since = "1.51.0")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro addr_of($place:expr) {
     &raw const $place
 }
@@ -2750,7 +2752,7 @@ pub macro addr_of($place:expr) {
 /// same requirements apply to field projections, even inside `addr_of_mut!`. (In particular, it
 /// makes no difference whether the pointer is null or dangling.)
 #[stable(feature = "raw_ref_macros", since = "1.51.0")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro addr_of_mut($place:expr) {
     &raw mut $place
 }
diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index fd1ca23fb79c..c3ff928a3277 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -13,13 +13,10 @@ impl<T, U> const PartialEq<[U]> for [T]
 where
     T: [const] PartialEq<U>,
 {
+    #[inline]
     fn eq(&self, other: &[U]) -> bool {
         SlicePartialEq::equal(self, other)
     }
-
-    fn ne(&self, other: &[U]) -> bool {
-        SlicePartialEq::not_equal(self, other)
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -99,10 +96,6 @@ impl<T: PartialOrd> PartialOrd for [T] {
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 const trait SlicePartialEq<B> {
     fn equal(&self, other: &[B]) -> bool;
-
-    fn not_equal(&self, other: &[B]) -> bool {
-        !self.equal(other)
-    }
 }
 
 // Generic slice equality
@@ -111,6 +104,11 @@ impl<A, B> const SlicePartialEq<B> for [A]
 where
     A: [const] PartialEq<B>,
 {
+    // It's not worth trying to inline the loops underneath here *in MIR*,
+    // and preventing it encourages more useful inlining upstream,
+    // such as in `<str as PartialEq>::eq`.
+    // The codegen backend can still inline it later if needed.
+    #[rustc_no_mir_inline]
     default fn equal(&self, other: &[B]) -> bool {
         if self.len() != other.len() {
             return false;
@@ -140,6 +138,16 @@ impl<A, B> const SlicePartialEq<B> for [A]
 where
     A: [const] BytewiseEq<B>,
 {
+    // This is usually a pretty good backend inlining candidate because the
+    // intrinsic tends to just be `memcmp`.  However, as of 2025-12 letting
+    // MIR inline this makes reuse worse because it means that, for example,
+    // `String::eq` doesn't inline, whereas by keeping this from inling all
+    // the wrappers until the call to this disappear.  If the heuristics have
+    // changed and this is no longer fruitful, though, please do remove it.
+    // In the mean time, it's fine to not inline it in MIR because the backend
+    // will still inline it if it things it's important to do so.
+    #[rustc_no_mir_inline]
+    #[inline]
     fn equal(&self, other: &[B]) -> bool {
         if self.len() != other.len() {
             return false;
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 889fd4cd65df..8113e1824f27 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -3244,6 +3244,219 @@ impl<T> [T] {
         sort::unstable::sort(self, &mut |a, b| f(a).lt(&f(b)));
     }
 
+    /// Partially sorts the slice in ascending order **without** preserving the initial order of equal elements.
+    ///
+    /// Upon completion, for the specified range `start..end`, it's guaranteed that:
+    ///
+    /// 1. Every element in `self[..start]` is smaller than or equal to
+    /// 2. Every element in `self[start..end]`, which is sorted, and smaller than or equal to
+    /// 3. Every element in `self[end..]`.
+    ///
+    /// This partial sort is unstable, meaning it may reorder equal elements in the specified range.
+    /// It may reorder elements outside the specified range as well, but the guarantees above still hold.
+    ///
+    /// This partial sort is in-place (i.e., does not allocate), and *O*(*n* + *k* \* log(*k*)) worst-case,
+    /// where *n* is the length of the slice and *k* is the length of the specified range.
+    ///
+    /// See the documentation of [`sort_unstable`] for implementation notes.
+    ///
+    /// # Panics
+    ///
+    /// May panic if the implementation of [`Ord`] for `T` does not implement a total order, or if
+    /// the [`Ord`] implementation panics, or if the specified range is out of bounds.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(slice_partial_sort_unstable)]
+    ///
+    /// let mut v = [4, -5, 1, -3, 2];
+    ///
+    /// // empty range at the beginning, nothing changed
+    /// v.partial_sort_unstable(0..0);
+    /// assert_eq!(v, [4, -5, 1, -3, 2]);
+    ///
+    /// // empty range in the middle, partitioning the slice
+    /// v.partial_sort_unstable(2..2);
+    /// for i in 0..2 {
+    ///    assert!(v[i] <= v[2]);
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2] <= v[i]);
+    /// }
+    ///
+    /// // single element range, same as select_nth_unstable
+    /// v.partial_sort_unstable(2..3);
+    /// for i in 0..2 {
+    ///    assert!(v[i] <= v[2]);
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2] <= v[i]);
+    /// }
+    ///
+    /// // partial sort a subrange
+    /// v.partial_sort_unstable(1..4);
+    /// assert_eq!(&v[1..4], [-3, 1, 2]);
+    ///
+    /// // partial sort the whole range, same as sort_unstable
+    /// v.partial_sort_unstable(..);
+    /// assert_eq!(v, [-5, -3, 1, 2, 4]);
+    /// ```
+    ///
+    /// [`sort_unstable`]: slice::sort_unstable
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable<R>(&mut self, range: R)
+    where
+        T: Ord,
+        R: RangeBounds<usize>,
+    {
+        sort::unstable::partial_sort(self, range, T::lt);
+    }
+
+    /// Partially sorts the slice in ascending order with a comparison function, **without**
+    /// preserving the initial order of equal elements.
+    ///
+    /// Upon completion, for the specified range `start..end`, it's guaranteed that:
+    ///
+    /// 1. Every element in `self[..start]` is smaller than or equal to
+    /// 2. Every element in `self[start..end]`, which is sorted, and smaller than or equal to
+    /// 3. Every element in `self[end..]`.
+    ///
+    /// This partial sort is unstable, meaning it may reorder equal elements in the specified range.
+    /// It may reorder elements outside the specified range as well, but the guarantees above still hold.
+    ///
+    /// This partial sort is in-place (i.e., does not allocate), and *O*(*n* + *k* \* log(*k*)) worst-case,
+    /// where *n* is the length of the slice and *k* is the length of the specified range.
+    ///
+    /// See the documentation of [`sort_unstable_by`] for implementation notes.
+    ///
+    /// # Panics
+    ///
+    /// May panic if the `compare` does not implement a total order, or if
+    /// the `compare` itself panics, or if the specified range is out of bounds.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(slice_partial_sort_unstable)]
+    ///
+    /// let mut v = [4, -5, 1, -3, 2];
+    ///
+    /// // empty range at the beginning, nothing changed
+    /// v.partial_sort_unstable_by(0..0, |a, b| b.cmp(a));
+    /// assert_eq!(v, [4, -5, 1, -3, 2]);
+    ///
+    /// // empty range in the middle, partitioning the slice
+    /// v.partial_sort_unstable_by(2..2, |a, b| b.cmp(a));
+    /// for i in 0..2 {
+    ///    assert!(v[i] >= v[2]);
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2] >= v[i]);
+    /// }
+    ///
+    /// // single element range, same as select_nth_unstable
+    /// v.partial_sort_unstable_by(2..3, |a, b| b.cmp(a));
+    /// for i in 0..2 {
+    ///    assert!(v[i] >= v[2]);
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2] >= v[i]);
+    /// }
+    ///
+    /// // partial sort a subrange
+    /// v.partial_sort_unstable_by(1..4, |a, b| b.cmp(a));
+    /// assert_eq!(&v[1..4], [2, 1, -3]);
+    ///
+    /// // partial sort the whole range, same as sort_unstable
+    /// v.partial_sort_unstable_by(.., |a, b| b.cmp(a));
+    /// assert_eq!(v, [4, 2, 1, -3, -5]);
+    /// ```
+    ///
+    /// [`sort_unstable_by`]: slice::sort_unstable_by
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable_by<F, R>(&mut self, range: R, mut compare: F)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+        R: RangeBounds<usize>,
+    {
+        sort::unstable::partial_sort(self, range, |a, b| compare(a, b) == Less);
+    }
+
+    /// Partially sorts the slice in ascending order with a key extraction function, **without**
+    /// preserving the initial order of equal elements.
+    ///
+    /// Upon completion, for the specified range `start..end`, it's guaranteed that:
+    ///
+    /// 1. Every element in `self[..start]` is smaller than or equal to
+    /// 2. Every element in `self[start..end]`, which is sorted, and smaller than or equal to
+    /// 3. Every element in `self[end..]`.
+    ///
+    /// This partial sort is unstable, meaning it may reorder equal elements in the specified range.
+    /// It may reorder elements outside the specified range as well, but the guarantees above still hold.
+    ///
+    /// This partial sort is in-place (i.e., does not allocate), and *O*(*n* + *k* \* log(*k*)) worst-case,
+    /// where *n* is the length of the slice and *k* is the length of the specified range.
+    ///
+    /// See the documentation of [`sort_unstable_by_key`] for implementation notes.
+    ///
+    /// # Panics
+    ///
+    /// May panic if the implementation of [`Ord`] for `K` does not implement a total order, or if
+    /// the [`Ord`] implementation panics, or if the specified range is out of bounds.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(slice_partial_sort_unstable)]
+    ///
+    /// let mut v = [4i32, -5, 1, -3, 2];
+    ///
+    /// // empty range at the beginning, nothing changed
+    /// v.partial_sort_unstable_by_key(0..0, |k| k.abs());
+    /// assert_eq!(v, [4, -5, 1, -3, 2]);
+    ///
+    /// // empty range in the middle, partitioning the slice
+    /// v.partial_sort_unstable_by_key(2..2, |k| k.abs());
+    /// for i in 0..2 {
+    ///    assert!(v[i].abs() <= v[2].abs());
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2].abs() <= v[i].abs());
+    /// }
+    ///
+    /// // single element range, same as select_nth_unstable
+    /// v.partial_sort_unstable_by_key(2..3, |k| k.abs());
+    /// for i in 0..2 {
+    ///    assert!(v[i].abs() <= v[2].abs());
+    /// }
+    /// for i in 3..v.len() {
+    ///   assert!(v[2].abs() <= v[i].abs());
+    /// }
+    ///
+    /// // partial sort a subrange
+    /// v.partial_sort_unstable_by_key(1..4, |k| k.abs());
+    /// assert_eq!(&v[1..4], [2, -3, 4]);
+    ///
+    /// // partial sort the whole range, same as sort_unstable
+    /// v.partial_sort_unstable_by_key(.., |k| k.abs());
+    /// assert_eq!(v, [1, 2, -3, 4, -5]);
+    /// ```
+    ///
+    /// [`sort_unstable_by_key`]: slice::sort_unstable_by_key
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable_by_key<K, F, R>(&mut self, range: R, mut f: F)
+    where
+        F: FnMut(&T) -> K,
+        K: Ord,
+        R: RangeBounds<usize>,
+    {
+        sort::unstable::partial_sort(self, range, |a, b| f(a).lt(&f(b)));
+    }
+
     /// Reorders the slice such that the element at `index` is at a sort-order position. All
     /// elements before `index` will be `<=` to this value, and all elements after will be `>=` to
     /// it.
@@ -4809,8 +5022,6 @@ impl<T> [T] {
     /// # Examples
     /// Basic usage:
     /// ```
-    /// #![feature(substr_range)]
-    ///
     /// let nums: &[u32] = &[1, 7, 1, 1];
     /// let num = &nums[2];
     ///
@@ -4819,8 +5030,6 @@ impl<T> [T] {
     /// ```
     /// Returning `None` with an unaligned element:
     /// ```
-    /// #![feature(substr_range)]
-    ///
     /// let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
     /// let flat_arr: &[u32] = arr.as_flattened();
     ///
@@ -4834,7 +5043,7 @@ impl<T> [T] {
     /// assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
     /// ```
     #[must_use]
-    #[unstable(feature = "substr_range", issue = "126769")]
+    #[stable(feature = "element_offset", since = "CURRENT_RUSTC_VERSION")]
     pub fn element_offset(&self, element: &T) -> Option<usize> {
         if T::IS_ZST {
             panic!("elements are zero-sized");
diff --git a/library/core/src/slice/sort/unstable/mod.rs b/library/core/src/slice/sort/unstable/mod.rs
index d4df8d3a264d..7ca95a3b1b19 100644
--- a/library/core/src/slice/sort/unstable/mod.rs
+++ b/library/core/src/slice/sort/unstable/mod.rs
@@ -1,11 +1,13 @@
 //! This module contains the entry points for `slice::sort_unstable`.
 
 use crate::mem::SizedTypeProperties;
+use crate::ops::{Range, RangeBounds};
+use crate::slice::sort::select::partition_at_index;
 #[cfg(not(any(feature = "optimize_for_size", target_pointer_width = "16")))]
 use crate::slice::sort::shared::find_existing_run;
 #[cfg(not(any(feature = "optimize_for_size", target_pointer_width = "16")))]
 use crate::slice::sort::shared::smallsort::insertion_sort_shift_left;
-use crate::{cfg_select, intrinsics};
+use crate::{cfg_select, intrinsics, slice};
 
 pub(crate) mod heapsort;
 pub(crate) mod quicksort;
@@ -17,7 +19,10 @@ pub(crate) mod quicksort;
 /// Upholds all safety properties outlined here:
 /// <https://github.com/Voultapher/sort-research-rs/blob/main/writeup/sort_safety/text.md>
 #[inline(always)]
-pub fn sort<T, F: FnMut(&T, &T) -> bool>(v: &mut [T], is_less: &mut F) {
+pub fn sort<T, F>(v: &mut [T], is_less: &mut F)
+where
+    F: FnMut(&T, &T) -> bool,
+{
     // Arrays of zero-sized types are always all-equal, and thus sorted.
     if T::IS_ZST {
         return;
@@ -52,6 +57,54 @@ pub fn sort<T, F: FnMut(&T, &T) -> bool>(v: &mut [T], is_less: &mut F) {
     }
 }
 
+/// Unstable partial sort the range `start..end`, after which it's guaranteed that:
+///
+/// 1. Every element in `v[..start]` is smaller than or equal to
+/// 2. Every element in `v[start..end]`, which is sorted, and smaller than or equal to
+/// 3. Every element in `v[end..]`.
+#[inline]
+pub fn partial_sort<T, F, R>(v: &mut [T], range: R, mut is_less: F)
+where
+    F: FnMut(&T, &T) -> bool,
+    R: RangeBounds<usize>,
+{
+    // Arrays of zero-sized types are always all-equal, and thus sorted.
+    if T::IS_ZST {
+        return;
+    }
+
+    let len = v.len();
+    let Range { start, end } = slice::range(range, ..len);
+
+    if end - start <= 1 {
+        // Empty range or single element. This case can be resolved in at most
+        // single partition_at_index call, without further sorting.
+
+        if end == 0 || start == len {
+            // Do nothing if it is an empty range at start or end: all guarantees
+            // are already upheld.
+            return;
+        }
+
+        partition_at_index(v, start, &mut is_less);
+        return;
+    }
+
+    // A heuristic factor to decide whether to partition the slice or not.
+    // If the range bound is close to the edges of the slice, it's not worth
+    // partitioning first.
+    const PARTITION_THRESHOLD: usize = 8;
+    let mut v = v;
+    if end + PARTITION_THRESHOLD <= len {
+        v = partition_at_index(v, end - 1, &mut is_less).0;
+    }
+    if start >= PARTITION_THRESHOLD {
+        v = partition_at_index(v, start, &mut is_less).2;
+    }
+
+    sort(v, &mut is_less);
+}
+
 /// See [`sort`]
 ///
 /// Deliberately don't inline the main sorting routine entrypoint to ensure the
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 1eae06ebd33e..22f46ec385ce 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -1550,6 +1550,24 @@ impl<T> AtomicPtr<T> {
         unsafe { &*ptr.cast() }
     }
 
+    /// Creates a new `AtomicPtr` initialized with a null pointer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(atomic_ptr_null)]
+    /// use std::sync::atomic::{AtomicPtr, Ordering};
+    ///
+    /// let atomic_ptr = AtomicPtr::<()>::null();
+    /// assert!(atomic_ptr.load(Ordering::Relaxed).is_null());
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "atomic_ptr_null", issue = "150733")]
+    pub const fn null() -> AtomicPtr<T> {
+        AtomicPtr::new(crate::ptr::null_mut())
+    }
+
     /// Returns a mutable reference to the underlying pointer.
     ///
     /// This is safe because the mutable reference guarantees that no other threads are
diff --git a/library/core/src/task/ready.rs b/library/core/src/task/ready.rs
index 495d72fd14be..468b3b4e528e 100644
--- a/library/core/src/task/ready.rs
+++ b/library/core/src/task/ready.rs
@@ -46,7 +46,7 @@
 /// # }
 /// ```
 #[stable(feature = "ready_macro", since = "1.64.0")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro ready($e:expr) {
     match $e {
         $crate::task::Poll::Ready(t) => t,
diff --git a/library/coretests/benches/num/int_bits/mod.rs b/library/coretests/benches/num/int_bits/mod.rs
index 43531b0b5de9..c6ec51f248ba 100644
--- a/library/coretests/benches/num/int_bits/mod.rs
+++ b/library/coretests/benches/num/int_bits/mod.rs
@@ -4,11 +4,12 @@ macro_rules! bench_template {
     ($op:path, $name:ident, $mask:expr) => {
         #[bench]
         fn $name(bench: &mut ::test::Bencher) {
-            use ::rand::Rng;
+            use ::rand::distr::{Distribution, Uniform};
             let mut rng = crate::bench_rng();
             let mut dst = vec![0; ITERATIONS];
-            let src1: Vec<U> = (0..ITERATIONS).map(|_| rng.random_range(0..=U::MAX)).collect();
-            let mut src2: Vec<U> = (0..ITERATIONS).map(|_| rng.random_range(0..=U::MAX)).collect();
+            let distr = &Uniform::try_from(0..=U::MAX).unwrap();
+            let src1: Vec<U> = distr.sample_iter(&mut rng).take(ITERATIONS).collect();
+            let mut src2: Vec<U> = distr.sample_iter(&mut rng).take(ITERATIONS).collect();
             // Fix the loop invariant mask
             src2[0] = U::MAX / 3;
             let dst = dst.first_chunk_mut().unwrap();
diff --git a/library/coretests/benches/num/int_sqrt/mod.rs b/library/coretests/benches/num/int_sqrt/mod.rs
index 05cb3c5383b2..56172f71dd88 100644
--- a/library/coretests/benches/num/int_sqrt/mod.rs
+++ b/library/coretests/benches/num/int_sqrt/mod.rs
@@ -1,3 +1,5 @@
+use std::iter;
+
 use rand::Rng;
 use test::{Bencher, black_box};
 
@@ -20,7 +22,9 @@ macro_rules! int_sqrt_bench {
             let mut rng = crate::bench_rng();
             /* Exponentially distributed random numbers from the whole range of the type.  */
             let numbers: Vec<$t> =
-                (0..256).map(|_| rng.random::<$t>() >> rng.random_range(0..<$t>::BITS)).collect();
+                iter::repeat_with(|| rng.random::<$t>() >> rng.random_range(0..<$t>::BITS))
+                    .take(256)
+                    .collect();
             bench.iter(|| {
                 for x in &numbers {
                     black_box(black_box(x).isqrt());
@@ -32,9 +36,10 @@ macro_rules! int_sqrt_bench {
         fn $random_small(bench: &mut Bencher) {
             let mut rng = crate::bench_rng();
             /* Exponentially distributed random numbers from the range 0..256.  */
-            let numbers: Vec<$t> = (0..256)
-                .map(|_| (rng.random::<u8>() >> rng.random_range(0..u8::BITS)) as $t)
-                .collect();
+            let numbers: Vec<$t> =
+                iter::repeat_with(|| (rng.random::<u8>() >> rng.random_range(0..u8::BITS)) as $t)
+                    .take(256)
+                    .collect();
             bench.iter(|| {
                 for x in &numbers {
                     black_box(black_box(x).isqrt());
@@ -44,9 +49,9 @@ macro_rules! int_sqrt_bench {
 
         #[bench]
         fn $random_uniform(bench: &mut Bencher) {
-            let mut rng = crate::bench_rng();
+            let rng = crate::bench_rng();
             /* Exponentially distributed random numbers from the whole range of the type.  */
-            let numbers: Vec<$t> = (0..256).map(|_| rng.random::<$t>()).collect();
+            let numbers: Vec<$t> = rng.random_iter().take(256).collect();
             bench.iter(|| {
                 for x in &numbers {
                     black_box(black_box(x).isqrt());
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index b28e7338859c..6a8b6d9ba154 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -90,7 +90,6 @@
 #![feature(one_sided_range)]
 #![feature(option_reduce)]
 #![feature(pattern)]
-#![feature(peekable_next_if_map)]
 #![feature(pointer_is_aligned_to)]
 #![feature(portable_simd)]
 #![feature(ptr_metadata)]
diff --git a/library/proc_macro/Cargo.toml b/library/proc_macro/Cargo.toml
index 3a4840a57334..1e5046ca61c3 100644
--- a/library/proc_macro/Cargo.toml
+++ b/library/proc_macro/Cargo.toml
@@ -9,7 +9,7 @@ std = { path = "../std" }
 # `core` when resolving doc links. Without this line a different `core` will be
 # loaded from sysroot causing duplicate lang items and other similar errors.
 core = { path = "../core" }
-rustc-literal-escaper = { version = "0.0.5", features = ["rustc-dep-of-std"] }
+rustc-literal-escaper = { version = "0.0.7", features = ["rustc-dep-of-std"] }
 
 [features]
 default = ["rustc-dep-of-std"]
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 43caf7734fdb..5c9ae52d9e6c 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -128,10 +128,6 @@ debug_refcell = ["core/debug_refcell"]
 
 llvm_enzyme = ["core/llvm_enzyme"]
 
-# Enable std_detect features:
-std_detect_file_io = ["std_detect/std_detect_file_io"]
-std_detect_dlsym_getauxval = ["std_detect/std_detect_dlsym_getauxval"]
-
 # Enable using raw-dylib for Windows imports.
 # This will eventually be the default.
 windows_raw_dylib = ["windows-targets/windows_raw_dylib"]
diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 251d62bd2033..ad6328f76ed6 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -4,6 +4,7 @@ mod tests;
 use hashbrown::hash_map as base;
 
 use self::Entry::*;
+use crate::alloc::{Allocator, Global};
 use crate::borrow::Borrow;
 use crate::collections::{TryReserveError, TryReserveErrorKind};
 use crate::error::Error;
@@ -243,8 +244,13 @@ use crate::ops::Index;
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashMap")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_insignificant_dtor]
-pub struct HashMap<K, V, S = RandomState> {
-    base: base::HashMap<K, V, S>,
+pub struct HashMap<
+    K,
+    V,
+    S = RandomState,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::HashMap<K, V, S, A>,
 }
 
 impl<K, V> HashMap<K, V, RandomState> {
@@ -286,6 +292,46 @@ impl<K, V> HashMap<K, V, RandomState> {
     }
 }
 
+impl<K, V, A: Allocator> HashMap<K, V, RandomState, A> {
+    /// Creates an empty `HashMap` using the given allocator.
+    ///
+    /// The hash map is initially created with a capacity of 0, so it will not allocate until it
+    /// is first inserted into.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// let mut map: HashMap<&str, i32> = HashMap::new();
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn new_in(alloc: A) -> Self {
+        HashMap::with_hasher_in(Default::default(), alloc)
+    }
+
+    /// Creates an empty `HashMap` with at least the specified capacity using
+    /// the given allocator.
+    ///
+    /// The hash map will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash map will not allocate.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
+        HashMap::with_capacity_and_hasher_in(capacity, Default::default(), alloc)
+    }
+}
+
 impl<K, V, S> HashMap<K, V, S> {
     /// Creates an empty `HashMap` which will use the given hash builder to hash
     /// keys.
@@ -347,6 +393,47 @@ impl<K, V, S> HashMap<K, V, S> {
     pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashMap<K, V, S> {
         HashMap { base: base::HashMap::with_capacity_and_hasher(capacity, hasher) }
     }
+}
+
+impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
+    /// Creates an empty `HashMap` which will use the given hash builder and
+    /// allocator.
+    ///
+    /// The created map has the default initial capacity.
+    ///
+    /// Warning: `hash_builder` is normally randomly generated, and
+    /// is designed to allow HashMaps to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashMap` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_hasher_in(hash_builder: S, alloc: A) -> Self {
+        HashMap { base: base::HashMap::with_hasher_in(hash_builder, alloc) }
+    }
+
+    /// Creates an empty `HashMap` with at least the specified capacity, using
+    /// `hasher` to hash the keys and `alloc` to allocate memory.
+    ///
+    /// The hash map will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash map will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow HashMaps to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hasher` passed should implement the [`BuildHasher`] trait for
+    /// the `HashMap` to be useful, see its documentation for details.
+    ///
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_and_hasher_in(capacity: usize, hash_builder: S, alloc: A) -> Self {
+        HashMap { base: base::HashMap::with_capacity_and_hasher_in(capacity, hash_builder, alloc) }
+    }
 
     /// Returns the number of elements the map can hold without reallocating.
     ///
@@ -424,7 +511,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-    pub fn into_keys(self) -> IntoKeys<K, V> {
+    pub fn into_keys(self) -> IntoKeys<K, V, A> {
         IntoKeys { inner: self.into_iter() }
     }
 
@@ -519,7 +606,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-    pub fn into_values(self) -> IntoValues<K, V> {
+    pub fn into_values(self) -> IntoValues<K, V, A> {
         IntoValues { inner: self.into_iter() }
     }
 
@@ -648,7 +735,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain(&mut self) -> Drain<'_, K, V> {
+    pub fn drain(&mut self) -> Drain<'_, K, V, A> {
         Drain { base: self.base.drain() }
     }
 
@@ -688,7 +775,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "hash_extract_if", since = "1.88.0")]
-    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F>
+    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F, A>
     where
         F: FnMut(&K, &mut V) -> bool,
     {
@@ -762,10 +849,11 @@ impl<K, V, S> HashMap<K, V, S> {
     }
 }
 
-impl<K, V, S> HashMap<K, V, S>
+impl<K, V, S, A> HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     /// Reserves capacity for at least `additional` more elements to be inserted
     /// in the `HashMap`. The collection may reserve more space to speculatively
@@ -884,7 +972,7 @@ where
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V, A> {
         map_entry(self.base.rustc_entry(key))
     }
 
@@ -1232,7 +1320,7 @@ where
     /// assert_eq!(err.value, "b");
     /// ```
     #[unstable(feature = "map_try_insert", issue = "82766")]
-    pub fn try_insert(&mut self, key: K, value: V) -> Result<&mut V, OccupiedError<'_, K, V>> {
+    pub fn try_insert(&mut self, key: K, value: V) -> Result<&mut V, OccupiedError<'_, K, V, A>> {
         match self.entry(key) {
             Occupied(entry) => Err(OccupiedError { entry, value }),
             Vacant(entry) => Ok(entry.insert(value)),
@@ -1298,11 +1386,12 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Clone for HashMap<K, V, S>
+impl<K, V, S, A> Clone for HashMap<K, V, S, A>
 where
     K: Clone,
     V: Clone,
     S: Clone,
+    A: Allocator + Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -1316,13 +1405,14 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> PartialEq for HashMap<K, V, S>
+impl<K, V, S, A> PartialEq for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     V: PartialEq,
     S: BuildHasher,
+    A: Allocator,
 {
-    fn eq(&self, other: &HashMap<K, V, S>) -> bool {
+    fn eq(&self, other: &HashMap<K, V, S, A>) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -1332,19 +1422,21 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Eq for HashMap<K, V, S>
+impl<K, V, S, A> Eq for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     V: Eq,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Debug for HashMap<K, V, S>
+impl<K, V, S, A> Debug for HashMap<K, V, S, A>
 where
     K: Debug,
     V: Debug,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_map().entries(self.iter()).finish()
@@ -1364,11 +1456,12 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, Q: ?Sized, V, S> Index<&Q> for HashMap<K, V, S>
+impl<K, Q: ?Sized, V, S, A> Index<&Q> for HashMap<K, V, S, A>
 where
     K: Eq + Hash + Borrow<Q>,
     Q: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Output = V;
 
@@ -1523,11 +1616,15 @@ impl<K, V> Default for IterMut<'_, K, V> {
 /// let iter = map.into_iter();
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<K, V> {
-    base: base::IntoIter<K, V>,
+pub struct IntoIter<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::IntoIter<K, V, A>,
 }
 
-impl<K, V> IntoIter<K, V> {
+impl<K, V, A: Allocator> IntoIter<K, V, A> {
     /// Returns an iterator of references over the remaining items.
     #[inline]
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
@@ -1656,11 +1753,16 @@ impl<K, V: Debug> fmt::Debug for Values<'_, K, V> {
 /// ```
 #[stable(feature = "drain", since = "1.6.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "hashmap_drain_ty")]
-pub struct Drain<'a, K: 'a, V: 'a> {
-    base: base::Drain<'a, K, V>,
+pub struct Drain<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::Drain<'a, K, V, A>,
 }
 
-impl<'a, K, V> Drain<'a, K, V> {
+impl<'a, K, V, A: Allocator> Drain<'a, K, V, A> {
     /// Returns an iterator of references over the remaining items.
     #[inline]
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
@@ -1687,8 +1789,14 @@ impl<'a, K, V> Drain<'a, K, V> {
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` to remove and discard elements"]
-pub struct ExtractIf<'a, K, V, F> {
-    base: base::ExtractIf<'a, K, V, F>,
+pub struct ExtractIf<
+    'a,
+    K,
+    V,
+    F,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::ExtractIf<'a, K, V, F, A>,
 }
 
 /// A mutable iterator over the values of a `HashMap`.
@@ -1740,8 +1848,12 @@ impl<K, V> Default for ValuesMut<'_, K, V> {
 /// let iter_keys = map.into_keys();
 /// ```
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoKeys<K, V> {
-    inner: IntoIter<K, V>,
+pub struct IntoKeys<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    inner: IntoIter<K, V, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1770,8 +1882,12 @@ impl<K, V> Default for IntoKeys<K, V> {
 /// let iter_keys = map.into_values();
 /// ```
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoValues<K, V> {
-    inner: IntoIter<K, V>,
+pub struct IntoValues<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    inner: IntoIter<K, V, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1789,14 +1905,19 @@ impl<K, V> Default for IntoValues<K, V> {
 /// [`entry`]: HashMap::entry
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashMapEntry")]
-pub enum Entry<'a, K: 'a, V: 'a> {
+pub enum Entry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// An occupied entry.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V>),
+    Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V, A>),
 
     /// A vacant entry.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V>),
+    Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V, A>),
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
@@ -1812,12 +1933,17 @@ impl<K: Debug, V: Debug> Debug for Entry<'_, K, V> {
 /// A view into an occupied entry in a `HashMap`.
 /// It is part of the [`Entry`] enum.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
-    base: base::RustcOccupiedEntry<'a, K, V>,
+pub struct OccupiedEntry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::RustcOccupiedEntry<'a, K, V, A>,
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
-impl<K: Debug, V: Debug> Debug for OccupiedEntry<'_, K, V> {
+impl<K: Debug, V: Debug, A: Allocator> Debug for OccupiedEntry<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedEntry")
             .field("key", self.key())
@@ -1829,12 +1955,17 @@ impl<K: Debug, V: Debug> Debug for OccupiedEntry<'_, K, V> {
 /// A view into a vacant entry in a `HashMap`.
 /// It is part of the [`Entry`] enum.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct VacantEntry<'a, K: 'a, V: 'a> {
-    base: base::RustcVacantEntry<'a, K, V>,
+pub struct VacantEntry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::RustcVacantEntry<'a, K, V, A>,
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
-impl<K: Debug, V> Debug for VacantEntry<'_, K, V> {
+impl<K: Debug, V, A: Allocator> Debug for VacantEntry<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("VacantEntry").field(self.key()).finish()
     }
@@ -1844,15 +1975,20 @@ impl<K: Debug, V> Debug for VacantEntry<'_, K, V> {
 ///
 /// Contains the occupied entry, and the value that was not inserted.
 #[unstable(feature = "map_try_insert", issue = "82766")]
-pub struct OccupiedError<'a, K: 'a, V: 'a> {
+pub struct OccupiedError<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// The entry in the map that was already occupied.
-    pub entry: OccupiedEntry<'a, K, V>,
+    pub entry: OccupiedEntry<'a, K, V, A>,
     /// The value which was not inserted, because the entry was already occupied.
     pub value: V,
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<K: Debug, V: Debug> Debug for OccupiedError<'_, K, V> {
+impl<K: Debug, V: Debug, A: Allocator> Debug for OccupiedError<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedError")
             .field("key", self.entry.key())
@@ -1863,7 +1999,7 @@ impl<K: Debug, V: Debug> Debug for OccupiedError<'_, K, V> {
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<'a, K: Debug, V: Debug> fmt::Display for OccupiedError<'a, K, V> {
+impl<'a, K: Debug, V: Debug, A: Allocator> fmt::Display for OccupiedError<'a, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
@@ -1876,10 +2012,10 @@ impl<'a, K: Debug, V: Debug> fmt::Display for OccupiedError<'a, K, V> {
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<'a, K: Debug, V: Debug> Error for OccupiedError<'a, K, V> {}
+impl<'a, K: Debug, V: Debug, A: Allocator> Error for OccupiedError<'a, K, V, A> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
+impl<'a, K, V, S, A: Allocator> IntoIterator for &'a HashMap<K, V, S, A> {
     type Item = (&'a K, &'a V);
     type IntoIter = Iter<'a, K, V>;
 
@@ -1891,7 +2027,7 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
+impl<'a, K, V, S, A: Allocator> IntoIterator for &'a mut HashMap<K, V, S, A> {
     type Item = (&'a K, &'a mut V);
     type IntoIter = IterMut<'a, K, V>;
 
@@ -1903,9 +2039,9 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> IntoIterator for HashMap<K, V, S> {
+impl<K, V, S, A: Allocator> IntoIterator for HashMap<K, V, S, A> {
     type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
+    type IntoIter = IntoIter<K, V, A>;
 
     /// Creates a consuming iterator, that is, one that moves each key-value
     /// pair out of the map in arbitrary order. The map cannot be used after
@@ -1927,7 +2063,7 @@ impl<K, V, S> IntoIterator for HashMap<K, V, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    fn into_iter(self) -> IntoIter<K, V> {
+    fn into_iter(self) -> IntoIter<K, V, A> {
         IntoIter { base: self.base.into_iter() }
     }
 }
@@ -2015,7 +2151,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> Iterator for IntoIter<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoIter<K, V, A> {
     type Item = (K, V);
 
     #[inline]
@@ -2040,17 +2176,17 @@ impl<K, V> Iterator for IntoIter<K, V> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoIter<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K, V> FusedIterator for IntoIter<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoIter<K, V, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: Debug, V: Debug> fmt::Debug for IntoIter<K, V> {
+impl<K: Debug, V: Debug, A: Allocator> fmt::Debug for IntoIter<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
     }
@@ -2169,7 +2305,7 @@ impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
 }
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> Iterator for IntoKeys<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoKeys<K, V, A> {
     type Item = K;
 
     #[inline]
@@ -2194,24 +2330,24 @@ impl<K, V> Iterator for IntoKeys<K, V> {
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoKeys<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> FusedIterator for IntoKeys<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoKeys<K, V, A> {}
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K: Debug, V> fmt::Debug for IntoKeys<K, V> {
+impl<K: Debug, V, A: Allocator> fmt::Debug for IntoKeys<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.inner.iter().map(|(k, _)| k)).finish()
     }
 }
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> Iterator for IntoValues<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoValues<K, V, A> {
     type Item = V;
 
     #[inline]
@@ -2236,24 +2372,24 @@ impl<K, V> Iterator for IntoValues<K, V> {
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> ExactSizeIterator for IntoValues<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoValues<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> FusedIterator for IntoValues<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoValues<K, V, A> {}
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V: Debug> fmt::Debug for IntoValues<K, V> {
+impl<K, V: Debug, A: Allocator> fmt::Debug for IntoValues<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.inner.iter().map(|(_, v)| v)).finish()
     }
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
-impl<'a, K, V> Iterator for Drain<'a, K, V> {
+impl<'a, K, V, A: Allocator> Iterator for Drain<'a, K, V, A> {
     type Item = (K, V);
 
     #[inline]
@@ -2274,17 +2410,17 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     }
 }
 #[stable(feature = "drain", since = "1.6.0")]
-impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for Drain<'_, K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K, V> FusedIterator for Drain<'_, K, V> {}
+impl<K, V, A: Allocator> FusedIterator for Drain<'_, K, V, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K, V> fmt::Debug for Drain<'_, K, V>
+impl<K, V, A: Allocator> fmt::Debug for Drain<'_, K, V, A>
 where
     K: fmt::Debug,
     V: fmt::Debug,
@@ -2295,7 +2431,7 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> Iterator for ExtractIf<'_, K, V, F>
+impl<K, V, F, A: Allocator> Iterator for ExtractIf<'_, K, V, F, A>
 where
     F: FnMut(&K, &mut V) -> bool,
 {
@@ -2312,10 +2448,13 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {}
+impl<K, V, F, A: Allocator> FusedIterator for ExtractIf<'_, K, V, F, A> where
+    F: FnMut(&K, &mut V) -> bool
+{
+}
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> fmt::Debug for ExtractIf<'_, K, V, F>
+impl<K, V, F, A: Allocator> fmt::Debug for ExtractIf<'_, K, V, F, A>
 where
     K: fmt::Debug,
     V: fmt::Debug,
@@ -2325,7 +2464,7 @@ where
     }
 }
 
-impl<'a, K, V> Entry<'a, K, V> {
+impl<'a, K, V, A: Allocator> Entry<'a, K, V, A> {
     /// Ensures a value is in the entry by inserting the default if empty, and returns
     /// a mutable reference to the value in the entry.
     ///
@@ -2473,7 +2612,7 @@ impl<'a, K, V> Entry<'a, K, V> {
     /// ```
     #[inline]
     #[stable(feature = "entry_insert", since = "1.83.0")]
-    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
         match self {
             Occupied(mut entry) => {
                 entry.insert(value);
@@ -2510,7 +2649,7 @@ impl<'a, K, V: Default> Entry<'a, K, V> {
     }
 }
 
-impl<'a, K, V> OccupiedEntry<'a, K, V> {
+impl<'a, K, V, A: Allocator> OccupiedEntry<'a, K, V, A> {
     /// Gets a reference to the key in the entry.
     ///
     /// # Examples
@@ -2682,7 +2821,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
     }
 }
 
-impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
+impl<'a, K: 'a, V: 'a, A: Allocator> VacantEntry<'a, K, V, A> {
     /// Gets a reference to the key that would be used when inserting a value
     /// through the `VacantEntry`.
     ///
@@ -2760,7 +2899,7 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
     /// ```
     #[inline]
     #[stable(feature = "entry_insert", since = "1.83.0")]
-    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
         let base = self.base.insert_entry(value);
         OccupiedEntry { base }
     }
@@ -2786,10 +2925,11 @@ where
 /// Inserts all new key-values from the iterator and replaces values with existing
 /// keys with new values returned from the iterator.
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Extend<(K, V)> for HashMap<K, V, S>
+impl<K, V, S, A> Extend<(K, V)> for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
@@ -2808,11 +2948,12 @@ where
 }
 
 #[stable(feature = "hash_extend_copy", since = "1.4.0")]
-impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap<K, V, S>
+impl<'a, K, V, S, A> Extend<(&'a K, &'a V)> for HashMap<K, V, S, A>
 where
     K: Eq + Hash + Copy,
     V: Copy,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) {
@@ -2831,7 +2972,9 @@ where
 }
 
 #[inline]
-fn map_entry<'a, K: 'a, V: 'a>(raw: base::RustcEntry<'a, K, V>) -> Entry<'a, K, V> {
+fn map_entry<'a, K: 'a, V: 'a, A: Allocator>(
+    raw: base::RustcEntry<'a, K, V, A>,
+) -> Entry<'a, K, V, A> {
     match raw {
         base::RustcEntry::Occupied(base) => Entry::Occupied(OccupiedEntry { base }),
         base::RustcEntry::Vacant(base) => Entry::Vacant(VacantEntry { base }),
diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs
index 6795da80aacb..02a4a0d9c815 100644
--- a/library/std/src/collections/hash/set.rs
+++ b/library/std/src/collections/hash/set.rs
@@ -4,6 +4,7 @@ mod tests;
 use hashbrown::hash_set as base;
 
 use super::map::map_try_reserve_error;
+use crate::alloc::{Allocator, Global};
 use crate::borrow::Borrow;
 use crate::collections::TryReserveError;
 use crate::fmt;
@@ -122,8 +123,12 @@ use crate::ops::{BitAnd, BitOr, BitXor, Sub};
 /// ```
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashSet")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct HashSet<T, S = RandomState> {
-    base: base::HashSet<T, S>,
+pub struct HashSet<
+    T,
+    S = RandomState,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::HashSet<T, S, A>,
 }
 
 impl<T> HashSet<T, RandomState> {
@@ -166,7 +171,141 @@ impl<T> HashSet<T, RandomState> {
     }
 }
 
+impl<T, A: Allocator> HashSet<T, RandomState, A> {
+    /// Creates an empty `HashSet` in the provided allocator.
+    ///
+    /// The hash set is initially created with a capacity of 0, so it will not allocate until it
+    /// is first inserted into.
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn new_in(alloc: A) -> HashSet<T, RandomState, A> {
+        HashSet::with_hasher_in(Default::default(), alloc)
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// let set: HashSet<i32> = HashSet::with_capacity(10);
+    /// assert!(set.capacity() >= 10);
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> HashSet<T, RandomState, A> {
+        HashSet::with_capacity_and_hasher_in(capacity, Default::default(), alloc)
+    }
+}
+
 impl<T, S> HashSet<T, S> {
+    /// Creates a new empty hash set which will use the given hasher to hash
+    /// keys.
+    ///
+    /// The hash set is also created with the default initial capacity.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_hasher(s);
+    /// set.insert(2);
+    /// ```
+    #[inline]
+    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
+    #[rustc_const_stable(feature = "const_collections_with_hasher", since = "1.85.0")]
+    pub const fn with_hasher(hasher: S) -> HashSet<T, S> {
+        HashSet { base: base::HashSet::with_hasher(hasher) }
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity, using
+    /// `hasher` to hash the keys.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_capacity_and_hasher(10, s);
+    /// set.insert(1);
+    /// ```
+    #[inline]
+    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
+    pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S> {
+        HashSet { base: base::HashSet::with_capacity_and_hasher(capacity, hasher) }
+    }
+}
+
+impl<T, S, A: Allocator> HashSet<T, S, A> {
+    /// Creates a new empty hash set which will use the given hasher to hash
+    /// keys and will allocate memory using the provided allocator.
+    ///
+    /// The hash set is also created with the default initial capacity.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_hasher_in(hasher: S, alloc: A) -> HashSet<T, S, A> {
+        HashSet { base: base::HashSet::with_hasher_in(hasher, alloc) }
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity, using
+    /// `hasher` to hash the keys and `alloc` to allocate memory.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_and_hasher_in(capacity: usize, hasher: S, alloc: A) -> HashSet<T, S, A> {
+        HashSet { base: base::HashSet::with_capacity_and_hasher_in(capacity, hasher, alloc) }
+    }
+
     /// Returns the number of elements the set can hold without reallocating.
     ///
     /// # Examples
@@ -272,7 +411,7 @@ impl<T, S> HashSet<T, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain(&mut self) -> Drain<'_, T> {
+    pub fn drain(&mut self) -> Drain<'_, T, A> {
         Drain { base: self.base.drain() }
     }
 
@@ -309,7 +448,7 @@ impl<T, S> HashSet<T, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "hash_extract_if", since = "1.88.0")]
-    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>
+    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F, A>
     where
         F: FnMut(&T) -> bool,
     {
@@ -362,67 +501,6 @@ impl<T, S> HashSet<T, S> {
         self.base.clear()
     }
 
-    /// Creates a new empty hash set which will use the given hasher to hash
-    /// keys.
-    ///
-    /// The hash set is also created with the default initial capacity.
-    ///
-    /// Warning: `hasher` is normally randomly generated, and
-    /// is designed to allow `HashSet`s to be resistant to attacks that
-    /// cause many collisions and very poor performance. Setting it
-    /// manually using this function can expose a DoS attack vector.
-    ///
-    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
-    /// the `HashSet` to be useful, see its documentation for details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    /// use std::hash::RandomState;
-    ///
-    /// let s = RandomState::new();
-    /// let mut set = HashSet::with_hasher(s);
-    /// set.insert(2);
-    /// ```
-    #[inline]
-    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-    #[rustc_const_stable(feature = "const_collections_with_hasher", since = "1.85.0")]
-    pub const fn with_hasher(hasher: S) -> HashSet<T, S> {
-        HashSet { base: base::HashSet::with_hasher(hasher) }
-    }
-
-    /// Creates an empty `HashSet` with at least the specified capacity, using
-    /// `hasher` to hash the keys.
-    ///
-    /// The hash set will be able to hold at least `capacity` elements without
-    /// reallocating. This method is allowed to allocate for more elements than
-    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
-    ///
-    /// Warning: `hasher` is normally randomly generated, and
-    /// is designed to allow `HashSet`s to be resistant to attacks that
-    /// cause many collisions and very poor performance. Setting it
-    /// manually using this function can expose a DoS attack vector.
-    ///
-    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
-    /// the `HashSet` to be useful, see its documentation for details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    /// use std::hash::RandomState;
-    ///
-    /// let s = RandomState::new();
-    /// let mut set = HashSet::with_capacity_and_hasher(10, s);
-    /// set.insert(1);
-    /// ```
-    #[inline]
-    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-    pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S> {
-        HashSet { base: base::HashSet::with_capacity_and_hasher(capacity, hasher) }
-    }
-
     /// Returns a reference to the set's [`BuildHasher`].
     ///
     /// # Examples
@@ -442,10 +520,11 @@ impl<T, S> HashSet<T, S> {
     }
 }
 
-impl<T, S> HashSet<T, S>
+impl<T, S, A> HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     /// Reserves capacity for at least `additional` more elements to be inserted
     /// in the `HashSet`. The collection may reserve more space to speculatively
@@ -569,7 +648,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> {
+    pub fn difference<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Difference<'a, T, S, A> {
         Difference { iter: self.iter(), other }
     }
 
@@ -599,8 +678,8 @@ where
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn symmetric_difference<'a>(
         &'a self,
-        other: &'a HashSet<T, S>,
-    ) -> SymmetricDifference<'a, T, S> {
+        other: &'a HashSet<T, S, A>,
+    ) -> SymmetricDifference<'a, T, S, A> {
         SymmetricDifference { iter: self.difference(other).chain(other.difference(self)) }
     }
 
@@ -631,7 +710,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> {
+    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Intersection<'a, T, S, A> {
         if self.len() <= other.len() {
             Intersection { iter: self.iter(), other }
         } else {
@@ -660,7 +739,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> {
+    pub fn union<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Union<'a, T, S, A> {
         if self.len() >= other.len() {
             Union { iter: self.iter().chain(other.difference(self)) }
         } else {
@@ -812,7 +891,7 @@ where
     /// ```
     #[inline]
     #[unstable(feature = "hash_set_entry", issue = "60896")]
-    pub fn entry(&mut self, value: T) -> Entry<'_, T, S> {
+    pub fn entry(&mut self, value: T) -> Entry<'_, T, S, A> {
         map_entry(self.base.entry(value))
     }
 
@@ -834,7 +913,7 @@ where
     /// assert_eq!(a.is_disjoint(&b), false);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_disjoint(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() <= other.len() {
             self.iter().all(|v| !other.contains(v))
         } else {
@@ -860,7 +939,7 @@ where
     /// assert_eq!(set.is_subset(&sup), false);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_subset(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_subset(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() <= other.len() { self.iter().all(|v| other.contains(v)) } else { false }
     }
 
@@ -886,7 +965,7 @@ where
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_superset(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_superset(&self, other: &HashSet<T, S, A>) -> bool {
         other.is_subset(self)
     }
 
@@ -995,7 +1074,7 @@ where
 }
 
 #[inline]
-fn map_entry<'a, K: 'a, V: 'a>(raw: base::Entry<'a, K, V>) -> Entry<'a, K, V> {
+fn map_entry<'a, K: 'a, V: 'a, A: Allocator>(raw: base::Entry<'a, K, V, A>) -> Entry<'a, K, V, A> {
     match raw {
         base::Entry::Occupied(base) => Entry::Occupied(OccupiedEntry { base }),
         base::Entry::Vacant(base) => Entry::Vacant(VacantEntry { base }),
@@ -1003,10 +1082,11 @@ fn map_entry<'a, K: 'a, V: 'a>(raw: base::Entry<'a, K, V>) -> Entry<'a, K, V> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for HashSet<T, S>
+impl<T, S, A> Clone for HashSet<T, S, A>
 where
     T: Clone,
     S: Clone,
+    A: Allocator + Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -1024,12 +1104,13 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> PartialEq for HashSet<T, S>
+impl<T, S, A> PartialEq for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
-    fn eq(&self, other: &HashSet<T, S>) -> bool {
+    fn eq(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -1039,17 +1120,19 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Eq for HashSet<T, S>
+impl<T, S, A> Eq for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> fmt::Debug for HashSet<T, S>
+impl<T, S, A> fmt::Debug for HashSet<T, S, A>
 where
     T: fmt::Debug,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_set().entries(self.iter()).finish()
@@ -1107,10 +1190,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Extend<T> for HashSet<T, S>
+impl<T, S, A> Extend<T> for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
@@ -1129,10 +1213,11 @@ where
 }
 
 #[stable(feature = "hash_extend_copy", since = "1.4.0")]
-impl<'a, T, S> Extend<&'a T> for HashSet<T, S>
+impl<'a, T, S, A> Extend<&'a T> for HashSet<T, S, A>
 where
     T: 'a + Eq + Hash + Copy,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
@@ -1341,8 +1426,11 @@ impl<K> Default for Iter<'_, K> {
 /// let mut iter = a.into_iter();
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<K> {
-    base: base::IntoIter<K>,
+pub struct IntoIter<
+    K,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::IntoIter<K, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1371,8 +1459,12 @@ impl<K> Default for IntoIter<K> {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "hashset_drain_ty")]
-pub struct Drain<'a, K: 'a> {
-    base: base::Drain<'a, K>,
+pub struct Drain<
+    'a,
+    K: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::Drain<'a, K, A>,
 }
 
 /// A draining, filtering iterator over the items of a `HashSet`.
@@ -1393,8 +1485,13 @@ pub struct Drain<'a, K: 'a> {
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` to remove and discard elements"]
-pub struct ExtractIf<'a, K, F> {
-    base: base::ExtractIf<'a, K, F>,
+pub struct ExtractIf<
+    'a,
+    K,
+    F,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::ExtractIf<'a, K, F, A>,
 }
 
 /// A lazy iterator producing elements in the intersection of `HashSet`s.
@@ -1417,11 +1514,16 @@ pub struct ExtractIf<'a, K, F> {
 #[must_use = "this returns the intersection as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Intersection<'a, T: 'a, S: 'a> {
+pub struct Intersection<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, S>,
+    other: &'a HashSet<T, S, A>,
 }
 
 /// A lazy iterator producing elements in the difference of `HashSet`s.
@@ -1444,11 +1546,16 @@ pub struct Intersection<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the difference as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Difference<'a, T: 'a, S: 'a> {
+pub struct Difference<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, S>,
+    other: &'a HashSet<T, S, A>,
 }
 
 /// A lazy iterator producing elements in the symmetric difference of `HashSet`s.
@@ -1471,8 +1578,13 @@ pub struct Difference<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the difference as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct SymmetricDifference<'a, T: 'a, S: 'a> {
-    iter: Chain<Difference<'a, T, S>, Difference<'a, T, S>>,
+pub struct SymmetricDifference<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    iter: Chain<Difference<'a, T, S, A>, Difference<'a, T, S, A>>,
 }
 
 /// A lazy iterator producing elements in the union of `HashSet`s.
@@ -1495,12 +1607,17 @@ pub struct SymmetricDifference<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the union as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Union<'a, T: 'a, S: 'a> {
-    iter: Chain<Iter<'a, T>, Difference<'a, T, S>>,
+pub struct Union<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    iter: Chain<Iter<'a, T>, Difference<'a, T, S, A>>,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
+impl<'a, T, S, A: Allocator> IntoIterator for &'a HashSet<T, S, A> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -1512,9 +1629,9 @@ impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> IntoIterator for HashSet<T, S> {
+impl<T, S, A: Allocator> IntoIterator for HashSet<T, S, A> {
     type Item = T;
-    type IntoIter = IntoIter<T>;
+    type IntoIter = IntoIter<T, A>;
 
     /// Creates a consuming iterator, that is, one that moves each value out
     /// of the set in arbitrary order. The set cannot be used after calling
@@ -1538,7 +1655,7 @@ impl<T, S> IntoIterator for HashSet<T, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    fn into_iter(self) -> IntoIter<T> {
+    fn into_iter(self) -> IntoIter<T, A> {
         IntoIter { base: self.base.into_iter() }
     }
 }
@@ -1593,7 +1710,7 @@ impl<K: fmt::Debug> fmt::Debug for Iter<'_, K> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> Iterator for IntoIter<K> {
+impl<K, A: Allocator> Iterator for IntoIter<K, A> {
     type Item = K;
 
     #[inline]
@@ -1618,24 +1735,24 @@ impl<K> Iterator for IntoIter<K> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> ExactSizeIterator for IntoIter<K> {
+impl<K, A: Allocator> ExactSizeIterator for IntoIter<K, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K> FusedIterator for IntoIter<K> {}
+impl<K, A: Allocator> FusedIterator for IntoIter<K, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: fmt::Debug> fmt::Debug for IntoIter<K> {
+impl<K: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<K, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.base, f)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K> Iterator for Drain<'a, K> {
+impl<'a, K, A: Allocator> Iterator for Drain<'a, K, A> {
     type Item = K;
 
     #[inline]
@@ -1656,24 +1773,24 @@ impl<'a, K> Iterator for Drain<'a, K> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> ExactSizeIterator for Drain<'_, K> {
+impl<K, A: Allocator> ExactSizeIterator for Drain<'_, K, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K> FusedIterator for Drain<'_, K> {}
+impl<K, A: Allocator> FusedIterator for Drain<'_, K, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: fmt::Debug> fmt::Debug for Drain<'_, K> {
+impl<K: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, K, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.base, f)
     }
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> Iterator for ExtractIf<'_, K, F>
+impl<K, F, A: Allocator> Iterator for ExtractIf<'_, K, F, A>
 where
     F: FnMut(&K) -> bool,
 {
@@ -1690,10 +1807,10 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> FusedIterator for ExtractIf<'_, K, F> where F: FnMut(&K) -> bool {}
+impl<K, F, A: Allocator> FusedIterator for ExtractIf<'_, K, F, A> where F: FnMut(&K) -> bool {}
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> fmt::Debug for ExtractIf<'_, K, F>
+impl<K, F, A: Allocator> fmt::Debug for ExtractIf<'_, K, F, A>
 where
     K: fmt::Debug,
 {
@@ -1703,7 +1820,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Intersection<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Intersection<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Intersection { iter: self.iter.clone(), ..*self }
@@ -1711,10 +1828,11 @@ impl<T, S> Clone for Intersection<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Intersection<'a, T, S>
+impl<'a, T, S, A> Iterator for Intersection<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1745,10 +1863,11 @@ where
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Intersection<'_, T, S>
+impl<T, S, A> fmt::Debug for Intersection<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1756,15 +1875,16 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Intersection<'_, T, S>
+impl<T, S, A> FusedIterator for Intersection<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Difference<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Difference<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Difference { iter: self.iter.clone(), ..*self }
@@ -1772,10 +1892,11 @@ impl<T, S> Clone for Difference<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Difference<'a, T, S>
+impl<'a, T, S, A> Iterator for Difference<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1806,18 +1927,20 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Difference<'_, T, S>
+impl<T, S, A> FusedIterator for Difference<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Difference<'_, T, S>
+impl<T, S, A> fmt::Debug for Difference<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1825,7 +1948,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for SymmetricDifference<'_, T, S> {
+impl<T, S, A: Allocator> Clone for SymmetricDifference<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         SymmetricDifference { iter: self.iter.clone() }
@@ -1833,10 +1956,11 @@ impl<T, S> Clone for SymmetricDifference<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S>
+impl<'a, T, S, A> Iterator for SymmetricDifference<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1859,18 +1983,20 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for SymmetricDifference<'_, T, S>
+impl<T, S, A> FusedIterator for SymmetricDifference<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for SymmetricDifference<'_, T, S>
+impl<T, S, A> fmt::Debug for SymmetricDifference<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1878,7 +2004,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Union<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Union<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Union { iter: self.iter.clone() }
@@ -1886,7 +2012,7 @@ impl<T, S> Clone for Union<'_, T, S> {
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Union<'_, T, S>
+impl<T, S, A: Allocator> FusedIterator for Union<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
@@ -1894,10 +2020,11 @@ where
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Union<'_, T, S>
+impl<T, S, A: Allocator> fmt::Debug for Union<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1905,10 +2032,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Union<'a, T, S>
+impl<'a, T, S, A> Iterator for Union<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1973,7 +2101,12 @@ where
 /// assert_eq!(vec, ["a", "b", "c", "d", "e"]);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub enum Entry<'a, T, S> {
+pub enum Entry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// An occupied entry.
     ///
     /// # Examples
@@ -1990,7 +2123,7 @@ pub enum Entry<'a, T, S> {
     ///     Entry::Occupied(_) => { }
     /// }
     /// ```
-    Occupied(OccupiedEntry<'a, T, S>),
+    Occupied(OccupiedEntry<'a, T, S, A>),
 
     /// A vacant entry.
     ///
@@ -2008,11 +2141,11 @@ pub enum Entry<'a, T, S> {
     ///     Entry::Vacant(_) => { }
     /// }
     /// ```
-    Vacant(VacantEntry<'a, T, S>),
+    Vacant(VacantEntry<'a, T, S, A>),
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for Entry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for Entry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Entry::Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(),
@@ -2060,12 +2193,17 @@ impl<T: fmt::Debug, S> fmt::Debug for Entry<'_, T, S> {
 /// assert_eq!(set.len(), 2);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub struct OccupiedEntry<'a, T, S> {
-    base: base::OccupiedEntry<'a, T, S>,
+pub struct OccupiedEntry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::OccupiedEntry<'a, T, S, A>,
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for OccupiedEntry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for OccupiedEntry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedEntry").field("value", self.get()).finish()
     }
@@ -2100,18 +2238,23 @@ impl<T: fmt::Debug, S> fmt::Debug for OccupiedEntry<'_, T, S> {
 /// assert!(set.contains("b") && set.len() == 2);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub struct VacantEntry<'a, T, S> {
-    base: base::VacantEntry<'a, T, S>,
+pub struct VacantEntry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::VacantEntry<'a, T, S, A>,
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for VacantEntry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for VacantEntry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("VacantEntry").field(self.get()).finish()
     }
 }
 
-impl<'a, T, S> Entry<'a, T, S> {
+impl<'a, T, S, A: Allocator> Entry<'a, T, S, A> {
     /// Sets the value of the entry, and returns an OccupiedEntry.
     ///
     /// # Examples
@@ -2128,7 +2271,7 @@ impl<'a, T, S> Entry<'a, T, S> {
     /// ```
     #[inline]
     #[unstable(feature = "hash_set_entry", issue = "60896")]
-    pub fn insert(self) -> OccupiedEntry<'a, T, S>
+    pub fn insert(self) -> OccupiedEntry<'a, T, S, A>
     where
         T: Hash,
         S: BuildHasher,
@@ -2198,7 +2341,7 @@ impl<'a, T, S> Entry<'a, T, S> {
     }
 }
 
-impl<T, S> OccupiedEntry<'_, T, S> {
+impl<T, S, A: Allocator> OccupiedEntry<'_, T, S, A> {
     /// Gets a reference to the value in the entry.
     ///
     /// # Examples
@@ -2255,7 +2398,7 @@ impl<T, S> OccupiedEntry<'_, T, S> {
     }
 }
 
-impl<'a, T, S> VacantEntry<'a, T, S> {
+impl<'a, T, S, A: Allocator> VacantEntry<'a, T, S, A> {
     /// Gets a reference to the value that would be used when inserting
     /// through the `VacantEntry`.
     ///
@@ -2325,7 +2468,7 @@ impl<'a, T, S> VacantEntry<'a, T, S> {
     }
 
     #[inline]
-    fn insert_entry(self) -> OccupiedEntry<'a, T, S>
+    fn insert_entry(self) -> OccupiedEntry<'a, T, S, A>
     where
         T: Hash,
         S: BuildHasher,
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index f078dec21d0a..a24baad61501 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -152,6 +152,43 @@ pub enum TryLockError {
     WouldBlock,
 }
 
+/// An object providing access to a directory on the filesystem.
+///
+/// Directories are automatically closed when they go out of scope.  Errors detected
+/// on closing are ignored by the implementation of `Drop`.
+///
+/// # Platform-specific behavior
+///
+/// On supported systems (including Windows and some UNIX-based OSes), this function acquires a
+/// handle/file descriptor for the directory. This allows functions like [`Dir::open_file`] to
+/// avoid [TOCTOU] errors when the directory itself is being moved.
+///
+/// On other systems, it stores an absolute path (see [`canonicalize()`]). In the latter case, no
+/// [TOCTOU] guarantees are made.
+///
+/// # Examples
+///
+/// Opens a directory and then a file inside it.
+///
+/// ```no_run
+/// #![feature(dirfd)]
+/// use std::{fs::Dir, io};
+///
+/// fn main() -> std::io::Result<()> {
+///     let dir = Dir::open("foo")?;
+///     let mut file = dir.open_file("bar.txt")?;
+///     let contents = io::read_to_string(file)?;
+///     assert_eq!(contents, "Hello, world!");
+///     Ok(())
+/// }
+/// ```
+///
+/// [TOCTOU]: self#time-of-check-to-time-of-use-toctou
+#[unstable(feature = "dirfd", issue = "120426")]
+pub struct Dir {
+    inner: fs_imp::Dir,
+}
+
 /// Metadata information about a file.
 ///
 /// This structure is returned from the [`metadata`] or
@@ -1554,6 +1591,87 @@ impl Seek for Arc<File> {
     }
 }
 
+impl Dir {
+    /// Attempts to open a directory at `path` in read-only mode.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `path` does not point to an existing directory.
+    /// Other errors may also be returned according to [`OpenOptions::open`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(dirfd)]
+    /// use std::{fs::Dir, io};
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let dir = Dir::open("foo")?;
+    ///     let mut f = dir.open_file("bar.txt")?;
+    ///     let contents = io::read_to_string(f)?;
+    ///     assert_eq!(contents, "Hello, world!");
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "dirfd", issue = "120426")]
+    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<Self> {
+        fs_imp::Dir::open(path.as_ref(), &OpenOptions::new().read(true).0)
+            .map(|inner| Self { inner })
+    }
+
+    /// Attempts to open a file in read-only mode relative to this directory.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `path` does not point to an existing file.
+    /// Other errors may also be returned according to [`OpenOptions::open`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(dirfd)]
+    /// use std::{fs::Dir, io};
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let dir = Dir::open("foo")?;
+    ///     let mut f = dir.open_file("bar.txt")?;
+    ///     let contents = io::read_to_string(f)?;
+    ///     assert_eq!(contents, "Hello, world!");
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "dirfd", issue = "120426")]
+    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> io::Result<File> {
+        self.inner
+            .open_file(path.as_ref(), &OpenOptions::new().read(true).0)
+            .map(|f| File { inner: f })
+    }
+}
+
+impl AsInner<fs_imp::Dir> for Dir {
+    #[inline]
+    fn as_inner(&self) -> &fs_imp::Dir {
+        &self.inner
+    }
+}
+impl FromInner<fs_imp::Dir> for Dir {
+    fn from_inner(f: fs_imp::Dir) -> Dir {
+        Dir { inner: f }
+    }
+}
+impl IntoInner<fs_imp::Dir> for Dir {
+    fn into_inner(self) -> fs_imp::Dir {
+        self.inner
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl fmt::Debug for Dir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
 impl OpenOptions {
     /// Creates a blank new set of options ready for configuration.
     ///
@@ -3328,30 +3446,48 @@ impl DirBuilder {
     }
 
     fn create_dir_all(&self, path: &Path) -> io::Result<()> {
-        if path == Path::new("") {
+        // if path's parent is None, it is "/" path, which should
+        // return Ok immediately
+        if path == Path::new("") || path.parent() == None {
             return Ok(());
         }
 
-        match self.inner.mkdir(path) {
-            Ok(()) => return Ok(()),
-            Err(ref e) if e.kind() == io::ErrorKind::NotFound => {}
-            Err(_) if path.is_dir() => return Ok(()),
-            Err(e) => return Err(e),
-        }
-        match path.parent() {
-            Some(p) => self.create_dir_all(p)?,
-            None => {
-                return Err(io::const_error!(
-                    io::ErrorKind::Uncategorized,
-                    "failed to create whole tree",
-                ));
+        let ancestors = path.ancestors();
+        let mut uncreated_dirs = 0;
+
+        for ancestor in ancestors {
+            // for relative paths like "foo/bar", the parent of
+            // "foo" will be "" which there's no need to invoke
+            // a mkdir syscall on
+            if ancestor == Path::new("") || ancestor.parent() == None {
+                break;
+            }
+
+            match self.inner.mkdir(ancestor) {
+                Ok(()) => break,
+                Err(e) if e.kind() == io::ErrorKind::NotFound => uncreated_dirs += 1,
+                // we check if the err is AlreadyExists for two reasons
+                //    - in case the path exists as a *file*
+                //    - and to avoid calls to .is_dir() in case of other errs
+                //      (i.e. PermissionDenied)
+                Err(e) if e.kind() == io::ErrorKind::AlreadyExists && ancestor.is_dir() => break,
+                Err(e) => return Err(e),
             }
         }
-        match self.inner.mkdir(path) {
-            Ok(()) => Ok(()),
-            Err(_) if path.is_dir() => Ok(()),
-            Err(e) => Err(e),
+
+        // collect only the uncreated directories w/o letting the vec resize
+        let mut uncreated_dirs_vec = Vec::with_capacity(uncreated_dirs);
+        uncreated_dirs_vec.extend(ancestors.take(uncreated_dirs));
+
+        for uncreated_dir in uncreated_dirs_vec.iter().rev() {
+            if let Err(e) = self.inner.mkdir(uncreated_dir) {
+                if e.kind() != io::ErrorKind::AlreadyExists || !uncreated_dir.is_dir() {
+                    return Err(e);
+                }
+            }
         }
+
+        Ok(())
     }
 }
 
diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
index f15efc7b2f0b..6a86705f2fad 100644
--- a/library/std/src/fs/tests.rs
+++ b/library/std/src/fs/tests.rs
@@ -1,7 +1,11 @@
 use rand::RngCore;
 
+#[cfg(not(miri))]
+use super::Dir;
 use crate::assert_matches::assert_matches;
 use crate::fs::{self, File, FileTimes, OpenOptions, TryLockError};
+#[cfg(not(miri))]
+use crate::io;
 use crate::io::prelude::*;
 use crate::io::{BorrowedBuf, ErrorKind, SeekFrom};
 use crate::mem::MaybeUninit;
@@ -2465,3 +2469,30 @@ fn test_fs_set_times_nofollow() {
     assert_ne!(target_metadata.accessed().unwrap(), accessed);
     assert_ne!(target_metadata.modified().unwrap(), modified);
 }
+
+#[test]
+// FIXME: libc calls fail on miri
+#[cfg(not(miri))]
+fn test_dir_smoke_test() {
+    let tmpdir = tmpdir();
+    let dir = Dir::open(tmpdir.path());
+    check!(dir);
+}
+
+#[test]
+// FIXME: libc calls fail on miri
+#[cfg(not(miri))]
+fn test_dir_read_file() {
+    let tmpdir = tmpdir();
+    let mut f = check!(File::create(tmpdir.join("foo.txt")));
+    check!(f.write(b"bar"));
+    check!(f.flush());
+    drop(f);
+    let dir = check!(Dir::open(tmpdir.path()));
+    let f = check!(dir.open_file("foo.txt"));
+    let buf = check!(io::read_to_string(f));
+    assert_eq!("bar", &buf);
+    let f = check!(dir.open_file(tmpdir.join("foo.txt")));
+    let buf = check!(io::read_to_string(f));
+    assert_eq!("bar", &buf);
+}
diff --git a/library/std/src/io/error.rs b/library/std/src/io/error.rs
index 528eb185df08..898ed0f7469c 100644
--- a/library/std/src/io/error.rs
+++ b/library/std/src/io/error.rs
@@ -187,7 +187,7 @@ pub struct SimpleMessage {
 ///     Err(FAIL)
 /// }
 /// ```
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 #[unstable(feature = "io_const_error", issue = "133448")]
 #[allow_internal_unstable(hint_must_use, io_const_error_internals)]
 pub macro const_error($kind:expr, $message:expr $(,)?) {
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 0dab29712f4f..f5b9f69a5f9f 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -681,9 +681,7 @@ pub mod arch {
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub use std_detect::is_x86_feature_detected;
 
-// Platform-abstraction modules
 mod sys;
-mod sys_common;
 
 pub mod alloc;
 
diff --git a/library/std/src/net/tcp/tests.rs b/library/std/src/net/tcp/tests.rs
index 7c7ef7b2f701..e4a30b80e3df 100644
--- a/library/std/src/net/tcp/tests.rs
+++ b/library/std/src/net/tcp/tests.rs
@@ -37,7 +37,8 @@ fn connect_error() {
             e.kind() == ErrorKind::ConnectionRefused
                 || e.kind() == ErrorKind::InvalidInput
                 || e.kind() == ErrorKind::AddrInUse
-                || e.kind() == ErrorKind::AddrNotAvailable,
+                || e.kind() == ErrorKind::AddrNotAvailable
+                || e.kind() == ErrorKind::NetworkUnreachable,
             "bad error: {} {:?}",
             e,
             e.kind()
diff --git a/library/std/src/os/fd/owned.rs b/library/std/src/os/fd/owned.rs
index 2acac6f086e4..8a39fe073bf9 100644
--- a/library/std/src/os/fd/owned.rs
+++ b/library/std/src/os/fd/owned.rs
@@ -77,7 +77,11 @@ impl BorrowedFd<'_> {
     /// # Safety
     ///
     /// The resource pointed to by `fd` must remain open for the duration of
-    /// the returned `BorrowedFd`, and it must not have the value `-1`.
+    /// the returned `BorrowedFd`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the raw file descriptor has the value `-1`.
     #[inline]
     #[track_caller]
     #[rustc_const_stable(feature = "io_safety", since = "1.63.0")]
@@ -177,6 +181,10 @@ impl FromRawFd for OwnedFd {
     /// [ownership][io-safety]. The resource must not require any cleanup other than `close`.
     ///
     /// [io-safety]: io#io-safety
+    ///
+    /// # Panics
+    ///
+    /// Panics if the raw file descriptor has the value `-1`.
     #[inline]
     #[track_caller]
     unsafe fn from_raw_fd(fd: RawFd) -> Self {
diff --git a/library/std/src/os/linux/process.rs b/library/std/src/os/linux/process.rs
index fef321436f6a..60851db831bf 100644
--- a/library/std/src/os/linux/process.rs
+++ b/library/std/src/os/linux/process.rs
@@ -67,8 +67,10 @@ impl PidFd {
     /// Waits for the child to exit completely, returning the status that it exited with.
     ///
     /// Unlike [`Child::wait`] it does not ensure that the stdin handle is closed.
-    /// Additionally it will not return an `ExitStatus` if the child
-    /// has already been reaped. Instead an error will be returned.
+    ///
+    /// Additionally on kernels prior to 6.15 only the first attempt to
+    /// reap a child will return an ExitStatus, further attempts
+    /// will return an Error.
     ///
     /// [`Child::wait`]: process::Child::wait
     pub fn wait(&self) -> Result<ExitStatus> {
@@ -77,8 +79,8 @@ impl PidFd {
 
     /// Attempts to collect the exit status of the child if it has already exited.
     ///
-    /// Unlike [`Child::try_wait`] this method will return an Error
-    /// if the child has already been reaped.
+    /// On kernels prior to 6.15, and unlike [`Child::try_wait`], only the first attempt
+    /// to reap a child will return an ExitStatus, further attempts will return an Error.
     ///
     /// [`Child::try_wait`]: process::Child::try_wait
     pub fn try_wait(&self) -> Result<Option<ExitStatus>> {
diff --git a/library/std/src/os/unix/io/mod.rs b/library/std/src/os/unix/io/mod.rs
index 6d4090ee31cf..708ebaec362e 100644
--- a/library/std/src/os/unix/io/mod.rs
+++ b/library/std/src/os/unix/io/mod.rs
@@ -92,9 +92,138 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use crate::io::{self, Stderr, StderrLock, Stdin, StdinLock, Stdout, StdoutLock, Write};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use crate::os::fd::*;
+#[allow(unused_imports)] // not used on all targets
+use crate::sys::cvt;
 
 // Tests for this module
 #[cfg(test)]
 mod tests;
+
+#[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+pub trait StdioExt: crate::sealed::Sealed {
+    /// Redirects the stdio file descriptor to point to the file description underpinning `fd`.
+    ///
+    /// Rust std::io write buffers (if any) are flushed, but other runtimes
+    /// (e.g. C stdio) or libraries that acquire a clone of the file descriptor
+    /// will not be aware of this change.
+    ///
+    /// # Platform-specific behavior
+    ///
+    /// This is [currently] implemented using
+    ///
+    /// - `fd_renumber` on wasip1
+    /// - `dup2` on most unixes
+    ///
+    /// [currently]: crate::io#platform-specific-behavior
+    ///
+    /// ```
+    /// #![feature(stdio_swap)]
+    /// use std::io::{self, Read, Write};
+    /// use std::os::unix::io::StdioExt;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///    let (reader, mut writer) = io::pipe()?;
+    ///    let mut stdin = io::stdin();
+    ///    stdin.set_fd(reader)?;
+    ///    writer.write_all(b"Hello, world!")?;
+    ///    let mut buffer = vec![0; 13];
+    ///    assert_eq!(stdin.read(&mut buffer)?, 13);
+    ///    assert_eq!(&buffer, b"Hello, world!");
+    ///    Ok(())
+    /// }
+    /// ```
+    fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()>;
+
+    /// Redirects the stdio file descriptor and returns a new `OwnedFd`
+    /// backed by the previous file description.
+    ///
+    /// See [`set_fd()`] for details.
+    ///
+    /// [`set_fd()`]: StdioExt::set_fd
+    fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd>;
+
+    /// Redirects the stdio file descriptor to the null device (`/dev/null`)
+    /// and returns a new `OwnedFd` backed by the previous file description.
+    ///
+    /// Programs that communicate structured data via stdio can use this early in `main()` to
+    /// extract the fds, treat them as other IO types (`File`, `UnixStream`, etc),
+    /// apply custom buffering or avoid interference from stdio use later in the program.
+    ///
+    /// See [`set_fd()`] for additional details.
+    ///
+    /// [`set_fd()`]: StdioExt::set_fd
+    fn take_fd(&mut self) -> io::Result<OwnedFd>;
+}
+
+macro io_ext_impl($stdio_ty:ty, $stdio_lock_ty:ty, $writer:literal) {
+    #[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+    impl StdioExt for $stdio_ty {
+        fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()> {
+            self.lock().set_fd(fd)
+        }
+
+        fn take_fd(&mut self) -> io::Result<OwnedFd> {
+            self.lock().take_fd()
+        }
+
+        fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd> {
+            self.lock().replace_fd(replace_with)
+        }
+    }
+
+    #[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+    impl StdioExt for $stdio_lock_ty {
+        fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()> {
+            #[cfg($writer)]
+            self.flush()?;
+            replace_stdio_fd(self.as_fd(), fd.into())
+        }
+
+        fn take_fd(&mut self) -> io::Result<OwnedFd> {
+            let null = null_fd()?;
+            let cloned = self.as_fd().try_clone_to_owned()?;
+            self.set_fd(null)?;
+            Ok(cloned)
+        }
+
+        fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd> {
+            let cloned = self.as_fd().try_clone_to_owned()?;
+            self.set_fd(replace_with)?;
+            Ok(cloned)
+        }
+    }
+}
+
+io_ext_impl!(Stdout, StdoutLock<'_>, true);
+io_ext_impl!(Stdin, StdinLock<'_>, false);
+io_ext_impl!(Stderr, StderrLock<'_>, true);
+
+fn null_fd() -> io::Result<OwnedFd> {
+    let null_dev = crate::fs::OpenOptions::new().read(true).write(true).open("/dev/null")?;
+    Ok(null_dev.into())
+}
+
+/// Replaces the underlying file descriptor with the one from `other`.
+/// Does not set CLOEXEC.
+fn replace_stdio_fd(this: BorrowedFd<'_>, other: OwnedFd) -> io::Result<()> {
+    cfg_select! {
+        all(target_os = "wasi", target_env = "p1") => {
+            cvt(unsafe { libc::__wasilibc_fd_renumber(other.as_raw_fd(), this.as_raw_fd()) }).map(|_| ())
+        }
+        not(any(
+            target_arch = "wasm32",
+            target_os = "hermit",
+            target_os = "trusty",
+            target_os = "motor"
+        )) => {
+            cvt(unsafe {libc::dup2(other.as_raw_fd(), this.as_raw_fd())}).map(|_| ())
+        }
+        _ => {
+            let _ = (this, other);
+            Err(io::Error::UNSUPPORTED_PLATFORM)
+        }
+    }
+}
diff --git a/library/std/src/panic.rs b/library/std/src/panic.rs
index beddc328582c..658026a8020f 100644
--- a/library/std/src/panic.rs
+++ b/library/std/src/panic.rs
@@ -212,7 +212,7 @@ impl fmt::Display for PanicHookInfo<'_> {
 #[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
 #[allow_internal_unstable(libstd_sys_internals, const_format_args, panic_internals, rt)]
 #[cfg_attr(not(test), rustc_diagnostic_item = "std_panic_2015_macro")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro panic_2015 {
     () => ({
         $crate::rt::begin_panic("explicit panic")
diff --git a/library/std/src/sync/mod.rs b/library/std/src/sync/mod.rs
index 19b3040dcb27..5da50480c723 100644
--- a/library/std/src/sync/mod.rs
+++ b/library/std/src/sync/mod.rs
@@ -184,6 +184,8 @@ pub use alloc_crate::sync::{Arc, Weak};
 #[unstable(feature = "mpmc_channel", issue = "126840")]
 pub mod mpmc;
 pub mod mpsc;
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub mod oneshot;
 
 pub(crate) mod once; // `pub(crate)` for the `sys::sync::once` implementations and `LazyLock`.
 
diff --git a/library/std/src/sync/mpmc/mod.rs b/library/std/src/sync/mpmc/mod.rs
index ee9795a52812..8df81a580f7b 100644
--- a/library/std/src/sync/mpmc/mod.rs
+++ b/library/std/src/sync/mpmc/mod.rs
@@ -654,7 +654,7 @@ impl<T> Clone for Sender<T> {
 #[unstable(feature = "mpmc_channel", issue = "126840")]
 impl<T> fmt::Debug for Sender<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("Sender { .. }")
+        f.debug_struct("Sender").finish_non_exhaustive()
     }
 }
 
@@ -1380,7 +1380,7 @@ impl<T> Clone for Receiver<T> {
 #[unstable(feature = "mpmc_channel", issue = "126840")]
 impl<T> fmt::Debug for Receiver<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("Receiver { .. }")
+        f.debug_struct("Receiver").finish_non_exhaustive()
     }
 }
 
diff --git a/library/std/src/sync/mpsc.rs b/library/std/src/sync/mpsc.rs
index f91c26aa22cf..0ae23f6e13bf 100644
--- a/library/std/src/sync/mpsc.rs
+++ b/library/std/src/sync/mpsc.rs
@@ -1114,8 +1114,10 @@ impl<T> error::Error for SendError<T> {}
 impl<T> fmt::Debug for TrySendError<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            TrySendError::Full(..) => "Full(..)".fmt(f),
-            TrySendError::Disconnected(..) => "Disconnected(..)".fmt(f),
+            TrySendError::Full(..) => f.debug_tuple("TrySendError::Full").finish_non_exhaustive(),
+            TrySendError::Disconnected(..) => {
+                f.debug_tuple("TrySendError::Disconnected").finish_non_exhaustive()
+            }
         }
     }
 }
diff --git a/library/std/src/sync/nonpoison/mutex.rs b/library/std/src/sync/nonpoison/mutex.rs
index ed3f8cfed821..307bf8eaf512 100644
--- a/library/std/src/sync/nonpoison/mutex.rs
+++ b/library/std/src/sync/nonpoison/mutex.rs
@@ -422,7 +422,7 @@ impl<T> From<T> for Mutex<T> {
 }
 
 #[unstable(feature = "nonpoison_mutex", issue = "134645")]
-impl<T: ?Sized + Default> Default for Mutex<T> {
+impl<T: Default> Default for Mutex<T> {
     /// Creates a `Mutex<T>`, with the `Default` value for T.
     fn default() -> Mutex<T> {
         Mutex::new(Default::default())
diff --git a/library/std/src/sync/oneshot.rs b/library/std/src/sync/oneshot.rs
new file mode 100644
index 000000000000..b2c9ba34c0ff
--- /dev/null
+++ b/library/std/src/sync/oneshot.rs
@@ -0,0 +1,466 @@
+//! A single-producer, single-consumer (oneshot) channel.
+//!
+//! This is an experimental module, so the API will likely change.
+
+use crate::sync::mpmc;
+use crate::sync::mpsc::{RecvError, SendError};
+use crate::time::{Duration, Instant};
+use crate::{error, fmt};
+
+/// Creates a new oneshot channel, returning the sender/receiver halves.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(oneshot_channel)]
+/// use std::sync::oneshot;
+/// use std::thread;
+///
+/// let (sender, receiver) = oneshot::channel();
+///
+/// // Spawn off an expensive computation.
+/// thread::spawn(move || {
+/// #   fn expensive_computation() -> i32 { 42 }
+///     sender.send(expensive_computation()).unwrap();
+///     // `sender` is consumed by `send`, so we cannot use it anymore.
+/// });
+///
+/// # fn do_other_work() -> i32 { 42 }
+/// do_other_work();
+///
+/// // Let's see what that answer was...
+/// println!("{:?}", receiver.recv().unwrap());
+/// // `receiver` is consumed by `recv`, so we cannot use it anymore.
+/// ```
+#[must_use]
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
+    // Using a `sync_channel` with capacity 1 means that the internal implementation will use the
+    // `Array`-flavored channel implementation.
+    let (sender, receiver) = mpmc::sync_channel(1);
+    (Sender { inner: sender }, Receiver { inner: receiver })
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Sender
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// The sending half of a oneshot channel.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(oneshot_channel)]
+/// use std::sync::oneshot;
+/// use std::thread;
+///
+/// let (sender, receiver) = oneshot::channel();
+///
+/// thread::spawn(move || {
+///     sender.send("Hello from thread!").unwrap();
+/// });
+///
+/// assert_eq!(receiver.recv().unwrap(), "Hello from thread!");
+/// ```
+///
+/// `Sender` cannot be sent between threads if it is sending non-`Send` types.
+///
+/// ```compile_fail
+/// #![feature(oneshot_channel)]
+/// use std::sync::oneshot;
+/// use std::thread;
+/// use std::ptr;
+///
+/// let (sender, receiver) = oneshot::channel();
+///
+/// struct NotSend(*mut ());
+/// thread::spawn(move || {
+///     sender.send(NotSend(ptr::null_mut()));
+/// });
+///
+/// let reply = receiver.try_recv().unwrap();
+/// ```
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub struct Sender<T> {
+    /// The `oneshot` channel is simply a wrapper around a `mpmc` channel.
+    inner: mpmc::Sender<T>,
+}
+
+// SAFETY: Since the only methods in which synchronization must occur take full ownership of the
+// [`Sender`], it is perfectly safe to share a `&Sender` between threads (as it is effectively
+// useless without ownership).
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+unsafe impl<T> Sync for Sender<T> {}
+
+impl<T> Sender<T> {
+    /// Attempts to send a value through this channel. This can only fail if the corresponding
+    /// [`Receiver<T>`] has been dropped.
+    ///
+    /// This method is non-blocking (wait-free).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(oneshot_channel)]
+    /// use std::sync::oneshot;
+    /// use std::thread;
+    ///
+    /// let (tx, rx) = oneshot::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     // Perform some computation.
+    ///     let result = 2 + 2;
+    ///     tx.send(result).unwrap();
+    /// });
+    ///
+    /// assert_eq!(rx.recv().unwrap(), 4);
+    /// ```
+    #[unstable(feature = "oneshot_channel", issue = "143674")]
+    pub fn send(self, t: T) -> Result<(), SendError<T>> {
+        self.inner.send(t)
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Debug for Sender<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Sender").finish_non_exhaustive()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Receiver
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// The receiving half of a oneshot channel.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(oneshot_channel)]
+/// use std::sync::oneshot;
+/// use std::thread;
+/// use std::time::Duration;
+///
+/// let (sender, receiver) = oneshot::channel();
+///
+/// thread::spawn(move || {
+///     thread::sleep(Duration::from_millis(100));
+///     sender.send("Hello after delay!").unwrap();
+/// });
+///
+/// println!("Waiting for message...");
+/// println!("{}", receiver.recv().unwrap());
+/// ```
+///
+/// `Receiver` cannot be sent between threads if it is receiving non-`Send` types.
+///
+/// ```compile_fail
+/// # #![feature(oneshot_channel)]
+/// # use std::sync::oneshot;
+/// # use std::thread;
+/// # use std::ptr;
+/// #
+/// let (sender, receiver) = oneshot::channel();
+///
+/// struct NotSend(*mut ());
+/// sender.send(NotSend(ptr::null_mut()));
+///
+/// thread::spawn(move || {
+///     let reply = receiver.try_recv().unwrap();
+/// });
+/// ```
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub struct Receiver<T> {
+    /// The `oneshot` channel is simply a wrapper around a `mpmc` channel.
+    inner: mpmc::Receiver<T>,
+}
+
+// SAFETY: Since the only methods in which synchronization must occur take full ownership of the
+// [`Receiver`], it is perfectly safe to share a `&Receiver` between threads (as it is unable to
+// receive any values without ownership).
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+unsafe impl<T> Sync for Receiver<T> {}
+
+impl<T> Receiver<T> {
+    /// Receives the value from the sending end, blocking the calling thread until it gets it.
+    ///
+    /// Can only fail if the corresponding [`Sender<T>`] has been dropped.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(oneshot_channel)]
+    /// use std::sync::oneshot;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let (tx, rx) = oneshot::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_millis(500));
+    ///     tx.send("Done!").unwrap();
+    /// });
+    ///
+    /// // This will block until the message arrives.
+    /// println!("{}", rx.recv().unwrap());
+    /// ```
+    #[unstable(feature = "oneshot_channel", issue = "143674")]
+    pub fn recv(self) -> Result<T, RecvError> {
+        self.inner.recv()
+    }
+
+    // Fallible methods.
+
+    /// Attempts to return a pending value on this receiver without blocking.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(oneshot_channel)]
+    /// use std::sync::oneshot;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let (sender, mut receiver) = oneshot::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_millis(100));
+    ///     sender.send(42).unwrap();
+    /// });
+    ///
+    /// // Keep trying until we get the message, doing other work in the process.
+    /// loop {
+    ///     match receiver.try_recv() {
+    ///         Ok(value) => {
+    ///             assert_eq!(value, 42);
+    ///             break;
+    ///         }
+    ///         Err(oneshot::TryRecvError::Empty(rx)) => {
+    ///             // Retake ownership of the receiver.
+    ///             receiver = rx;
+    /// #           fn do_other_work() { thread::sleep(Duration::from_millis(25)); }
+    ///             do_other_work();
+    ///         }
+    ///         Err(oneshot::TryRecvError::Disconnected) => panic!("Sender disconnected"),
+    ///     }
+    /// }
+    /// ```
+    #[unstable(feature = "oneshot_channel", issue = "143674")]
+    pub fn try_recv(self) -> Result<T, TryRecvError<T>> {
+        self.inner.try_recv().map_err(|err| match err {
+            mpmc::TryRecvError::Empty => TryRecvError::Empty(self),
+            mpmc::TryRecvError::Disconnected => TryRecvError::Disconnected,
+        })
+    }
+
+    /// Attempts to wait for a value on this receiver, returning an error if the corresponding
+    /// [`Sender`] half of this channel has been dropped, or if it waits more than `timeout`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(oneshot_channel)]
+    /// use std::sync::oneshot;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let (sender, receiver) = oneshot::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_millis(500));
+    ///     sender.send("Success!").unwrap();
+    /// });
+    ///
+    /// // Wait up to 1 second for the message
+    /// match receiver.recv_timeout(Duration::from_secs(1)) {
+    ///     Ok(msg) => println!("Received: {}", msg),
+    ///     Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Timed out!"),
+    ///     Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
+    /// }
+    /// ```
+    #[unstable(feature = "oneshot_channel", issue = "143674")]
+    pub fn recv_timeout(self, timeout: Duration) -> Result<T, RecvTimeoutError<T>> {
+        self.inner.recv_timeout(timeout).map_err(|err| match err {
+            mpmc::RecvTimeoutError::Timeout => RecvTimeoutError::Timeout(self),
+            mpmc::RecvTimeoutError::Disconnected => RecvTimeoutError::Disconnected,
+        })
+    }
+
+    /// Attempts to wait for a value on this receiver, returning an error if the corresponding
+    /// [`Sender`] half of this channel has been dropped, or if `deadline` is reached.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(oneshot_channel)]
+    /// use std::sync::oneshot;
+    /// use std::thread;
+    /// use std::time::{Duration, Instant};
+    ///
+    /// let (sender, receiver) = oneshot::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_millis(100));
+    ///     sender.send("Just in time!").unwrap();
+    /// });
+    ///
+    /// let deadline = Instant::now() + Duration::from_millis(500);
+    /// match receiver.recv_deadline(deadline) {
+    ///     Ok(msg) => println!("Received: {}", msg),
+    ///     Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Missed deadline!"),
+    ///     Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
+    /// }
+    /// ```
+    #[unstable(feature = "oneshot_channel", issue = "143674")]
+    pub fn recv_deadline(self, deadline: Instant) -> Result<T, RecvTimeoutError<T>> {
+        self.inner.recv_deadline(deadline).map_err(|err| match err {
+            mpmc::RecvTimeoutError::Timeout => RecvTimeoutError::Timeout(self),
+            mpmc::RecvTimeoutError::Disconnected => RecvTimeoutError::Disconnected,
+        })
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Debug for Receiver<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Receiver").finish_non_exhaustive()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Receiver Errors
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// An error returned from the [`try_recv`](Receiver::try_recv) method.
+///
+/// See the documentation for [`try_recv`] for more information on how to use this error.
+///
+/// [`try_recv`]: Receiver::try_recv
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub enum TryRecvError<T> {
+    /// The [`Sender`] has not sent a message yet, but it might in the future (as it has not yet
+    /// disconnected). This variant contains the [`Receiver`] that [`try_recv`](Receiver::try_recv)
+    /// took ownership over.
+    Empty(Receiver<T>),
+    /// The corresponding [`Sender`] half of this channel has become disconnected, and there will
+    /// never be any more data sent over the channel.
+    Disconnected,
+}
+
+/// An error returned from the [`recv_timeout`](Receiver::recv_timeout) or
+/// [`recv_deadline`](Receiver::recv_deadline) methods.
+///
+/// # Examples
+///
+/// Usage of this error is similar to [`TryRecvError`].
+///
+/// ```
+/// #![feature(oneshot_channel)]
+/// use std::sync::oneshot::{self, RecvTimeoutError};
+/// use std::thread;
+/// use std::time::Duration;
+///
+/// let (sender, receiver) = oneshot::channel();
+///
+/// let send_failure = thread::spawn(move || {
+///     // Simulate a long computation that takes longer than our timeout.
+///     thread::sleep(Duration::from_millis(250));
+///
+///     // This will likely fail to send because we drop the receiver in the main thread.
+///     sender.send("Goodbye!".to_string()).unwrap();
+/// });
+///
+/// // Try to receive the message with a short timeout.
+/// match receiver.recv_timeout(Duration::from_millis(10)) {
+///     Ok(msg) => println!("Received: {}", msg),
+///     Err(RecvTimeoutError::Timeout(rx)) => {
+///         println!("Timed out waiting for message!");
+///
+///         // Note that you can reuse the receiver without dropping it.
+///         drop(rx);
+///     },
+///     Err(RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
+/// }
+///
+/// send_failure.join().unwrap_err();
+/// ```
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+pub enum RecvTimeoutError<T> {
+    /// The [`Sender`] has not sent a message yet, but it might in the future (as it has not yet
+    /// disconnected). This variant contains the [`Receiver`] that either
+    /// [`recv_timeout`](Receiver::recv_timeout) or [`recv_deadline`](Receiver::recv_deadline) took
+    /// ownership over.
+    Timeout(Receiver<T>),
+    /// The corresponding [`Sender`] half of this channel has become disconnected, and there will
+    /// never be any more data sent over the channel.
+    Disconnected,
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Debug for TryRecvError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("TryRecvError").finish_non_exhaustive()
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Display for TryRecvError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            TryRecvError::Empty(..) => "receiving on an empty oneshot channel".fmt(f),
+            TryRecvError::Disconnected => "receiving on a closed oneshot channel".fmt(f),
+        }
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> error::Error for TryRecvError<T> {}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> From<RecvError> for TryRecvError<T> {
+    /// Converts a `RecvError` into a `TryRecvError`.
+    ///
+    /// This conversion always returns `TryRecvError::Disconnected`.
+    ///
+    /// No data is allocated on the heap.
+    fn from(err: RecvError) -> TryRecvError<T> {
+        match err {
+            RecvError => TryRecvError::Disconnected,
+        }
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Debug for RecvTimeoutError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("RecvTimeoutError").finish_non_exhaustive()
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> fmt::Display for RecvTimeoutError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            RecvTimeoutError::Timeout(..) => "timed out waiting on oneshot channel".fmt(f),
+            RecvTimeoutError::Disconnected => "receiving on a closed oneshot channel".fmt(f),
+        }
+    }
+}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> error::Error for RecvTimeoutError<T> {}
+
+#[unstable(feature = "oneshot_channel", issue = "143674")]
+impl<T> From<RecvError> for RecvTimeoutError<T> {
+    /// Converts a `RecvError` into a `RecvTimeoutError`.
+    ///
+    /// This conversion always returns `RecvTimeoutError::Disconnected`.
+    ///
+    /// No data is allocated on the heap.
+    fn from(err: RecvError) -> RecvTimeoutError<T> {
+        match err {
+            RecvError => RecvTimeoutError::Disconnected,
+        }
+    }
+}
diff --git a/library/std/src/sync/poison/mutex.rs b/library/std/src/sync/poison/mutex.rs
index 7f9e5fe62516..6eccd8a875ed 100644
--- a/library/std/src/sync/poison/mutex.rs
+++ b/library/std/src/sync/poison/mutex.rs
@@ -688,7 +688,7 @@ impl<T> From<T> for Mutex<T> {
 }
 
 #[stable(feature = "mutex_default", since = "1.10.0")]
-impl<T: ?Sized + Default> Default for Mutex<T> {
+impl<T: Default> Default for Mutex<T> {
     /// Creates a `Mutex<T>`, with the `Default` value for T.
     fn default() -> Mutex<T> {
         Mutex::new(Default::default())
diff --git a/library/std/src/sys/args/windows.rs b/library/std/src/sys/args/windows.rs
index b4de759e1a4c..c1988657ff1b 100644
--- a/library/std/src/sys/args/windows.rs
+++ b/library/std/src/sys/args/windows.rs
@@ -11,11 +11,11 @@ use crate::ffi::{OsStr, OsString};
 use crate::num::NonZero;
 use crate::os::windows::prelude::*;
 use crate::path::{Path, PathBuf};
+use crate::sys::helpers::WStrUnits;
 use crate::sys::pal::os::current_exe;
 use crate::sys::pal::{ensure_no_nuls, fill_utf16_buf};
 use crate::sys::path::get_long_path;
 use crate::sys::{AsInner, c, to_u16s};
-use crate::sys_common::wstr::WStrUnits;
 use crate::{io, iter, ptr};
 
 pub fn args() -> Args {
diff --git a/library/std/src/sys/configure_builtins.rs b/library/std/src/sys/configure_builtins.rs
index f569ec0f5129..7cdf04ebb889 100644
--- a/library/std/src/sys/configure_builtins.rs
+++ b/library/std/src/sys/configure_builtins.rs
@@ -1,3 +1,7 @@
+//! The configure builtins provides runtime support compiler-builtin features
+//! which require dynamic initialization to work as expected, e.g. aarch64
+//! outline-atomics.
+
 /// Enable LSE atomic operations at startup, if supported.
 ///
 /// Linker sections are based on what [`ctor`] does, with priorities to run slightly before user
diff --git a/library/std/src/sys/env/solid.rs b/library/std/src/sys/env/solid.rs
index ea77fc3c1193..0ce5a22b4256 100644
--- a/library/std/src/sys/env/solid.rs
+++ b/library/std/src/sys/env/solid.rs
@@ -6,7 +6,7 @@ use crate::io;
 use crate::os::raw::{c_char, c_int};
 use crate::os::solid::ffi::{OsStrExt, OsStringExt};
 use crate::sync::{PoisonError, RwLock};
-use crate::sys::common::small_c_string::run_with_cstr;
+use crate::sys::helpers::run_with_cstr;
 
 static ENV_LOCK: RwLock<()> = RwLock::new(());
 
diff --git a/library/std/src/sys/env/uefi.rs b/library/std/src/sys/env/uefi.rs
index 1561df41cac3..5fe29a47a2ea 100644
--- a/library/std/src/sys/env/uefi.rs
+++ b/library/std/src/sys/env/uefi.rs
@@ -24,7 +24,7 @@ mod uefi_env {
     use crate::io;
     use crate::os::uefi::ffi::OsStringExt;
     use crate::ptr::NonNull;
-    use crate::sys::{helpers, unsupported_err};
+    use crate::sys::pal::{helpers, unsupported_err};
 
     pub(crate) fn get(key: &OsStr) -> Option<OsString> {
         let shell = helpers::open_shell()?;
diff --git a/library/std/src/sys/env/unix.rs b/library/std/src/sys/env/unix.rs
index 78c7af65f9e3..66805ce3fa71 100644
--- a/library/std/src/sys/env/unix.rs
+++ b/library/std/src/sys/env/unix.rs
@@ -7,8 +7,8 @@ use crate::ffi::{CStr, OsStr, OsString};
 use crate::io;
 use crate::os::unix::prelude::*;
 use crate::sync::{PoisonError, RwLock};
-use crate::sys::common::small_c_string::run_with_cstr;
 use crate::sys::cvt;
+use crate::sys::helpers::run_with_cstr;
 
 // Use `_NSGetEnviron` on Apple platforms.
 //
diff --git a/library/std/src/sys/env/wasi.rs b/library/std/src/sys/env/wasi.rs
index 1327cbc3263b..c970aac18260 100644
--- a/library/std/src/sys/env/wasi.rs
+++ b/library/std/src/sys/env/wasi.rs
@@ -4,7 +4,7 @@ pub use super::common::Env;
 use crate::ffi::{CStr, OsStr, OsString};
 use crate::io;
 use crate::os::wasi::prelude::*;
-use crate::sys::common::small_c_string::run_with_cstr;
+use crate::sys::helpers::run_with_cstr;
 use crate::sys::pal::os::{cvt, libc};
 
 cfg_select! {
diff --git a/library/std/src/sys/fs/common.rs b/library/std/src/sys/fs/common.rs
index bfd684d295b8..4d47d392a826 100644
--- a/library/std/src/sys/fs/common.rs
+++ b/library/std/src/sys/fs/common.rs
@@ -1,9 +1,10 @@
 #![allow(dead_code)] // not used on all platforms
 
-use crate::fs;
 use crate::io::{self, Error, ErrorKind};
-use crate::path::Path;
-use crate::sys_common::ignore_notfound;
+use crate::path::{Path, PathBuf};
+use crate::sys::fs::{File, OpenOptions};
+use crate::sys::helpers::ignore_notfound;
+use crate::{fmt, fs};
 
 pub(crate) const NOT_FILE_ERROR: Error = io::const_error!(
     ErrorKind::InvalidInput,
@@ -58,3 +59,23 @@ pub fn exists(path: &Path) -> io::Result<bool> {
         Err(error) => Err(error),
     }
 }
+
+pub struct Dir {
+    path: PathBuf,
+}
+
+impl Dir {
+    pub fn open(path: &Path, _opts: &OpenOptions) -> io::Result<Self> {
+        path.canonicalize().map(|path| Self { path })
+    }
+
+    pub fn open_file(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        File::open(&self.path.join(path), &opts)
+    }
+}
+
+impl fmt::Debug for Dir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Dir").field("path", &self.path).finish()
+    }
+}
diff --git a/library/std/src/sys/fs/hermit.rs b/library/std/src/sys/fs/hermit.rs
index 0914e4b6c907..1e281eb0d9d1 100644
--- a/library/std/src/sys/fs/hermit.rs
+++ b/library/std/src/sys/fs/hermit.rs
@@ -9,15 +9,16 @@ use crate::os::hermit::hermit_abi::{
 use crate::os::hermit::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use crate::path::{Path, PathBuf};
 use crate::sync::Arc;
-use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::fd::FileDesc;
-pub use crate::sys::fs::common::{copy, exists};
+pub use crate::sys::fs::common::{Dir, copy, exists};
+use crate::sys::helpers::run_path_with_cstr;
 use crate::sys::time::SystemTime;
 use crate::sys::{AsInner, AsInnerMut, FromInner, IntoInner, cvt, unsupported, unsupported_err};
 use crate::{fmt, mem};
 
 #[derive(Debug)]
 pub struct File(FileDesc);
+
 #[derive(Clone)]
 pub struct FileAttr {
     stat_val: stat_struct,
diff --git a/library/std/src/sys/fs/mod.rs b/library/std/src/sys/fs/mod.rs
index 4a66227ce5f4..0c297c5766b8 100644
--- a/library/std/src/sys/fs/mod.rs
+++ b/library/std/src/sys/fs/mod.rs
@@ -17,7 +17,7 @@ cfg_select! {
         pub(crate) use unix::debug_assert_fd_is_open;
         #[cfg(any(target_os = "linux", target_os = "android"))]
         pub(super) use unix::CachedFileMetadata;
-        use crate::sys::common::small_c_string::run_path_with_cstr as with_native_path;
+        use crate::sys::helpers::run_path_with_cstr as with_native_path;
     }
     target_os = "windows" => {
         mod windows;
@@ -59,7 +59,7 @@ pub fn with_native_path<T>(path: &Path, f: &dyn Fn(&Path) -> io::Result<T>) -> i
 }
 
 pub use imp::{
-    DirBuilder, DirEntry, File, FileAttr, FilePermissions, FileTimes, FileType, OpenOptions,
+    Dir, DirBuilder, DirEntry, File, FileAttr, FilePermissions, FileTimes, FileType, OpenOptions,
     ReadDir,
 };
 
diff --git a/library/std/src/sys/fs/motor.rs b/library/std/src/sys/fs/motor.rs
index 8f3336e2fa96..2ae01db24be5 100644
--- a/library/std/src/sys/fs/motor.rs
+++ b/library/std/src/sys/fs/motor.rs
@@ -4,7 +4,7 @@ use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use crate::path::{Path, PathBuf};
 use crate::sys::fd::FileDesc;
-pub use crate::sys::fs::common::exists;
+pub use crate::sys::fs::common::{Dir, exists};
 use crate::sys::time::SystemTime;
 use crate::sys::{AsInner, AsInnerMut, FromInner, IntoInner, map_motor_error, unsupported};
 
diff --git a/library/std/src/sys/fs/solid.rs b/library/std/src/sys/fs/solid.rs
index f6d5d3b784d3..114ffda57bc5 100644
--- a/library/std/src/sys/fs/solid.rs
+++ b/library/std/src/sys/fs/solid.rs
@@ -9,11 +9,11 @@ use crate::os::raw::{c_int, c_short};
 use crate::os::solid::ffi::OsStrExt;
 use crate::path::{Path, PathBuf};
 use crate::sync::Arc;
-pub use crate::sys::fs::common::exists;
+pub use crate::sys::fs::common::{Dir, exists};
+use crate::sys::helpers::ignore_notfound;
 use crate::sys::pal::{abi, error};
 use crate::sys::time::SystemTime;
 use crate::sys::{unsupported, unsupported_err};
-use crate::sys_common::ignore_notfound;
 
 type CIntNotMinusOne = core::num::niche_types::NotAllOnes<c_int>;
 
diff --git a/library/std/src/sys/fs/uefi.rs b/library/std/src/sys/fs/uefi.rs
index 8339d835dd1c..8061068e447a 100644
--- a/library/std/src/sys/fs/uefi.rs
+++ b/library/std/src/sys/fs/uefi.rs
@@ -6,12 +6,13 @@ use crate::fs::TryLockError;
 use crate::hash::Hash;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::path::{Path, PathBuf};
+pub use crate::sys::fs::common::{Dir, remove_dir_all};
+use crate::sys::pal::{helpers, unsupported};
 use crate::sys::time::SystemTime;
-use crate::sys::{helpers, unsupported};
 
 const FILE_PERMISSIONS_MASK: u64 = r_efi::protocols::file::READ_ONLY;
 
-pub struct File(!);
+pub struct File(uefi_fs::File);
 
 #[derive(Clone)]
 pub struct FileAttr {
@@ -243,9 +244,11 @@ impl OpenOptions {
 
     pub fn create_new(&mut self, create_new: bool) {
         self.create_new = create_new;
+        if create_new {
+            self.create(true);
+        }
     }
 
-    #[expect(dead_code)]
     const fn is_mode_valid(&self) -> bool {
         // Valid Combinations: Read, Read/Write, Read/Write/Create
         self.mode == file::MODE_READ
@@ -255,100 +258,142 @@ impl OpenOptions {
 }
 
 impl File {
-    pub fn open(_path: &Path, _opts: &OpenOptions) -> io::Result<File> {
-        unsupported()
+    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        if !opts.is_mode_valid() {
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "Invalid open options"));
+        }
+
+        if opts.create_new && exists(path)? {
+            return Err(io::const_error!(io::ErrorKind::AlreadyExists, "File already exists"));
+        }
+
+        let f = uefi_fs::File::from_path(path, opts.mode, 0).map(Self)?;
+
+        if opts.truncate {
+            f.truncate(0)?;
+        }
+
+        if opts.append {
+            f.seek(io::SeekFrom::End(0))?;
+        }
+
+        Ok(f)
     }
 
     pub fn file_attr(&self) -> io::Result<FileAttr> {
-        self.0
+        self.0.file_info().map(FileAttr::from_uefi)
     }
 
     pub fn fsync(&self) -> io::Result<()> {
-        self.0
+        self.datasync()
     }
 
     pub fn datasync(&self) -> io::Result<()> {
-        self.0
+        self.0.flush()
     }
 
     pub fn lock(&self) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn lock_shared(&self) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
     pub fn try_lock(&self) -> Result<(), TryLockError> {
-        self.0
+        unsupported().map_err(TryLockError::Error)
     }
 
     pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
-        self.0
+        unsupported().map_err(TryLockError::Error)
     }
 
     pub fn unlock(&self) -> io::Result<()> {
-        self.0
+        unsupported()
     }
 
-    pub fn truncate(&self, _size: u64) -> io::Result<()> {
-        self.0
+    pub fn truncate(&self, size: u64) -> io::Result<()> {
+        let mut file_info = self.0.file_info()?;
+
+        unsafe { (*file_info.as_mut_ptr()).file_size = size };
+
+        self.0.set_file_info(file_info)
     }
 
-    pub fn read(&self, _buf: &mut [u8]) -> io::Result<usize> {
-        self.0
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
     }
 
-    pub fn read_vectored(&self, _bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0
+    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        crate::io::default_read_vectored(|b| self.read(b), bufs)
     }
 
     pub fn is_read_vectored(&self) -> bool {
-        self.0
+        false
     }
 
-    pub fn read_buf(&self, _cursor: BorrowedCursor<'_>) -> io::Result<()> {
-        self.0
+    pub fn read_buf(&self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        crate::io::default_read_buf(|buf| self.read(buf), cursor)
     }
 
-    pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {
-        self.0
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
     }
 
-    pub fn write_vectored(&self, _bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.0
+    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        crate::io::default_write_vectored(|b| self.write(b), bufs)
     }
 
     pub fn is_write_vectored(&self) -> bool {
-        self.0
+        false
     }
 
+    // Write::flush is only meant for buffered writers. So should be noop for unbuffered files.
     pub fn flush(&self) -> io::Result<()> {
-        self.0
+        Ok(())
     }
 
-    pub fn seek(&self, _pos: SeekFrom) -> io::Result<u64> {
-        self.0
+    pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
+        const NEG_OFF_ERR: io::Error =
+            io::const_error!(io::ErrorKind::InvalidInput, "cannot seek to negative offset.");
+
+        let off = match pos {
+            SeekFrom::Start(p) => p,
+            SeekFrom::End(p) => {
+                // Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
+                if p == 0 {
+                    0xFFFFFFFFFFFFFFFF
+                } else {
+                    self.file_attr()?.size().checked_add_signed(p).ok_or(NEG_OFF_ERR)?
+                }
+            }
+            SeekFrom::Current(p) => self.tell()?.checked_add_signed(p).ok_or(NEG_OFF_ERR)?,
+        };
+
+        self.0.set_position(off).map(|_| off)
     }
 
     pub fn size(&self) -> Option<io::Result<u64>> {
-        self.0
+        match self.file_attr() {
+            Ok(x) => Some(Ok(x.size())),
+            Err(e) => Some(Err(e)),
+        }
     }
 
     pub fn tell(&self) -> io::Result<u64> {
-        self.0
+        self.0.position()
     }
 
     pub fn duplicate(&self) -> io::Result<File> {
-        self.0
+        unsupported()
     }
 
-    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
-        self.0
+    pub fn set_permissions(&self, perm: FilePermissions) -> io::Result<()> {
+        set_perm_inner(&self.0, perm)
     }
 
-    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
-        self.0
+    pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
+        set_times_inner(&self.0, times)
     }
 }
 
@@ -363,8 +408,10 @@ impl DirBuilder {
 }
 
 impl fmt::Debug for File {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut b = f.debug_struct("File");
+        b.field("path", &self.0.path());
+        b.finish()
     }
 }
 
@@ -393,20 +440,48 @@ pub fn unlink(p: &Path) -> io::Result<()> {
     }
 }
 
-pub fn rename(_old: &Path, _new: &Path) -> io::Result<()> {
-    unsupported()
+/// The implementation mirrors `mv` implementation in UEFI shell:
+/// https://github.com/tianocore/edk2/blob/66346d5edeac2a00d3cf2f2f3b5f66d423c07b3e/ShellPkg/Library/UefiShellLevel2CommandsLib/Mv.c#L455
+///
+/// In a nutshell we do the following:
+/// 1. Convert both old and new paths to absolute paths.
+/// 2. Check that both lie in the same disk.
+/// 3. Construct the target path relative to the current disk root.
+/// 4. Set this target path as the file_name in the file_info structure.
+pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
+    let old_absolute = crate::path::absolute(old)?;
+    let new_absolute = crate::path::absolute(new)?;
+
+    let mut old_components = old_absolute.components();
+    let mut new_components = new_absolute.components();
+
+    let Some(old_disk) = old_components.next() else {
+        return Err(io::const_error!(io::ErrorKind::InvalidInput, "Old path is not valid"));
+    };
+    let Some(new_disk) = new_components.next() else {
+        return Err(io::const_error!(io::ErrorKind::InvalidInput, "New path is not valid"));
+    };
+
+    // Ensure that paths are on the same device.
+    if old_disk != new_disk {
+        return Err(io::const_error!(io::ErrorKind::CrossesDevices, "Cannot rename across device"));
+    }
+
+    // Construct an path relative the current disk root.
+    let new_relative =
+        [crate::path::Component::RootDir].into_iter().chain(new_components).collect::<PathBuf>();
+
+    let f = uefi_fs::File::from_path(old, file::MODE_READ | file::MODE_WRITE, 0)?;
+    let file_info = f.file_info()?;
+
+    let new_info = file_info.with_file_name(new_relative.as_os_str())?;
+
+    f.set_file_info(new_info)
 }
 
 pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
     let f = uefi_fs::File::from_path(p, file::MODE_READ | file::MODE_WRITE, 0)?;
-    let mut file_info = f.file_info()?;
-
-    unsafe {
-        (*file_info.as_mut_ptr()).attribute =
-            ((*file_info.as_ptr()).attribute & !FILE_PERMISSIONS_MASK) | perm.to_attr()
-    };
-
-    f.set_file_info(file_info)
+    set_perm_inner(&f, perm)
 }
 
 pub fn set_times(p: &Path, times: FileTimes) -> io::Result<()> {
@@ -416,21 +491,7 @@ pub fn set_times(p: &Path, times: FileTimes) -> io::Result<()> {
 
 pub fn set_times_nofollow(p: &Path, times: FileTimes) -> io::Result<()> {
     let f = uefi_fs::File::from_path(p, file::MODE_READ | file::MODE_WRITE, 0)?;
-    let mut file_info = f.file_info()?;
-
-    if let Some(x) = times.accessed {
-        unsafe {
-            (*file_info.as_mut_ptr()).last_access_time = uefi_fs::systemtime_to_uefi(x);
-        }
-    }
-
-    if let Some(x) = times.modified {
-        unsafe {
-            (*file_info.as_mut_ptr()).modification_time = uefi_fs::systemtime_to_uefi(x);
-        }
-    }
-
-    f.set_file_info(file_info)
+    set_times_inner(&f, times)
 }
 
 pub fn rmdir(p: &Path) -> io::Result<()> {
@@ -445,10 +506,6 @@ pub fn rmdir(p: &Path) -> io::Result<()> {
     }
 }
 
-pub fn remove_dir_all(_path: &Path) -> io::Result<()> {
-    unsupported()
-}
-
 pub fn exists(path: &Path) -> io::Result<bool> {
     let f = uefi_fs::File::from_path(path, r_efi::protocols::file::MODE_READ, 0);
     match f {
@@ -488,6 +545,35 @@ pub fn copy(_from: &Path, _to: &Path) -> io::Result<u64> {
     unsupported()
 }
 
+fn set_perm_inner(f: &uefi_fs::File, perm: FilePermissions) -> io::Result<()> {
+    let mut file_info = f.file_info()?;
+
+    unsafe {
+        (*file_info.as_mut_ptr()).attribute =
+            ((*file_info.as_ptr()).attribute & !FILE_PERMISSIONS_MASK) | perm.to_attr()
+    };
+
+    f.set_file_info(file_info)
+}
+
+fn set_times_inner(f: &uefi_fs::File, times: FileTimes) -> io::Result<()> {
+    let mut file_info = f.file_info()?;
+
+    if let Some(x) = times.accessed {
+        unsafe {
+            (*file_info.as_mut_ptr()).last_access_time = uefi_fs::systemtime_to_uefi(x);
+        }
+    }
+
+    if let Some(x) = times.modified {
+        unsafe {
+            (*file_info.as_mut_ptr()).modification_time = uefi_fs::systemtime_to_uefi(x);
+        }
+    }
+
+    f.set_file_info(file_info)
+}
+
 mod uefi_fs {
     use r_efi::protocols::{device_path, file, simple_file_system};
 
@@ -497,7 +583,7 @@ mod uefi_fs {
     use crate::os::uefi::ffi::OsStringExt;
     use crate::path::Path;
     use crate::ptr::NonNull;
-    use crate::sys::helpers::{self, UefiBox};
+    use crate::sys::pal::helpers::{self, UefiBox};
     use crate::sys::time::{self, SystemTime};
 
     pub(crate) struct File {
@@ -597,6 +683,19 @@ mod uefi_fs {
             Ok(p)
         }
 
+        pub(crate) fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+            let file_ptr = self.protocol.as_ptr();
+            let mut buf_size = buf.len();
+
+            let r = unsafe { ((*file_ptr).read)(file_ptr, &mut buf_size, buf.as_mut_ptr().cast()) };
+
+            if buf_size == 0 && r.is_error() {
+                Err(io::Error::from_raw_os_error(r.as_usize()))
+            } else {
+                Ok(buf_size)
+            }
+        }
+
         pub(crate) fn read_dir_entry(&self) -> io::Result<Option<UefiBox<file::Info>>> {
             let file_ptr = self.protocol.as_ptr();
             let mut buf_size = 0;
@@ -623,6 +722,25 @@ mod uefi_fs {
             }
         }
 
+        pub(crate) fn write(&self, buf: &[u8]) -> io::Result<usize> {
+            let file_ptr = self.protocol.as_ptr();
+            let mut buf_size = buf.len();
+
+            let r = unsafe {
+                ((*file_ptr).write)(
+                    file_ptr,
+                    &mut buf_size,
+                    buf.as_ptr().cast::<crate::ffi::c_void>().cast_mut(),
+                )
+            };
+
+            if buf_size == 0 && r.is_error() {
+                Err(io::Error::from_raw_os_error(r.as_usize()))
+            } else {
+                Ok(buf_size)
+            }
+        }
+
         pub(crate) fn file_info(&self) -> io::Result<UefiBox<file::Info>> {
             let file_ptr = self.protocol.as_ptr();
             let mut info_id = file::INFO_ID;
@@ -665,6 +783,20 @@ mod uefi_fs {
             if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
         }
 
+        pub(crate) fn position(&self) -> io::Result<u64> {
+            let file_ptr = self.protocol.as_ptr();
+            let mut pos = 0;
+
+            let r = unsafe { ((*file_ptr).get_position)(file_ptr, &mut pos) };
+            if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(pos) }
+        }
+
+        pub(crate) fn set_position(&self, pos: u64) -> io::Result<()> {
+            let file_ptr = self.protocol.as_ptr();
+            let r = unsafe { ((*file_ptr).set_position)(file_ptr, pos) };
+            if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
+        }
+
         pub(crate) fn delete(self) -> io::Result<()> {
             let file_ptr = self.protocol.as_ptr();
             let r = unsafe { ((*file_ptr).delete)(file_ptr) };
@@ -675,6 +807,12 @@ mod uefi_fs {
             if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
         }
 
+        pub(crate) fn flush(&self) -> io::Result<()> {
+            let file_ptr = self.protocol.as_ptr();
+            let r = unsafe { ((*file_ptr).flush)(file_ptr) };
+            if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
+        }
+
         pub(crate) fn path(&self) -> &Path {
             &self.path
         }
@@ -759,12 +897,7 @@ mod uefi_fs {
     }
 
     pub(crate) fn file_name_from_uefi(info: &UefiBox<file::Info>) -> OsString {
-        let file_name = {
-            let size = unsafe { (*info.as_ptr()).size };
-            let strlen = (size as usize - crate::mem::size_of::<file::Info<0>>() - 1) / 2;
-            unsafe { crate::slice::from_raw_parts((*info.as_ptr()).file_name.as_ptr(), strlen) }
-        };
-
-        OsString::from_wide(file_name)
+        let fname = info.file_name();
+        OsString::from_wide(&fname[..fname.len() - 1])
     }
 }
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 7ac09cbea3da..bb2ee6ae10ed 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -89,9 +89,9 @@ use crate::os::unix::prelude::*;
 use crate::os::wasi::prelude::*;
 use crate::path::{Path, PathBuf};
 use crate::sync::Arc;
-use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::fd::FileDesc;
 pub use crate::sys::fs::common::exists;
+use crate::sys::helpers::run_path_with_cstr;
 use crate::sys::time::SystemTime;
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use crate::sys::weak::syscall;
@@ -257,7 +257,7 @@ cfg_has_statx! {{
 
 // all DirEntry's will have a reference to this struct
 struct InnerReadDir {
-    dirp: Dir,
+    dirp: DirStream,
     root: PathBuf,
 }
 
@@ -272,10 +272,134 @@ impl ReadDir {
     }
 }
 
-struct Dir(*mut libc::DIR);
+struct DirStream(*mut libc::DIR);
 
-unsafe impl Send for Dir {}
-unsafe impl Sync for Dir {}
+// dir::Dir requires openat support
+cfg_select! {
+    any(
+        target_os = "redox",
+        target_os = "espidf",
+        target_os = "horizon",
+        target_os = "vita",
+        target_os = "nto",
+        target_os = "vxworks",
+    ) => {
+        pub use crate::sys::fs::common::Dir;
+    }
+    _ => {
+        mod dir;
+        pub use dir::Dir;
+    }
+}
+
+fn debug_path_fd<'a, 'b>(
+    fd: c_int,
+    f: &'a mut fmt::Formatter<'b>,
+    name: &str,
+) -> fmt::DebugStruct<'a, 'b> {
+    let mut b = f.debug_struct(name);
+
+    fn get_mode(fd: c_int) -> Option<(bool, bool)> {
+        let mode = unsafe { libc::fcntl(fd, libc::F_GETFL) };
+        if mode == -1 {
+            return None;
+        }
+        match mode & libc::O_ACCMODE {
+            libc::O_RDONLY => Some((true, false)),
+            libc::O_RDWR => Some((true, true)),
+            libc::O_WRONLY => Some((false, true)),
+            _ => None,
+        }
+    }
+
+    b.field("fd", &fd);
+    if let Some(path) = get_path_from_fd(fd) {
+        b.field("path", &path);
+    }
+    if let Some((read, write)) = get_mode(fd) {
+        b.field("read", &read).field("write", &write);
+    }
+
+    b
+}
+
+fn get_path_from_fd(fd: c_int) -> Option<PathBuf> {
+    #[cfg(any(target_os = "linux", target_os = "illumos", target_os = "solaris"))]
+    fn get_path(fd: c_int) -> Option<PathBuf> {
+        let mut p = PathBuf::from("/proc/self/fd");
+        p.push(&fd.to_string());
+        run_path_with_cstr(&p, &readlink).ok()
+    }
+
+    #[cfg(any(target_vendor = "apple", target_os = "netbsd"))]
+    fn get_path(fd: c_int) -> Option<PathBuf> {
+        // FIXME: The use of PATH_MAX is generally not encouraged, but it
+        // is inevitable in this case because Apple targets and NetBSD define `fcntl`
+        // with `F_GETPATH` in terms of `MAXPATHLEN`, and there are no
+        // alternatives. If a better method is invented, it should be used
+        // instead.
+        let mut buf = vec![0; libc::PATH_MAX as usize];
+        let n = unsafe { libc::fcntl(fd, libc::F_GETPATH, buf.as_ptr()) };
+        if n == -1 {
+            cfg_select! {
+                target_os = "netbsd" => {
+                    // fallback to procfs as last resort
+                    let mut p = PathBuf::from("/proc/self/fd");
+                    p.push(&fd.to_string());
+                    return run_path_with_cstr(&p, &readlink).ok()
+                }
+                _ => {
+                    return None;
+                }
+            }
+        }
+        let l = buf.iter().position(|&c| c == 0).unwrap();
+        buf.truncate(l as usize);
+        buf.shrink_to_fit();
+        Some(PathBuf::from(OsString::from_vec(buf)))
+    }
+
+    #[cfg(target_os = "freebsd")]
+    fn get_path(fd: c_int) -> Option<PathBuf> {
+        let info = Box::<libc::kinfo_file>::new_zeroed();
+        let mut info = unsafe { info.assume_init() };
+        info.kf_structsize = size_of::<libc::kinfo_file>() as libc::c_int;
+        let n = unsafe { libc::fcntl(fd, libc::F_KINFO, &mut *info) };
+        if n == -1 {
+            return None;
+        }
+        let buf = unsafe { CStr::from_ptr(info.kf_path.as_mut_ptr()).to_bytes().to_vec() };
+        Some(PathBuf::from(OsString::from_vec(buf)))
+    }
+
+    #[cfg(target_os = "vxworks")]
+    fn get_path(fd: c_int) -> Option<PathBuf> {
+        let mut buf = vec![0; libc::PATH_MAX as usize];
+        let n = unsafe { libc::ioctl(fd, libc::FIOGETNAME, buf.as_ptr()) };
+        if n == -1 {
+            return None;
+        }
+        let l = buf.iter().position(|&c| c == 0).unwrap();
+        buf.truncate(l as usize);
+        Some(PathBuf::from(OsString::from_vec(buf)))
+    }
+
+    #[cfg(not(any(
+        target_os = "linux",
+        target_os = "vxworks",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "illumos",
+        target_os = "solaris",
+        target_vendor = "apple",
+    )))]
+    fn get_path(_fd: c_int) -> Option<PathBuf> {
+        // FIXME(#24570): implement this for other Unix platforms
+        None
+    }
+
+    get_path(fd)
+}
 
 #[cfg(any(
     target_os = "aix",
@@ -874,7 +998,7 @@ pub(crate) fn debug_assert_fd_is_open(fd: RawFd) {
     }
 }
 
-impl Drop for Dir {
+impl Drop for DirStream {
     fn drop(&mut self) {
         // dirfd isn't supported everywhere
         #[cfg(not(any(
@@ -902,6 +1026,11 @@ impl Drop for Dir {
     }
 }
 
+// SAFETY: `int dirfd (DIR *dirstream)` is MT-safe, implying that the pointer
+// may be safely sent among threads.
+unsafe impl Send for DirStream {}
+unsafe impl Sync for DirStream {}
+
 impl DirEntry {
     pub fn path(&self) -> PathBuf {
         self.dir.root.join(self.file_name_os_str())
@@ -1860,102 +1989,8 @@ impl FromRawFd for File {
 
 impl fmt::Debug for File {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        #[cfg(any(target_os = "linux", target_os = "illumos", target_os = "solaris"))]
-        fn get_path(fd: c_int) -> Option<PathBuf> {
-            let mut p = PathBuf::from("/proc/self/fd");
-            p.push(&fd.to_string());
-            run_path_with_cstr(&p, &readlink).ok()
-        }
-
-        #[cfg(any(target_vendor = "apple", target_os = "netbsd"))]
-        fn get_path(fd: c_int) -> Option<PathBuf> {
-            // FIXME: The use of PATH_MAX is generally not encouraged, but it
-            // is inevitable in this case because Apple targets and NetBSD define `fcntl`
-            // with `F_GETPATH` in terms of `MAXPATHLEN`, and there are no
-            // alternatives. If a better method is invented, it should be used
-            // instead.
-            let mut buf = vec![0; libc::PATH_MAX as usize];
-            let n = unsafe { libc::fcntl(fd, libc::F_GETPATH, buf.as_ptr()) };
-            if n == -1 {
-                cfg_select! {
-                    target_os = "netbsd" => {
-                        // fallback to procfs as last resort
-                        let mut p = PathBuf::from("/proc/self/fd");
-                        p.push(&fd.to_string());
-                        return run_path_with_cstr(&p, &readlink).ok()
-                    }
-                    _ => {
-                        return None;
-                    }
-                }
-            }
-            let l = buf.iter().position(|&c| c == 0).unwrap();
-            buf.truncate(l as usize);
-            buf.shrink_to_fit();
-            Some(PathBuf::from(OsString::from_vec(buf)))
-        }
-
-        #[cfg(target_os = "freebsd")]
-        fn get_path(fd: c_int) -> Option<PathBuf> {
-            let info = Box::<libc::kinfo_file>::new_zeroed();
-            let mut info = unsafe { info.assume_init() };
-            info.kf_structsize = size_of::<libc::kinfo_file>() as libc::c_int;
-            let n = unsafe { libc::fcntl(fd, libc::F_KINFO, &mut *info) };
-            if n == -1 {
-                return None;
-            }
-            let buf = unsafe { CStr::from_ptr(info.kf_path.as_mut_ptr()).to_bytes().to_vec() };
-            Some(PathBuf::from(OsString::from_vec(buf)))
-        }
-
-        #[cfg(target_os = "vxworks")]
-        fn get_path(fd: c_int) -> Option<PathBuf> {
-            let mut buf = vec![0; libc::PATH_MAX as usize];
-            let n = unsafe { libc::ioctl(fd, libc::FIOGETNAME, buf.as_ptr()) };
-            if n == -1 {
-                return None;
-            }
-            let l = buf.iter().position(|&c| c == 0).unwrap();
-            buf.truncate(l as usize);
-            Some(PathBuf::from(OsString::from_vec(buf)))
-        }
-
-        #[cfg(not(any(
-            target_os = "linux",
-            target_os = "vxworks",
-            target_os = "freebsd",
-            target_os = "netbsd",
-            target_os = "illumos",
-            target_os = "solaris",
-            target_vendor = "apple",
-        )))]
-        fn get_path(_fd: c_int) -> Option<PathBuf> {
-            // FIXME(#24570): implement this for other Unix platforms
-            None
-        }
-
-        fn get_mode(fd: c_int) -> Option<(bool, bool)> {
-            let mode = unsafe { libc::fcntl(fd, libc::F_GETFL) };
-            if mode == -1 {
-                return None;
-            }
-            match mode & libc::O_ACCMODE {
-                libc::O_RDONLY => Some((true, false)),
-                libc::O_RDWR => Some((true, true)),
-                libc::O_WRONLY => Some((false, true)),
-                _ => None,
-            }
-        }
-
         let fd = self.as_raw_fd();
-        let mut b = f.debug_struct("File");
-        b.field("fd", &fd);
-        if let Some(path) = get_path(fd) {
-            b.field("path", &path);
-        }
-        if let Some((read, write)) = get_mode(fd) {
-            b.field("read", &read).field("write", &write);
-        }
+        let mut b = debug_path_fd(fd, f, "File");
         b.finish()
     }
 }
@@ -2033,7 +2068,7 @@ pub fn readdir(path: &Path) -> io::Result<ReadDir> {
         Err(Error::last_os_error())
     } else {
         let root = path.to_path_buf();
-        let inner = InnerReadDir { dirp: Dir(ptr), root };
+        let inner = InnerReadDir { dirp: DirStream(ptr), root };
         Ok(ReadDir::new(inner))
     }
 }
@@ -2261,7 +2296,7 @@ fn open_to_and_set_permissions(
     _reader_metadata: &crate::fs::Metadata,
 ) -> io::Result<(crate::fs::File, crate::fs::Metadata)> {
     use crate::fs::OpenOptions;
-    let writer = OpenOptions::new().open(to)?;
+    let writer = OpenOptions::new().write(true).create(true).truncate(true).open(to)?;
     let writer_metadata = writer.metadata()?;
     Ok((writer, writer_metadata))
 }
@@ -2493,14 +2528,14 @@ mod remove_dir_impl {
     use libc::{fdopendir, openat64 as openat, unlinkat};
 
     use super::{
-        AsRawFd, Dir, DirEntry, FromRawFd, InnerReadDir, IntoRawFd, OwnedFd, RawFd, ReadDir, lstat,
+        AsRawFd, DirEntry, DirStream, FromRawFd, InnerReadDir, IntoRawFd, OwnedFd, RawFd, ReadDir,
+        lstat,
     };
     use crate::ffi::CStr;
     use crate::io;
     use crate::path::{Path, PathBuf};
-    use crate::sys::common::small_c_string::run_path_with_cstr;
+    use crate::sys::helpers::{ignore_notfound, run_path_with_cstr};
     use crate::sys::{cvt, cvt_r};
-    use crate::sys_common::ignore_notfound;
 
     pub fn openat_nofollow_dironly(parent_fd: Option<RawFd>, p: &CStr) -> io::Result<OwnedFd> {
         let fd = cvt_r(|| unsafe {
@@ -2518,7 +2553,7 @@ mod remove_dir_impl {
         if ptr.is_null() {
             return Err(io::Error::last_os_error());
         }
-        let dirp = Dir(ptr);
+        let dirp = DirStream(ptr);
         // file descriptor is automatically closed by libc::closedir() now, so give up ownership
         let new_parent_fd = dir_fd.into_raw_fd();
         // a valid root is not needed because we do not call any functions involving the full path
diff --git a/library/std/src/sys/fs/unix/dir.rs b/library/std/src/sys/fs/unix/dir.rs
new file mode 100644
index 000000000000..094d1bfd3168
--- /dev/null
+++ b/library/std/src/sys/fs/unix/dir.rs
@@ -0,0 +1,114 @@
+use libc::c_int;
+
+cfg_select! {
+    not(
+        any(
+            all(target_os = "linux", not(target_env = "musl")),
+            target_os = "l4re",
+            target_os = "android",
+            target_os = "hurd",
+        )
+    ) => {
+        use libc::{open as open64, openat as openat64};
+    }
+    _ => {
+        use libc::{open64, openat64};
+    }
+}
+
+use crate::ffi::CStr;
+use crate::os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd};
+#[cfg(target_family = "unix")]
+use crate::os::unix::io::{AsRawFd, FromRawFd};
+#[cfg(target_os = "wasi")]
+use crate::os::wasi::io::{AsRawFd, FromRawFd};
+use crate::path::Path;
+use crate::sys::fd::FileDesc;
+use crate::sys::fs::OpenOptions;
+use crate::sys::fs::unix::{File, debug_path_fd};
+use crate::sys::helpers::run_path_with_cstr;
+use crate::sys::{AsInner, FromInner, IntoInner, cvt_r};
+use crate::{fmt, fs, io};
+
+pub struct Dir(OwnedFd);
+
+impl Dir {
+    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<Self> {
+        run_path_with_cstr(path, &|path| Self::open_with_c(path, opts))
+    }
+
+    pub fn open_file(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        run_path_with_cstr(path.as_ref(), &|path| self.open_file_c(path, &opts))
+    }
+
+    pub fn open_with_c(path: &CStr, opts: &OpenOptions) -> io::Result<Self> {
+        let flags = libc::O_CLOEXEC
+            | libc::O_DIRECTORY
+            | opts.get_access_mode()?
+            | opts.get_creation_mode()?
+            | (opts.custom_flags as c_int & !libc::O_ACCMODE);
+        let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode as c_int) })?;
+        Ok(Self(unsafe { OwnedFd::from_raw_fd(fd) }))
+    }
+
+    fn open_file_c(&self, path: &CStr, opts: &OpenOptions) -> io::Result<File> {
+        let flags = libc::O_CLOEXEC
+            | opts.get_access_mode()?
+            | opts.get_creation_mode()?
+            | (opts.custom_flags as c_int & !libc::O_ACCMODE);
+        let fd = cvt_r(|| unsafe {
+            openat64(self.0.as_raw_fd(), path.as_ptr(), flags, opts.mode as c_int)
+        })?;
+        Ok(File(unsafe { FileDesc::from_raw_fd(fd) }))
+    }
+}
+
+impl fmt::Debug for Dir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let fd = self.0.as_raw_fd();
+        let mut b = debug_path_fd(fd, f, "Dir");
+        b.finish()
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl AsRawFd for fs::Dir {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().0.as_raw_fd()
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl IntoRawFd for fs::Dir {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().0.into_raw_fd()
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl FromRawFd for fs::Dir {
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        Self::from_inner(Dir(unsafe { FromRawFd::from_raw_fd(fd) }))
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl AsFd for fs::Dir {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.as_inner().0.as_fd()
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl From<fs::Dir> for OwnedFd {
+    fn from(value: fs::Dir) -> Self {
+        value.into_inner().0
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl From<OwnedFd> for fs::Dir {
+    fn from(value: OwnedFd) -> Self {
+        Self::from_inner(Dir(value))
+    }
+}
diff --git a/library/std/src/sys/fs/unsupported.rs b/library/std/src/sys/fs/unsupported.rs
index f222151d18e2..069b4fb8a29c 100644
--- a/library/std/src/sys/fs/unsupported.rs
+++ b/library/std/src/sys/fs/unsupported.rs
@@ -4,6 +4,7 @@ use crate::fs::TryLockError;
 use crate::hash::{Hash, Hasher};
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::path::{Path, PathBuf};
+pub use crate::sys::fs::common::Dir;
 use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 
diff --git a/library/std/src/sys/fs/vexos.rs b/library/std/src/sys/fs/vexos.rs
index 381c87c62c68..81083a4fa81d 100644
--- a/library/std/src/sys/fs/vexos.rs
+++ b/library/std/src/sys/fs/vexos.rs
@@ -4,7 +4,7 @@ use crate::fs::TryLockError;
 use crate::hash::Hash;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::path::{Path, PathBuf};
-use crate::sys::common::small_c_string::run_path_with_cstr;
+use crate::sys::helpers::run_path_with_cstr;
 use crate::sys::time::SystemTime;
 use crate::sys::{unsupported, unsupported_err};
 
diff --git a/library/std/src/sys/fs/windows.rs b/library/std/src/sys/fs/windows.rs
index b588b91c753b..2e3d50aa0e08 100644
--- a/library/std/src/sys/fs/windows.rs
+++ b/library/std/src/sys/fs/windows.rs
@@ -18,6 +18,8 @@ use crate::sys::time::SystemTime;
 use crate::sys::{Align8, AsInner, FromInner, IntoInner, c, cvt};
 use crate::{fmt, ptr, slice};
 
+mod dir;
+pub use dir::Dir;
 mod remove_dir_all;
 use remove_dir_all::remove_dir_all_iterative;
 
@@ -274,7 +276,7 @@ impl OpenOptions {
         }
     }
 
-    fn get_creation_mode(&self) -> io::Result<u32> {
+    fn get_cmode_disposition(&self) -> io::Result<(u32, u32)> {
         match (self.write, self.append) {
             (true, false) => {}
             (false, false) => {
@@ -296,16 +298,24 @@ impl OpenOptions {
         }
 
         Ok(match (self.create, self.truncate, self.create_new) {
-            (false, false, false) => c::OPEN_EXISTING,
-            (true, false, false) => c::OPEN_ALWAYS,
-            (false, true, false) => c::TRUNCATE_EXISTING,
+            (false, false, false) => (c::OPEN_EXISTING, c::FILE_OPEN),
+            (true, false, false) => (c::OPEN_ALWAYS, c::FILE_OPEN_IF),
+            (false, true, false) => (c::TRUNCATE_EXISTING, c::FILE_OVERWRITE),
             // `CREATE_ALWAYS` has weird semantics so we emulate it using
             // `OPEN_ALWAYS` and a manual truncation step. See #115745.
-            (true, true, false) => c::OPEN_ALWAYS,
-            (_, _, true) => c::CREATE_NEW,
+            (true, true, false) => (c::OPEN_ALWAYS, c::FILE_OVERWRITE_IF),
+            (_, _, true) => (c::CREATE_NEW, c::FILE_CREATE),
         })
     }
 
+    fn get_creation_mode(&self) -> io::Result<u32> {
+        self.get_cmode_disposition().map(|(mode, _)| mode)
+    }
+
+    fn get_disposition(&self) -> io::Result<u32> {
+        self.get_cmode_disposition().map(|(_, mode)| mode)
+    }
+
     fn get_flags_and_attributes(&self) -> u32 {
         self.custom_flags
             | self.attributes
@@ -1019,14 +1029,23 @@ impl FromRawHandle for File {
     }
 }
 
+fn debug_path_handle<'a, 'b>(
+    handle: BorrowedHandle<'a>,
+    f: &'a mut fmt::Formatter<'b>,
+    name: &str,
+) -> fmt::DebugStruct<'a, 'b> {
+    // FIXME(#24570): add more info here (e.g., mode)
+    let mut b = f.debug_struct(name);
+    b.field("handle", &handle.as_raw_handle());
+    if let Ok(path) = get_path(handle) {
+        b.field("path", &path);
+    }
+    b
+}
+
 impl fmt::Debug for File {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // FIXME(#24570): add more info here (e.g., mode)
-        let mut b = f.debug_struct("File");
-        b.field("handle", &self.handle.as_raw_handle());
-        if let Ok(path) = get_path(self) {
-            b.field("path", &path);
-        }
+        let mut b = debug_path_handle(self.handle.as_handle(), f, "File");
         b.finish()
     }
 }
@@ -1292,8 +1311,8 @@ pub fn rename(old: &WCStr, new: &WCStr) -> io::Result<()> {
                 Layout::from_size_align(struct_size as usize, align_of::<c::FILE_RENAME_INFO>())
                     .unwrap();
 
-            // SAFETY: We allocate enough memory for a full FILE_RENAME_INFO struct and a filename.
             let file_rename_info;
+            // SAFETY: We allocate enough memory for a full FILE_RENAME_INFO struct and a filename.
             unsafe {
                 file_rename_info = alloc(layout).cast::<c::FILE_RENAME_INFO>();
                 if file_rename_info.is_null() {
@@ -1530,10 +1549,10 @@ pub fn set_times_nofollow(p: &WCStr, times: FileTimes) -> io::Result<()> {
     file.set_times(times)
 }
 
-fn get_path(f: &File) -> io::Result<PathBuf> {
+fn get_path(f: impl AsRawHandle) -> io::Result<PathBuf> {
     fill_utf16_buf(
         |buf, sz| unsafe {
-            c::GetFinalPathNameByHandleW(f.handle.as_raw_handle(), buf, sz, c::VOLUME_NAME_DOS)
+            c::GetFinalPathNameByHandleW(f.as_raw_handle(), buf, sz, c::VOLUME_NAME_DOS)
         },
         |buf| PathBuf::from(OsString::from_wide(buf)),
     )
@@ -1546,7 +1565,7 @@ pub fn canonicalize(p: &WCStr) -> io::Result<PathBuf> {
     // This flag is so we can open directories too
     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS);
     let f = File::open_native(p, &opts)?;
-    get_path(&f)
+    get_path(f.handle)
 }
 
 pub fn copy(from: &WCStr, to: &WCStr) -> io::Result<u64> {
diff --git a/library/std/src/sys/fs/windows/dir.rs b/library/std/src/sys/fs/windows/dir.rs
new file mode 100644
index 000000000000..3f617806c6c3
--- /dev/null
+++ b/library/std/src/sys/fs/windows/dir.rs
@@ -0,0 +1,153 @@
+use crate::os::windows::io::{
+    AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, HandleOrInvalid, IntoRawHandle,
+    OwnedHandle, RawHandle,
+};
+use crate::path::Path;
+use crate::sys::api::{UnicodeStrRef, WinError};
+use crate::sys::fs::windows::debug_path_handle;
+use crate::sys::fs::{File, OpenOptions};
+use crate::sys::handle::Handle;
+use crate::sys::path::{WCStr, with_native_path};
+use crate::sys::{AsInner, FromInner, IntoInner, IoResult, c, to_u16s};
+use crate::{fmt, fs, io, ptr};
+
+pub struct Dir {
+    handle: Handle,
+}
+
+/// A wrapper around a raw NtCreateFile call.
+///
+/// This isn't completely safe because `OBJECT_ATTRIBUTES` contains raw pointers.
+unsafe fn nt_create_file(
+    opts: &OpenOptions,
+    object_attributes: &c::OBJECT_ATTRIBUTES,
+    create_options: c::NTCREATEFILE_CREATE_OPTIONS,
+) -> io::Result<Handle> {
+    let mut handle = ptr::null_mut();
+    let mut io_status = c::IO_STATUS_BLOCK::PENDING;
+    // SYNCHRONIZE is included in FILE_GENERIC_READ, but not GENERIC_READ, so we add it manually
+    let access = opts.get_access_mode()? | c::SYNCHRONIZE;
+    // one of FILE_SYNCHRONOUS_IO_{,NON}ALERT is required for later operations to succeed.
+    let options = create_options | c::FILE_SYNCHRONOUS_IO_NONALERT;
+    let status = unsafe {
+        c::NtCreateFile(
+            &mut handle,
+            access,
+            object_attributes,
+            &mut io_status,
+            ptr::null(),
+            c::FILE_ATTRIBUTE_NORMAL,
+            opts.share_mode,
+            opts.get_disposition()?,
+            options,
+            ptr::null(),
+            0,
+        )
+    };
+    if c::nt_success(status) {
+        // SAFETY: nt_success guarantees that handle is no longer null
+        unsafe { Ok(Handle::from_raw_handle(handle)) }
+    } else {
+        Err(WinError::new(unsafe { c::RtlNtStatusToDosError(status) })).io_result()
+    }
+}
+
+impl Dir {
+    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<Self> {
+        with_native_path(path, &|path| Self::open_with_native(path, opts))
+    }
+
+    pub fn open_file(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        // NtCreateFile will fail if given an absolute path and a non-null RootDirectory
+        if path.is_absolute() {
+            return File::open(path, opts);
+        }
+        let path = to_u16s(path)?;
+        let path = &path[..path.len() - 1]; // trim 0 byte
+        self.open_file_native(&path, opts).map(|handle| File { handle })
+    }
+
+    fn open_with_native(path: &WCStr, opts: &OpenOptions) -> io::Result<Self> {
+        let creation = opts.get_creation_mode()?;
+        let sa = c::SECURITY_ATTRIBUTES {
+            nLength: size_of::<c::SECURITY_ATTRIBUTES>() as u32,
+            lpSecurityDescriptor: ptr::null_mut(),
+            bInheritHandle: opts.inherit_handle as c::BOOL,
+        };
+        let handle = unsafe {
+            c::CreateFileW(
+                path.as_ptr(),
+                opts.get_access_mode()?,
+                opts.share_mode,
+                &raw const sa,
+                creation,
+                // FILE_FLAG_BACKUP_SEMANTICS is required to open a directory
+                opts.get_flags_and_attributes() | c::FILE_FLAG_BACKUP_SEMANTICS,
+                ptr::null_mut(),
+            )
+        };
+        match OwnedHandle::try_from(unsafe { HandleOrInvalid::from_raw_handle(handle) }) {
+            Ok(handle) => Ok(Self { handle: Handle::from_inner(handle) }),
+            Err(_) => Err(io::Error::last_os_error()),
+        }
+    }
+
+    fn open_file_native(&self, path: &[u16], opts: &OpenOptions) -> io::Result<Handle> {
+        let name = UnicodeStrRef::from_slice(path);
+        let object_attributes = c::OBJECT_ATTRIBUTES {
+            RootDirectory: self.handle.as_raw_handle(),
+            ObjectName: name.as_ptr(),
+            ..c::OBJECT_ATTRIBUTES::with_length()
+        };
+        unsafe { nt_create_file(opts, &object_attributes, c::FILE_NON_DIRECTORY_FILE) }
+    }
+}
+
+impl fmt::Debug for Dir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut b = debug_path_handle(self.handle.as_handle(), f, "Dir");
+        b.finish()
+    }
+}
+
+#[unstable(feature = "dirfd", issue = "120426")]
+impl AsRawHandle for fs::Dir {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.as_inner().handle.as_raw_handle()
+    }
+}
+
+#[unstable(feature = "dirhandle", issue = "120426")]
+impl IntoRawHandle for fs::Dir {
+    fn into_raw_handle(self) -> RawHandle {
+        self.into_inner().handle.into_raw_handle()
+    }
+}
+
+#[unstable(feature = "dirhandle", issue = "120426")]
+impl FromRawHandle for fs::Dir {
+    unsafe fn from_raw_handle(handle: RawHandle) -> Self {
+        Self::from_inner(Dir { handle: unsafe { FromRawHandle::from_raw_handle(handle) } })
+    }
+}
+
+#[unstable(feature = "dirhandle", issue = "120426")]
+impl AsHandle for fs::Dir {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        self.as_inner().handle.as_handle()
+    }
+}
+
+#[unstable(feature = "dirhandle", issue = "120426")]
+impl From<fs::Dir> for OwnedHandle {
+    fn from(value: fs::Dir) -> Self {
+        value.into_inner().handle.into_inner()
+    }
+}
+
+#[unstable(feature = "dirhandle", issue = "120426")]
+impl From<OwnedHandle> for fs::Dir {
+    fn from(value: OwnedHandle) -> Self {
+        Self::from_inner(Dir { handle: Handle::from_inner(value) })
+    }
+}
diff --git a/library/std/src/sys/helpers/mod.rs b/library/std/src/sys/helpers/mod.rs
new file mode 100644
index 000000000000..a6236799caea
--- /dev/null
+++ b/library/std/src/sys/helpers/mod.rs
@@ -0,0 +1,39 @@
+//! Small helper functions used inside `sys`.
+//!
+//! If any of these have uses outside of `sys`, please move them to a different
+//! module.
+
+#[cfg_attr(not(target_os = "linux"), allow(unused))] // Not used on all platforms.
+mod small_c_string;
+#[cfg_attr(not(target_os = "windows"), allow(unused))] // Not used on all platforms.
+mod wstr;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg_attr(not(target_os = "linux"), allow(unused))] // Not used on all platforms.
+pub use small_c_string::{run_path_with_cstr, run_with_cstr};
+#[cfg_attr(not(target_os = "windows"), allow(unused))] // Not used on all platforms.
+pub use wstr::WStrUnits;
+
+/// Computes `(value*numerator)/denom` without overflow, as long as both
+/// `numerator*denom` and the overall result fit into `u64` (which is the case
+/// for our time conversions).
+#[cfg_attr(not(target_os = "windows"), allow(unused))] // Not used on all platforms.
+pub fn mul_div_u64(value: u64, numerator: u64, denom: u64) -> u64 {
+    let q = value / denom;
+    let r = value % denom;
+    // Decompose value as (value/denom*denom + value%denom),
+    // substitute into (value*numerator)/denom and simplify.
+    // r < denom, so (denom*numerator) is the upper bound of (r*numerator)
+    q * numerator + r * numerator / denom
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(unused))] // Not used on all platforms.
+pub fn ignore_notfound<T>(result: crate::io::Result<T>) -> crate::io::Result<()> {
+    match result {
+        Err(err) if err.kind() == crate::io::ErrorKind::NotFound => Ok(()),
+        Ok(_) => Ok(()),
+        Err(err) => Err(err),
+    }
+}
diff --git a/library/std/src/sys/pal/common/small_c_string.rs b/library/std/src/sys/helpers/small_c_string.rs
similarity index 100%
rename from library/std/src/sys/pal/common/small_c_string.rs
rename to library/std/src/sys/helpers/small_c_string.rs
diff --git a/library/std/src/sys/pal/common/tests.rs b/library/std/src/sys/helpers/tests.rs
similarity index 89%
rename from library/std/src/sys/pal/common/tests.rs
rename to library/std/src/sys/helpers/tests.rs
index b7698907070c..b67fdb9408d6 100644
--- a/library/std/src/sys/pal/common/tests.rs
+++ b/library/std/src/sys/helpers/tests.rs
@@ -1,9 +1,10 @@
 use core::iter::repeat;
 
+use super::mul_div_u64;
+use super::small_c_string::run_path_with_cstr;
 use crate::ffi::CString;
 use crate::hint::black_box;
 use crate::path::Path;
-use crate::sys::common::small_c_string::run_path_with_cstr;
 
 #[test]
 fn stack_allocation_works() {
@@ -65,3 +66,8 @@ fn bench_heap_path_alloc(b: &mut test::Bencher) {
         .unwrap();
     });
 }
+
+#[test]
+fn test_muldiv() {
+    assert_eq!(mul_div_u64(1_000_000_000_001, 1_000_000_000, 1_000_000), 1_000_000_000_001_000);
+}
diff --git a/library/std/src/sys_common/wstr.rs b/library/std/src/sys/helpers/wstr.rs
similarity index 98%
rename from library/std/src/sys_common/wstr.rs
rename to library/std/src/sys/helpers/wstr.rs
index f9a171fb7d8f..9c4b8e09e463 100644
--- a/library/std/src/sys_common/wstr.rs
+++ b/library/std/src/sys/helpers/wstr.rs
@@ -1,5 +1,4 @@
 //! This module contains constructs to work with 16-bit characters (UCS-2 or UTF-16)
-#![allow(dead_code)]
 
 use crate::marker::PhantomData;
 use crate::num::NonZero;
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index 0c72f6a57fe8..c9035938cfdd 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -1,16 +1,9 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
-/// The configure builtins provides runtime support compiler-builtin features
-/// which require dynamic initialization to work as expected, e.g. aarch64
-/// outline-atomics.
-mod configure_builtins;
-
-/// The PAL (platform abstraction layer) contains platform-specific abstractions
-/// for implementing the features in the other submodules, e.g. UNIX file
-/// descriptors.
-mod pal;
-
 mod alloc;
+mod configure_builtins;
+mod helpers;
+mod pal;
 mod personality;
 
 pub mod args;
diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs
index c32f8dcc8de8..d57a075eb42d 100644
--- a/library/std/src/sys/net/connection/socket/hermit.rs
+++ b/library/std/src/sys/net/connection/socket/hermit.rs
@@ -300,7 +300,6 @@ impl Socket {
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
-    // This is used by sys_common code to abstract over Windows and Unix.
     pub fn as_raw(&self) -> RawFd {
         self.0.as_raw_fd()
     }
diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index c6df9c6b8ae1..256b99dfa987 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -7,7 +7,7 @@ use crate::mem::MaybeUninit;
 use crate::net::{
     Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs,
 };
-use crate::sys::common::small_c_string::run_with_cstr;
+use crate::sys::helpers::run_with_cstr;
 use crate::sys::net::connection::each_addr;
 use crate::sys::{AsInner, FromInner};
 use crate::time::Duration;
diff --git a/library/std/src/sys/net/connection/socket/solid.rs b/library/std/src/sys/net/connection/socket/solid.rs
index 673d75046d3f..e20a3fbb76b7 100644
--- a/library/std/src/sys/net/connection/socket/solid.rs
+++ b/library/std/src/sys/net/connection/socket/solid.rs
@@ -353,7 +353,6 @@ impl Socket {
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
-    // This method is used by sys_common code to abstract over targets.
     pub fn as_raw(&self) -> c_int {
         self.as_raw_fd()
     }
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index 6d06a8d86bf1..d09ba97cfe01 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -614,7 +614,6 @@ impl Socket {
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
-    // This is used by sys_common code to abstract over Windows and Unix.
     pub fn as_raw(&self) -> RawFd {
         self.as_raw_fd()
     }
diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index 7355f0ce6bf5..3f99249efc47 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -439,7 +439,6 @@ impl Socket {
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
-    // This is used by sys_common code to abstract over Windows and Unix.
     pub fn as_raw(&self) -> c::SOCKET {
         debug_assert_eq!(size_of::<c::SOCKET>(), size_of::<RawSocket>());
         debug_assert_eq!(align_of::<c::SOCKET>(), align_of::<RawSocket>());
diff --git a/library/std/src/sys/net/connection/uefi/mod.rs b/library/std/src/sys/net/connection/uefi/mod.rs
index db2d18646d02..107a3e23733d 100644
--- a/library/std/src/sys/net/connection/uefi/mod.rs
+++ b/library/std/src/sys/net/connection/uefi/mod.rs
@@ -16,26 +16,26 @@ pub struct TcpStream {
 }
 
 impl TcpStream {
+    fn new(inner: tcp::Tcp) -> Self {
+        Self {
+            inner,
+            read_timeout: Arc::new(Mutex::new(None)),
+            write_timeout: Arc::new(Mutex::new(None)),
+        }
+    }
+
     pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
         return each_addr(addr, inner);
 
         fn inner(addr: &SocketAddr) -> io::Result<TcpStream> {
             let inner = tcp::Tcp::connect(addr, None)?;
-            Ok(TcpStream {
-                inner,
-                read_timeout: Arc::new(Mutex::new(None)),
-                write_timeout: Arc::new(Mutex::new(None)),
-            })
+            Ok(TcpStream::new(inner))
         }
     }
 
     pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
         let inner = tcp::Tcp::connect(addr, Some(timeout))?;
-        Ok(Self {
-            inner,
-            read_timeout: Arc::new(Mutex::new(None)),
-            write_timeout: Arc::new(Mutex::new(None)),
-        })
+        Ok(Self::new(inner))
     }
 
     pub fn set_read_timeout(&self, t: Option<Duration>) -> io::Result<()> {
@@ -148,16 +148,23 @@ pub struct TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<TcpListener> {
-        unsupported()
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
+        return each_addr(addr, inner);
+
+        fn inner(addr: &SocketAddr) -> io::Result<TcpListener> {
+            let inner = tcp::Tcp::bind(addr)?;
+            Ok(TcpListener { inner })
+        }
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        unsupported()
+        self.inner.socket_addr()
     }
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
-        unsupported()
+        let tcp = self.inner.accept()?;
+        let addr = tcp.peer_addr()?;
+        Ok((TcpStream::new(tcp), addr))
     }
 
     pub fn duplicate(&self) -> io::Result<TcpListener> {
diff --git a/library/std/src/sys/net/connection/uefi/tcp.rs b/library/std/src/sys/net/connection/uefi/tcp.rs
index 1e7e829c85f3..3e79aa049187 100644
--- a/library/std/src/sys/net/connection/uefi/tcp.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp.rs
@@ -2,7 +2,7 @@ use super::tcp4;
 use crate::io::{self, IoSlice, IoSliceMut};
 use crate::net::SocketAddr;
 use crate::ptr::NonNull;
-use crate::sys::{helpers, unsupported};
+use crate::sys::pal::{helpers, unsupported};
 use crate::time::Duration;
 
 pub(crate) enum Tcp {
@@ -18,7 +18,24 @@ impl Tcp {
                 temp.connect(timeout)?;
                 Ok(Tcp::V4(temp))
             }
-            SocketAddr::V6(_) => todo!(),
+            SocketAddr::V6(_) => unsupported(),
+        }
+    }
+
+    pub(crate) fn bind(addr: &SocketAddr) -> io::Result<Self> {
+        match addr {
+            SocketAddr::V4(x) => {
+                let temp = tcp4::Tcp4::new()?;
+                temp.configure(false, None, Some(x))?;
+                Ok(Tcp::V4(temp))
+            }
+            SocketAddr::V6(_) => unsupported(),
+        }
+    }
+
+    pub(crate) fn accept(&self) -> io::Result<Self> {
+        match self {
+            Self::V4(client) => client.accept().map(Tcp::V4),
         }
     }
 
diff --git a/library/std/src/sys/net/connection/uefi/tcp4.rs b/library/std/src/sys/net/connection/uefi/tcp4.rs
index 0409997f0272..00c93384e5f6 100644
--- a/library/std/src/sys/net/connection/uefi/tcp4.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp4.rs
@@ -3,7 +3,7 @@ use r_efi::protocols::tcp4;
 
 use crate::io::{self, IoSlice, IoSliceMut};
 use crate::net::SocketAddrV4;
-use crate::ptr::NonNull;
+use crate::ptr::{self, NonNull};
 use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::sys::pal::helpers;
 use crate::time::{Duration, Instant};
@@ -12,9 +12,9 @@ const TYPE_OF_SERVICE: u8 = 8;
 const TIME_TO_LIVE: u8 = 255;
 
 pub(crate) struct Tcp4 {
+    handle: NonNull<crate::ffi::c_void>,
     protocol: NonNull<tcp4::Protocol>,
     flag: AtomicBool,
-    #[expect(dead_code)]
     service_binding: helpers::ServiceProtocol,
 }
 
@@ -22,10 +22,11 @@ const DEFAULT_ADDR: efi::Ipv4Address = efi::Ipv4Address { addr: [0u8; 4] };
 
 impl Tcp4 {
     pub(crate) fn new() -> io::Result<Self> {
-        let service_binding = helpers::ServiceProtocol::open(tcp4::SERVICE_BINDING_PROTOCOL_GUID)?;
-        let protocol = helpers::open_protocol(service_binding.child_handle(), tcp4::PROTOCOL_GUID)?;
+        let (service_binding, handle) =
+            helpers::ServiceProtocol::open(tcp4::SERVICE_BINDING_PROTOCOL_GUID)?;
+        let protocol = helpers::open_protocol(handle, tcp4::PROTOCOL_GUID)?;
 
-        Ok(Self { service_binding, protocol, flag: AtomicBool::new(false) })
+        Ok(Self { service_binding, handle, protocol, flag: AtomicBool::new(false) })
     }
 
     pub(crate) fn configure(
@@ -42,11 +43,14 @@ impl Tcp4 {
             (DEFAULT_ADDR, 0)
         };
 
-        // FIXME: Remove when passive connections with proper subnet handling are added
-        assert!(station_address.is_none());
-        let use_default_address = efi::Boolean::TRUE;
-        let (station_address, station_port) = (DEFAULT_ADDR, 0);
-        let subnet_mask = helpers::ipv4_to_r_efi(crate::net::Ipv4Addr::new(0, 0, 0, 0));
+        let use_default_address: r_efi::efi::Boolean =
+            station_address.is_none_or(|addr| addr.ip().is_unspecified()).into();
+        let (station_address, station_port) = if let Some(x) = station_address {
+            (helpers::ipv4_to_r_efi(*x.ip()), x.port())
+        } else {
+            (DEFAULT_ADDR, 0)
+        };
+        let subnet_mask = helpers::ipv4_to_r_efi(crate::net::Ipv4Addr::new(255, 255, 255, 0));
 
         let mut config_data = tcp4::ConfigData {
             type_of_service: TYPE_OF_SERVICE,
@@ -60,7 +64,7 @@ impl Tcp4 {
                 station_port,
                 subnet_mask,
             },
-            control_option: crate::ptr::null_mut(),
+            control_option: ptr::null_mut(),
         };
 
         let r = unsafe { ((*protocol).configure)(protocol, &mut config_data) };
@@ -74,17 +78,55 @@ impl Tcp4 {
         let r = unsafe {
             ((*protocol).get_mode_data)(
                 protocol,
-                crate::ptr::null_mut(),
+                ptr::null_mut(),
                 &mut config_data,
-                crate::ptr::null_mut(),
-                crate::ptr::null_mut(),
-                crate::ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
             )
         };
 
         if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(config_data) }
     }
 
+    pub(crate) fn accept(&self) -> io::Result<Self> {
+        let evt = unsafe { self.create_evt() }?;
+        let completion_token =
+            tcp4::CompletionToken { event: evt.as_ptr(), status: Status::SUCCESS };
+        let mut listen_token =
+            tcp4::ListenToken { completion_token, new_child_handle: ptr::null_mut() };
+
+        let protocol = self.protocol.as_ptr();
+        let r = unsafe { ((*protocol).accept)(protocol, &mut listen_token) };
+        if r.is_error() {
+            return Err(io::Error::from_raw_os_error(r.as_usize()));
+        }
+
+        unsafe { self.wait_or_cancel(None, &mut listen_token.completion_token) }?;
+
+        if completion_token.status.is_error() {
+            Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
+        } else {
+            // EDK2 internals seem to assume a single ServiceBinding Protocol for TCP4 and TCP6, and
+            // thus does not use any service binding protocol data in destroying child sockets. It
+            // does seem to suggest that we need to cleanup even the protocols created by accept. To
+            // be on the safe side with other implementations, we will be using the same service
+            // binding protocol as the parent TCP4 handle.
+            //
+            // https://github.com/tianocore/edk2/blob/f80580f56b267c96f16f985dbf707b2f96947da4/NetworkPkg/TcpDxe/TcpDriver.c#L938
+
+            let handle = NonNull::new(listen_token.new_child_handle).unwrap();
+            let protocol = helpers::open_protocol(handle, tcp4::PROTOCOL_GUID)?;
+
+            Ok(Self {
+                handle,
+                service_binding: self.service_binding,
+                protocol,
+                flag: AtomicBool::new(false),
+            })
+        }
+    }
+
     pub(crate) fn connect(&self, timeout: Option<Duration>) -> io::Result<()> {
         let evt = unsafe { self.create_evt() }?;
         let completion_token =
@@ -352,6 +394,12 @@ impl Tcp4 {
     }
 }
 
+impl Drop for Tcp4 {
+    fn drop(&mut self) {
+        let _ = unsafe { self.service_binding.destroy_child(self.handle) };
+    }
+}
+
 extern "efiapi" fn toggle_atomic_flag(_: r_efi::efi::Event, ctx: *mut crate::ffi::c_void) {
     let flag = unsafe { AtomicBool::from_ptr(ctx.cast()) };
     flag.store(true, Ordering::Relaxed);
diff --git a/library/std/src/sys/pal/common/mod.rs b/library/std/src/sys/pal/common/mod.rs
deleted file mode 100644
index 9af4dee401cf..000000000000
--- a/library/std/src/sys/pal/common/mod.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// This module contains code that is shared between all platforms, mostly utility or fallback code.
-// This explicitly does not include code that is shared between only a few platforms,
-// such as when reusing an implementation from `unix` or `unsupported`.
-// In those cases the desired code should be included directly using the #[path] attribute,
-// not moved to this module.
-//
-// Currently `sys_common` contains a lot of code that should live in this module,
-// ideally `sys_common` would only contain platform-independent abstractions on top of `sys`.
-// Progress on this is tracked in #84187.
-
-#![allow(dead_code)]
-
-pub mod small_c_string;
-
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/sys/pal/mod.rs b/library/std/src/sys/pal/mod.rs
index 93ad4536e18f..88d9d4205990 100644
--- a/library/std/src/sys/pal/mod.rs
+++ b/library/std/src/sys/pal/mod.rs
@@ -1,29 +1,8 @@
-//! Platform-dependent platform abstraction.
-//!
-//! The `std::sys` module is the abstracted interface through which
-//! `std` talks to the underlying operating system. It has different
-//! implementations for different operating system families, today
-//! just Unix and Windows, and initial support for Redox.
-//!
-//! The centralization of platform-specific code in this module is
-//! enforced by the "platform abstraction layer" tidy script in
-//! `tools/tidy/src/pal.rs`.
-//!
-//! This module is closely related to the platform-independent system
-//! integration code in `std::sys_common`. See that module's
-//! documentation for details.
-//!
-//! In the future it would be desirable for the independent
-//! implementations of this module to be extracted to their own crates
-//! that `std` can link to, thus enabling their implementation
-//! out-of-tree via crate replacement. Though due to the complex
-//! inter-dependencies within `std` that will be a challenging goal to
-//! achieve.
+//! The PAL (platform abstraction layer) contains platform-specific abstractions
+//! for implementing the features in the other submodules, such as e.g. bindings.
 
 #![allow(missing_debug_implementations)]
 
-pub mod common;
-
 cfg_select! {
     unix => {
         mod unix;
diff --git a/library/std/src/sys/pal/uefi/helpers.rs b/library/std/src/sys/pal/uefi/helpers.rs
index d059be010e98..9db72db60677 100644
--- a/library/std/src/sys/pal/uefi/helpers.rs
+++ b/library/std/src/sys/pal/uefi/helpers.rs
@@ -10,7 +10,7 @@
 //! - More information about protocols can be found [here](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/3_foundation/36_protocols_and_handles)
 
 use r_efi::efi::{self, Guid};
-use r_efi::protocols::{device_path, device_path_to_text, service_binding, shell};
+use r_efi::protocols::{device_path, device_path_to_text, file, service_binding, shell};
 
 use crate::alloc::Layout;
 use crate::ffi::{OsStr, OsString};
@@ -24,7 +24,7 @@ use crate::path::Path;
 use crate::ptr::NonNull;
 use crate::slice;
 use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
-use crate::sys_common::wstr::WStrUnits;
+use crate::sys::helpers::WStrUnits;
 
 type BootInstallMultipleProtocolInterfaces =
     unsafe extern "efiapi" fn(_: *mut r_efi::efi::Handle, _: ...) -> r_efi::efi::Status;
@@ -651,34 +651,38 @@ pub(crate) fn get_device_path_from_map(map: &Path) -> io::Result<BorrowedDeviceP
 
 /// Helper for UEFI Protocols which are created and destroyed using
 /// [EFI_SERVICE_BINDING_PROTOCOL](https://uefi.org/specs/UEFI/2.11/11_Protocols_UEFI_Driver_Model.html#efi-service-binding-protocol)
+///
+/// # Invariant
+/// - `handle` must always be a valid UEFI handle corresponding to the `service_guid`.
+/// - Copying `ServiceProtocol` is sound as long as `handle` remains valid.
+/// - For most service binding protocols (in edk2 implementations), such handles remain valid
+///   for the lifetime of the UEFI environment — effectively `'static`.
+#[derive(Clone, Copy)]
 pub(crate) struct ServiceProtocol {
     service_guid: r_efi::efi::Guid,
     handle: NonNull<crate::ffi::c_void>,
-    child_handle: NonNull<crate::ffi::c_void>,
 }
 
 impl ServiceProtocol {
-    pub(crate) fn open(service_guid: r_efi::efi::Guid) -> io::Result<Self> {
+    /// Open a child handle on a service_binding protocol.
+    pub(crate) fn open(
+        service_guid: r_efi::efi::Guid,
+    ) -> io::Result<(Self, NonNull<crate::ffi::c_void>)> {
         let handles = locate_handles(service_guid)?;
 
         for handle in handles {
             if let Ok(protocol) = open_protocol::<service_binding::Protocol>(handle, service_guid) {
-                let Ok(child_handle) = Self::create_child(protocol) else {
-                    continue;
-                };
-
-                return Ok(Self { service_guid, handle, child_handle });
+                if let Ok(child_handle) = unsafe { Self::create_child(protocol) } {
+                    return Ok((Self { service_guid, handle }, child_handle));
+                }
             }
         }
 
         Err(io::const_error!(io::ErrorKind::NotFound, "no service binding protocol found"))
     }
 
-    pub(crate) fn child_handle(&self) -> NonNull<crate::ffi::c_void> {
-        self.child_handle
-    }
-
-    fn create_child(
+    // SAFETY: sbp must be a valid service binding protocol pointer
+    unsafe fn create_child(
         sbp: NonNull<service_binding::Protocol>,
     ) -> io::Result<NonNull<crate::ffi::c_void>> {
         let mut child_handle: r_efi::efi::Handle = crate::ptr::null_mut();
@@ -692,17 +696,17 @@ impl ServiceProtocol {
                 .ok_or(const_error!(io::ErrorKind::Other, "null child handle"))
         }
     }
-}
 
-impl Drop for ServiceProtocol {
-    fn drop(&mut self) {
-        if let Ok(sbp) = open_protocol::<service_binding::Protocol>(self.handle, self.service_guid)
-        {
-            // SAFETY: Child handle must be allocated by the current service binding protocol.
-            let _ = unsafe {
-                ((*sbp.as_ptr()).destroy_child)(sbp.as_ptr(), self.child_handle.as_ptr())
-            };
-        }
+    // SAFETY: Child handle must be allocated by the current service binding protocol and must be
+    // valid.
+    pub(crate) unsafe fn destroy_child(
+        &self,
+        handle: NonNull<crate::ffi::c_void>,
+    ) -> io::Result<()> {
+        let sbp = open_protocol::<service_binding::Protocol>(self.handle, self.service_guid)?;
+
+        let r = unsafe { ((*sbp.as_ptr()).destroy_child)(sbp.as_ptr(), handle.as_ptr()) };
+        if r.is_error() { Err(crate::io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
     }
 }
 
@@ -787,7 +791,7 @@ impl<T> UefiBox<T> {
 
         match NonNull::new(ptr.cast()) {
             Some(inner) => Ok(Self { inner, size: len }),
-            None => Err(io::Error::new(io::ErrorKind::OutOfMemory, "Allocation failed")),
+            None => Err(const_error!(io::ErrorKind::OutOfMemory, "Allocation failed")),
         }
     }
 
@@ -814,3 +818,58 @@ impl<T> Drop for UefiBox<T> {
         unsafe { crate::alloc::dealloc(self.inner.as_ptr().cast(), layout) };
     }
 }
+
+impl UefiBox<file::Info> {
+    fn size(&self) -> u64 {
+        unsafe { (*self.as_ptr()).size }
+    }
+
+    fn set_size(&mut self, s: u64) {
+        unsafe { (*self.as_mut_ptr()).size = s }
+    }
+
+    // Length of string (including NULL), not number of bytes.
+    fn file_name_len(&self) -> usize {
+        (self.size() as usize - size_of::<file::Info<0>>()) / size_of::<u16>()
+    }
+
+    pub(crate) fn file_name(&self) -> &[u16] {
+        unsafe {
+            crate::slice::from_raw_parts((*self.as_ptr()).file_name.as_ptr(), self.file_name_len())
+        }
+    }
+
+    fn file_name_mut(&mut self) -> &mut [u16] {
+        unsafe {
+            crate::slice::from_raw_parts_mut(
+                (*self.as_mut_ptr()).file_name.as_mut_ptr(),
+                self.file_name_len(),
+            )
+        }
+    }
+
+    pub(crate) fn with_file_name(mut self, name: &OsStr) -> io::Result<Self> {
+        // os_string_to_raw returns NULL terminated string. So no need to handle it separately.
+        let fname = os_string_to_raw(name)
+            .ok_or(const_error!(io::ErrorKind::OutOfMemory, "Allocation failed"))?;
+        let new_size = size_of::<file::Info<0>>() + fname.len() * size_of::<u16>();
+
+        // Reuse the current structure if the new name can fit in it.
+        if self.size() >= new_size as u64 {
+            self.file_name_mut()[..fname.len()].copy_from_slice(&fname);
+            self.set_size(new_size as u64);
+
+            return Ok(self);
+        }
+
+        let mut new_box = UefiBox::new(new_size)?;
+
+        unsafe {
+            crate::ptr::copy_nonoverlapping(self.as_ptr(), new_box.as_mut_ptr(), 1);
+        }
+        new_box.set_size(new_size as u64);
+        new_box.file_name_mut().copy_from_slice(&fname);
+
+        Ok(new_box)
+    }
+}
diff --git a/library/std/src/sys/pal/uefi/time.rs b/library/std/src/sys/pal/uefi/time.rs
index c0f13de252ed..3dccd03ff3fc 100644
--- a/library/std/src/sys/pal/uefi/time.rs
+++ b/library/std/src/sys/pal/uefi/time.rs
@@ -300,7 +300,7 @@ pub(crate) mod instant_internal {
     use crate::mem::MaybeUninit;
     use crate::ptr::NonNull;
     use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
-    use crate::sys_common::mul_div_u64;
+    use crate::sys::helpers::mul_div_u64;
 
     const NS_PER_SEC: u64 = 1_000_000_000;
 
diff --git a/library/std/src/sys/pal/unix/linux/pidfd.rs b/library/std/src/sys/pal/unix/linux/pidfd.rs
index 7859854e96b4..e9e4831fcc02 100644
--- a/library/std/src/sys/pal/unix/linux/pidfd.rs
+++ b/library/std/src/sys/pal/unix/linux/pidfd.rs
@@ -1,5 +1,5 @@
 use crate::io;
-use crate::os::fd::{AsRawFd, FromRawFd, RawFd};
+use crate::os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 use crate::sys::fd::FileDesc;
 use crate::sys::process::ExitStatus;
 use crate::sys::{AsInner, FromInner, IntoInner, cvt};
@@ -15,6 +15,73 @@ impl PidFd {
         self.send_signal(libc::SIGKILL)
     }
 
+    #[cfg(any(test, target_env = "gnu", target_env = "musl"))]
+    pub(crate) fn current_process() -> io::Result<PidFd> {
+        let pid = crate::process::id();
+        let pidfd = cvt(unsafe { libc::syscall(libc::SYS_pidfd_open, pid, 0) })?;
+        Ok(unsafe { PidFd::from_raw_fd(pidfd as RawFd) })
+    }
+
+    #[cfg(any(test, target_env = "gnu", target_env = "musl"))]
+    pub(crate) fn pid(&self) -> io::Result<u32> {
+        use crate::sys::weak::weak;
+
+        // since kernel 6.13
+        // https://lore.kernel.org/all/20241010155401.2268522-1-luca.boccassi@gmail.com/
+        let mut pidfd_info: libc::pidfd_info = unsafe { crate::mem::zeroed() };
+        pidfd_info.mask = libc::PIDFD_INFO_PID as u64;
+        match cvt(unsafe { libc::ioctl(self.0.as_raw_fd(), libc::PIDFD_GET_INFO, &mut pidfd_info) })
+        {
+            Ok(_) => {}
+            Err(e) if e.raw_os_error() == Some(libc::EINVAL) => {
+                // kernel doesn't support that ioctl, try the glibc helper that looks at procfs
+                weak!(
+                    fn pidfd_getpid(pidfd: RawFd) -> libc::pid_t;
+                );
+                if let Some(pidfd_getpid) = pidfd_getpid.get() {
+                    let pid: libc::c_int = cvt(unsafe { pidfd_getpid(self.0.as_raw_fd()) })?;
+                    return Ok(pid as u32);
+                }
+                return Err(e);
+            }
+            Err(e) => return Err(e),
+        }
+
+        Ok(pidfd_info.pid)
+    }
+
+    fn exit_for_reaped_child(&self) -> io::Result<ExitStatus> {
+        // since kernel 6.15
+        // https://lore.kernel.org/linux-fsdevel/20250305-work-pidfs-kill_on_last_close-v3-0-c8c3d8361705@kernel.org/T/
+        let mut pidfd_info: libc::pidfd_info = unsafe { crate::mem::zeroed() };
+        pidfd_info.mask = libc::PIDFD_INFO_EXIT as u64;
+        cvt(unsafe { libc::ioctl(self.0.as_raw_fd(), libc::PIDFD_GET_INFO, &mut pidfd_info) })?;
+        Ok(ExitStatus::new(pidfd_info.exit_code))
+    }
+
+    fn waitid(&self, options: libc::c_int) -> io::Result<Option<ExitStatus>> {
+        let mut siginfo: libc::siginfo_t = unsafe { crate::mem::zeroed() };
+        let r = cvt(unsafe {
+            libc::waitid(libc::P_PIDFD, self.0.as_raw_fd() as u32, &mut siginfo, options)
+        });
+        match r {
+            Err(waitid_err) if waitid_err.raw_os_error() == Some(libc::ECHILD) => {
+                // already reaped
+                match self.exit_for_reaped_child() {
+                    Ok(exit_status) => return Ok(Some(exit_status)),
+                    Err(_) => return Err(waitid_err),
+                }
+            }
+            Err(e) => return Err(e),
+            Ok(_) => {}
+        }
+        if unsafe { siginfo.si_pid() } == 0 {
+            Ok(None)
+        } else {
+            Ok(Some(ExitStatus::from_waitid_siginfo(siginfo)))
+        }
+    }
+
     pub(crate) fn send_signal(&self, signal: i32) -> io::Result<()> {
         cvt(unsafe {
             libc::syscall(
@@ -29,29 +96,15 @@ impl PidFd {
     }
 
     pub fn wait(&self) -> io::Result<ExitStatus> {
-        let mut siginfo: libc::siginfo_t = unsafe { crate::mem::zeroed() };
-        cvt(unsafe {
-            libc::waitid(libc::P_PIDFD, self.0.as_raw_fd() as u32, &mut siginfo, libc::WEXITED)
-        })?;
-        Ok(ExitStatus::from_waitid_siginfo(siginfo))
+        let r = self.waitid(libc::WEXITED)?;
+        match r {
+            Some(exit_status) => Ok(exit_status),
+            None => unreachable!("waitid with WEXITED should not return None"),
+        }
     }
 
     pub fn try_wait(&self) -> io::Result<Option<ExitStatus>> {
-        let mut siginfo: libc::siginfo_t = unsafe { crate::mem::zeroed() };
-
-        cvt(unsafe {
-            libc::waitid(
-                libc::P_PIDFD,
-                self.0.as_raw_fd() as u32,
-                &mut siginfo,
-                libc::WEXITED | libc::WNOHANG,
-            )
-        })?;
-        if unsafe { siginfo.si_pid() } == 0 {
-            Ok(None)
-        } else {
-            Ok(Some(ExitStatus::from_waitid_siginfo(siginfo)))
-        }
+        self.waitid(libc::WEXITED | libc::WNOHANG)
     }
 }
 
@@ -78,3 +131,9 @@ impl FromRawFd for PidFd {
         Self(FileDesc::from_raw_fd(fd))
     }
 }
+
+impl IntoRawFd for PidFd {
+    fn into_raw_fd(self) -> RawFd {
+        self.0.into_raw_fd()
+    }
+}
diff --git a/library/std/src/sys/pal/unix/linux/pidfd/tests.rs b/library/std/src/sys/pal/unix/linux/pidfd/tests.rs
index 17b06bea9127..a3bb5d5d64ba 100644
--- a/library/std/src/sys/pal/unix/linux/pidfd/tests.rs
+++ b/library/std/src/sys/pal/unix/linux/pidfd/tests.rs
@@ -1,8 +1,11 @@
+use super::PidFd as InternalPidFd;
 use crate::assert_matches::assert_matches;
-use crate::os::fd::{AsRawFd, RawFd};
+use crate::io::ErrorKind;
+use crate::os::fd::AsRawFd;
 use crate::os::linux::process::{ChildExt, CommandExt as _};
 use crate::os::unix::process::{CommandExt as _, ExitStatusExt};
 use crate::process::Command;
+use crate::sys::AsInner;
 
 #[test]
 fn test_command_pidfd() {
@@ -48,11 +51,22 @@ fn test_command_pidfd() {
     let mut cmd = Command::new("false");
     let mut child = unsafe { cmd.pre_exec(|| Ok(())) }.create_pidfd(true).spawn().unwrap();
 
-    assert!(child.id() > 0 && child.id() < -1i32 as u32);
+    let id = child.id();
+
+    assert!(id > 0 && id < -1i32 as u32, "spawning with pidfd still returns a sane pid");
 
     if pidfd_open_available {
         assert!(child.pidfd().is_ok())
     }
+
+    if let Ok(pidfd) = child.pidfd() {
+        match pidfd.as_inner().pid() {
+            Ok(pid) => assert_eq!(pid, id),
+            Err(e) if e.kind() == ErrorKind::InvalidInput => { /* older kernel */ }
+            Err(e) => panic!("unexpected error getting pid from pidfd: {}", e),
+        }
+    }
+
     child.wait().expect("error waiting on child");
 }
 
@@ -77,9 +91,15 @@ fn test_pidfd() {
     assert_eq!(status.signal(), Some(libc::SIGKILL));
 
     // Trying to wait again for a reaped child is safe since there's no pid-recycling race.
-    // But doing so will return an error.
+    // But doing so may return an error.
     let res = fd.wait();
-    assert_matches!(res, Err(e) if e.raw_os_error() == Some(libc::ECHILD));
+    match res {
+        // older kernels
+        Err(e) if e.raw_os_error() == Some(libc::ECHILD) => {}
+        // 6.15+
+        Ok(exit) if exit.signal() == Some(libc::SIGKILL) => {}
+        other => panic!("expected ECHILD error, got {:?}", other),
+    }
 
     // Ditto for additional attempts to kill an already-dead child.
     let res = fd.kill();
@@ -87,13 +107,5 @@ fn test_pidfd() {
 }
 
 fn probe_pidfd_support() -> bool {
-    // pidfds require the pidfd_open syscall
-    let our_pid = crate::process::id();
-    let pidfd = unsafe { libc::syscall(libc::SYS_pidfd_open, our_pid, 0) };
-    if pidfd >= 0 {
-        unsafe { libc::close(pidfd as RawFd) };
-        true
-    } else {
-        false
-    }
+    InternalPidFd::current_process().is_ok()
 }
diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/pal/unix/os.rs
index edb7b604415b..ef3b4a02f8ae 100644
--- a/library/std/src/sys/pal/unix/os.rs
+++ b/library/std/src/sys/pal/unix/os.rs
@@ -10,8 +10,8 @@ use libc::{c_char, c_int, c_void};
 use crate::ffi::{CStr, OsStr, OsString};
 use crate::os::unix::prelude::*;
 use crate::path::{self, PathBuf};
-use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::cvt;
+use crate::sys::helpers::run_path_with_cstr;
 use crate::{fmt, io, iter, mem, ptr, slice, str};
 
 const TMPBUF_SZ: usize = 128;
diff --git a/library/std/src/sys/pal/unix/thread_parking.rs b/library/std/src/sys/pal/unix/thread_parking.rs
index bef8b4fb3639..6c3d04ceab21 100644
--- a/library/std/src/sys/pal/unix/thread_parking.rs
+++ b/library/std/src/sys/pal/unix/thread_parking.rs
@@ -2,24 +2,11 @@
 // separate modules for each platform.
 #![cfg(target_os = "netbsd")]
 
-use libc::{_lwp_self, CLOCK_MONOTONIC, c_long, clockid_t, lwpid_t, time_t, timespec};
+use libc::{_lwp_park, _lwp_self, _lwp_unpark, CLOCK_MONOTONIC, c_long, lwpid_t, time_t, timespec};
 
-use crate::ffi::{c_int, c_void};
 use crate::ptr;
 use crate::time::Duration;
 
-unsafe extern "C" {
-    fn ___lwp_park60(
-        clock_id: clockid_t,
-        flags: c_int,
-        ts: *mut timespec,
-        unpark: lwpid_t,
-        hint: *const c_void,
-        unparkhint: *const c_void,
-    ) -> c_int;
-    fn _lwp_unpark(lwp: lwpid_t, hint: *const c_void) -> c_int;
-}
-
 pub type ThreadId = lwpid_t;
 
 #[inline]
@@ -30,7 +17,7 @@ pub fn current() -> ThreadId {
 #[inline]
 pub fn park(hint: usize) {
     unsafe {
-        ___lwp_park60(0, 0, ptr::null_mut(), 0, ptr::without_provenance(hint), ptr::null());
+        _lwp_park(0, 0, ptr::null_mut(), 0, ptr::without_provenance(hint), ptr::null_mut());
     }
 }
 
@@ -45,13 +32,13 @@ pub fn park_timeout(dur: Duration, hint: usize) {
     // Timeout needs to be mutable since it is modified on NetBSD 9.0 and
     // above.
     unsafe {
-        ___lwp_park60(
+        _lwp_park(
             CLOCK_MONOTONIC,
             0,
             &mut timeout,
             0,
             ptr::without_provenance(hint),
-            ptr::null(),
+            ptr::null_mut(),
         );
     }
 }
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasi/os.rs
index a3bb329c2c4f..fee187a8adf3 100644
--- a/library/std/src/sys/pal/wasi/os.rs
+++ b/library/std/src/sys/pal/wasi/os.rs
@@ -4,7 +4,7 @@ use crate::ffi::{CStr, OsStr, OsString};
 use crate::marker::PhantomData;
 use crate::os::wasi::prelude::*;
 use crate::path::{self, PathBuf};
-use crate::sys::common::small_c_string::run_path_with_cstr;
+use crate::sys::helpers::run_path_with_cstr;
 use crate::sys::unsupported;
 use crate::{fmt, io, str};
 
diff --git a/library/std/src/sys/pal/windows/time.rs b/library/std/src/sys/pal/windows/time.rs
index ecd46c950b5e..a555b2b54623 100644
--- a/library/std/src/sys/pal/windows/time.rs
+++ b/library/std/src/sys/pal/windows/time.rs
@@ -179,8 +179,8 @@ fn intervals2dur(intervals: u64) -> Duration {
 mod perf_counter {
     use super::NANOS_PER_SEC;
     use crate::sync::atomic::{Atomic, AtomicU64, Ordering};
+    use crate::sys::helpers::mul_div_u64;
     use crate::sys::{c, cvt};
-    use crate::sys_common::mul_div_u64;
     use crate::time::Duration;
 
     pub struct PerformanceCounterInstant {
diff --git a/library/std/src/sys/path/cygwin.rs b/library/std/src/sys/path/cygwin.rs
index 416877a7280d..75f0de6beaeb 100644
--- a/library/std/src/sys/path/cygwin.rs
+++ b/library/std/src/sys/path/cygwin.rs
@@ -1,8 +1,8 @@
 use crate::ffi::OsString;
 use crate::os::unix::ffi::OsStringExt;
 use crate::path::{Path, PathBuf};
-use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::cvt;
+use crate::sys::helpers::run_path_with_cstr;
 use crate::{io, ptr};
 
 #[inline]
diff --git a/library/std/src/sys/path/uefi.rs b/library/std/src/sys/path/uefi.rs
index 6b8258685aa0..84d634af93cf 100644
--- a/library/std/src/sys/path/uefi.rs
+++ b/library/std/src/sys/path/uefi.rs
@@ -2,7 +2,8 @@
 use crate::ffi::OsStr;
 use crate::io;
 use crate::path::{Path, PathBuf, Prefix};
-use crate::sys::{helpers, unsupported_err};
+use crate::sys::pal::helpers;
+use crate::sys::unsupported_err;
 
 const FORWARD_SLASH: u8 = b'/';
 const COLON: u8 = b':';
diff --git a/library/std/src/sys/platform_version/darwin/core_foundation.rs b/library/std/src/sys/platform_version/darwin/core_foundation.rs
index 1e0d15fcf661..de2b57ea755b 100644
--- a/library/std/src/sys/platform_version/darwin/core_foundation.rs
+++ b/library/std/src/sys/platform_version/darwin/core_foundation.rs
@@ -3,7 +3,7 @@
 use super::root_relative;
 use crate::ffi::{CStr, c_char, c_void};
 use crate::ptr::null_mut;
-use crate::sys::common::small_c_string::run_path_with_cstr;
+use crate::sys::helpers::run_path_with_cstr;
 
 // MacTypes.h
 pub(super) type Boolean = u8;
diff --git a/library/std/src/sys/process/uefi.rs b/library/std/src/sys/process/uefi.rs
index 0e10bc02a0b9..d627a477dc1a 100644
--- a/library/std/src/sys/process/uefi.rs
+++ b/library/std/src/sys/process/uefi.rs
@@ -377,8 +377,8 @@ mod uefi_command_internal {
     use crate::os::uefi::ffi::{OsStrExt, OsStringExt};
     use crate::ptr::NonNull;
     use crate::slice;
+    use crate::sys::helpers::WStrUnits;
     use crate::sys::pal::helpers::{self, OwnedTable};
-    use crate::sys_common::wstr::WStrUnits;
 
     pub struct Image {
         handle: NonNull<crate::ffi::c_void>,
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 5ba57e11679c..df64a1716d52 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -482,10 +482,6 @@ impl Command {
                     ) -> libc::c_int;
                 );
 
-                weak!(
-                    fn pidfd_getpid(pidfd: libc::c_int) -> libc::c_int;
-                );
-
                 static PIDFD_SUPPORTED: Atomic<u8> = AtomicU8::new(0);
                 const UNKNOWN: u8 = 0;
                 const SPAWN: u8 = 1;
@@ -502,24 +498,26 @@ impl Command {
                     }
                     if support == UNKNOWN {
                         support = NO;
-                        let our_pid = crate::process::id();
-                        let pidfd = cvt(unsafe { libc::syscall(libc::SYS_pidfd_open, our_pid, 0) } as c_int);
-                        match pidfd {
+
+                        match PidFd::current_process() {
                             Ok(pidfd) => {
+                                // if pidfd_open works then we at least know the fork path is available.
                                 support = FORK_EXEC;
-                                if let Some(Ok(pid)) = pidfd_getpid.get().map(|f| cvt(unsafe { f(pidfd) } as i32)) {
-                                    if pidfd_spawnp.get().is_some() && pid as u32 == our_pid {
-                                        support = SPAWN
-                                    }
+                                // but for the fast path we need both spawnp and the
+                                // pidfd -> pid conversion to work.
+                                if pidfd_spawnp.get().is_some() && let Ok(pid) = pidfd.pid() {
+                                    assert_eq!(pid, crate::process::id(), "sanity check");
+                                    support = SPAWN;
                                 }
-                                unsafe { libc::close(pidfd) };
                             }
                             Err(e) if e.raw_os_error() == Some(libc::EMFILE) => {
-                                // We're temporarily(?) out of file descriptors.  In this case obtaining a pidfd would also fail
+                                // We're temporarily(?) out of file descriptors. In this case pidfd_spawnp would also fail
                                 // Don't update the support flag so we can probe again later.
                                 return Err(e)
                             }
-                            _ => {}
+                            _ => {
+                                // pidfd_open not available? likely an old kernel without pidfd support.
+                            }
                         }
                         PIDFD_SUPPORTED.store(support, Ordering::Relaxed);
                         if support == FORK_EXEC {
@@ -791,13 +789,17 @@ impl Command {
                 }
                 spawn_res?;
 
-                let pid = match cvt(pidfd_getpid.get().unwrap()(pidfd)) {
+                use crate::os::fd::{FromRawFd, IntoRawFd};
+
+                let pidfd = PidFd::from_raw_fd(pidfd);
+                let pid = match pidfd.pid() {
                     Ok(pid) => pid,
                     Err(e) => {
                         // The child has been spawned and we are holding its pidfd.
-                        // But we cannot obtain its pid even though pidfd_getpid support was verified earlier.
-                        // This might happen if libc can't open procfs because the file descriptor limit has been reached.
-                        libc::close(pidfd);
+                        // But we cannot obtain its pid even though pidfd_spawnp and getpid support
+                        // was verified earlier.
+                        // This is quite unlikely, but might happen if the ioctl is not supported,
+                        // glibc tries to use procfs and we're out of file descriptors.
                         return Err(Error::new(
                             e.kind(),
                             "pidfd_spawnp succeeded but the child's PID could not be obtained",
@@ -805,7 +807,7 @@ impl Command {
                     }
                 };
 
-                return Ok(Some(Process::new(pid, pidfd)));
+                return Ok(Some(Process::new(pid as i32, pidfd.into_raw_fd())));
             }
 
             // Safety: -1 indicates we don't have a pidfd.
diff --git a/library/std/src/sys/thread_local/native/mod.rs b/library/std/src/sys/thread_local/native/mod.rs
index 38b373be56c9..4dad81685a94 100644
--- a/library/std/src/sys/thread_local/native/mod.rs
+++ b/library/std/src/sys/thread_local/native/mod.rs
@@ -47,7 +47,7 @@ pub use lazy::Storage as LazyStorage;
 )]
 #[allow_internal_unsafe]
 #[unstable(feature = "thread_local_internals", issue = "none")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro thread_local_inner {
     // NOTE: we cannot import `LocalKey`, `LazyStorage` or `EagerStorage` with a `use` because that
     // can shadow user provided type or type alias with a matching name. Please update the shadowing
@@ -110,7 +110,7 @@ pub macro thread_local_inner {
     }},
 }
 
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub(crate) macro local_pointer {
     () => {},
     ($vis:vis static $name:ident; $($rest:tt)*) => {
diff --git a/library/std/src/sys/thread_local/no_threads.rs b/library/std/src/sys/thread_local/no_threads.rs
index 936d464be9f1..27a589a4a76a 100644
--- a/library/std/src/sys/thread_local/no_threads.rs
+++ b/library/std/src/sys/thread_local/no_threads.rs
@@ -9,7 +9,7 @@ use crate::ptr;
 #[allow_internal_unstable(thread_local_internals)]
 #[allow_internal_unsafe]
 #[unstable(feature = "thread_local_internals", issue = "none")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
     (@key $t:ty, $(#[$align_attr:meta])*, const $init:expr) => {{
@@ -119,7 +119,7 @@ impl<T> LazyStorage<T> {
 // SAFETY: the target doesn't have threads.
 unsafe impl<T> Sync for LazyStorage<T> {}
 
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub(crate) macro local_pointer {
     () => {},
     ($vis:vis static $name:ident; $($rest:tt)*) => {
diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index 07b93a2cbbc3..3f06c9bd1d77 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -12,7 +12,7 @@ use crate::ptr::{self, NonNull};
 #[allow_internal_unstable(thread_local_internals)]
 #[allow_internal_unsafe]
 #[unstable(feature = "thread_local_internals", issue = "none")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro thread_local_inner {
     // NOTE: we cannot import `Storage` or `LocalKey` with a `use` because that can shadow user
     // provided type or type alias with a matching name. Please update the shadowing test in
@@ -261,7 +261,7 @@ unsafe extern "C" fn destroy_value<T: 'static, const ALIGN: usize>(ptr: *mut u8)
     });
 }
 
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub(crate) macro local_pointer {
     () => {},
     ($vis:vis static $name:ident; $($rest:tt)*) => {
diff --git a/library/std/src/sys_common/mod.rs b/library/std/src/sys_common/mod.rs
deleted file mode 100644
index 015042440b5a..000000000000
--- a/library/std/src/sys_common/mod.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! Platform-independent platform abstraction
-//!
-//! This is the platform-independent portion of the standard library's
-//! platform abstraction layer, whereas `std::sys` is the
-//! platform-specific portion.
-//!
-//! The relationship between `std::sys_common`, `std::sys` and the
-//! rest of `std` is complex, with dependencies going in all
-//! directions: `std` depending on `sys_common`, `sys_common`
-//! depending on `sys`, and `sys` depending on `sys_common` and `std`.
-//! This is because `sys_common` not only contains platform-independent code,
-//! but also code that is shared between the different platforms in `sys`.
-//! Ideally all that shared code should be moved to `sys::common`,
-//! and the dependencies between `std`, `sys_common` and `sys` all would form a DAG.
-//! Progress on this is tracked in #84187.
-
-#![allow(missing_docs)]
-
-#[cfg(test)]
-mod tests;
-
-pub mod wstr;
-
-// common error constructors
-
-// Computes (value*numerator)/denom without overflow, as long as both (numerator*denom) and the
-// overall result fit into i64 (which is the case for our time conversions).
-#[allow(dead_code)] // not used on all platforms
-pub fn mul_div_u64(value: u64, numerator: u64, denom: u64) -> u64 {
-    let q = value / denom;
-    let r = value % denom;
-    // Decompose value as (value/denom*denom + value%denom),
-    // substitute into (value*numerator)/denom and simplify.
-    // r < denom, so (denom*numerator) is the upper bound of (r*numerator)
-    q * numerator + r * numerator / denom
-}
-
-pub fn ignore_notfound<T>(result: crate::io::Result<T>) -> crate::io::Result<()> {
-    match result {
-        Err(err) if err.kind() == crate::io::ErrorKind::NotFound => Ok(()),
-        Ok(_) => Ok(()),
-        Err(err) => Err(err),
-    }
-}
diff --git a/library/std/src/sys_common/tests.rs b/library/std/src/sys_common/tests.rs
deleted file mode 100644
index 1b6446db52d4..000000000000
--- a/library/std/src/sys_common/tests.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use super::mul_div_u64;
-
-#[test]
-fn test_muldiv() {
-    assert_eq!(mul_div_u64(1_000_000_000_001, 1_000_000_000, 1_000_000), 1_000_000_000_001_000);
-}
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 06e4b252fc8f..1318d8dc2780 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -140,7 +140,7 @@ impl<T: 'static> fmt::Debug for LocalKey<T> {
 #[doc(hidden)]
 #[allow_internal_unstable(thread_local_internals)]
 #[unstable(feature = "thread_local_internals", issue = "none")]
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 pub macro thread_local_process_attrs {
 
     // Parse `cfg_attr` to figure out whether it's a `rustc_align_static`.
diff --git a/library/std/tests/sync/lib.rs b/library/std/tests/sync/lib.rs
index 7ade9f623147..32a7efde2a25 100644
--- a/library/std/tests/sync/lib.rs
+++ b/library/std/tests/sync/lib.rs
@@ -1,5 +1,6 @@
 #![feature(mapped_lock_guards)]
 #![feature(mpmc_channel)]
+#![feature(oneshot_channel)]
 #![feature(once_cell_try)]
 #![feature(lock_value_accessors)]
 #![feature(reentrant_lock)]
@@ -26,6 +27,8 @@ mod mutex;
 mod once;
 mod once_lock;
 #[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod oneshot;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
 mod reentrant_lock;
 #[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
 mod rwlock;
diff --git a/library/std/tests/sync/oneshot.rs b/library/std/tests/sync/oneshot.rs
new file mode 100644
index 000000000000..6a87c72b9cb5
--- /dev/null
+++ b/library/std/tests/sync/oneshot.rs
@@ -0,0 +1,342 @@
+//! Inspired by tests from <https://github.com/faern/oneshot/blob/main/tests/sync.rs>
+
+use std::sync::mpsc::RecvError;
+use std::sync::oneshot;
+use std::sync::oneshot::{RecvTimeoutError, TryRecvError};
+use std::time::{Duration, Instant};
+use std::{mem, thread};
+
+#[test]
+fn send_before_try_recv() {
+    let (sender, receiver) = oneshot::channel();
+
+    assert!(sender.send(19i128).is_ok());
+
+    match receiver.try_recv() {
+        Ok(19) => {}
+        _ => panic!("expected Ok(19)"),
+    }
+}
+
+#[test]
+fn send_before_recv() {
+    let (sender, receiver) = oneshot::channel::<()>();
+
+    assert!(sender.send(()).is_ok());
+    assert_eq!(receiver.recv(), Ok(()));
+
+    let (sender, receiver) = oneshot::channel::<u64>();
+
+    assert!(sender.send(42).is_ok());
+    assert_eq!(receiver.recv(), Ok(42));
+
+    let (sender, receiver) = oneshot::channel::<[u8; 4096]>();
+
+    assert!(sender.send([0b10101010; 4096]).is_ok());
+    assert!(receiver.recv().unwrap()[..] == [0b10101010; 4096][..]);
+}
+
+#[test]
+fn sender_drop() {
+    {
+        let (sender, receiver) = oneshot::channel::<u128>();
+
+        mem::drop(sender);
+
+        match receiver.recv() {
+            Err(RecvError) => {}
+            _ => panic!("expected recv error"),
+        }
+    }
+
+    {
+        let (sender, receiver) = oneshot::channel::<i32>();
+
+        mem::drop(sender);
+
+        match receiver.try_recv() {
+            Err(TryRecvError::Disconnected) => {}
+            _ => panic!("expected disconnected error"),
+        }
+    }
+    {
+        let (sender, receiver) = oneshot::channel::<i32>();
+
+        mem::drop(sender);
+
+        match receiver.recv_timeout(Duration::from_secs(1)) {
+            Err(RecvTimeoutError::Disconnected) => {}
+            _ => panic!("expected disconnected error"),
+        }
+    }
+}
+
+#[test]
+fn send_never_deadline() {
+    let (sender, receiver) = oneshot::channel::<i32>();
+
+    mem::drop(sender);
+
+    match receiver.recv_deadline(Instant::now()) {
+        Err(RecvTimeoutError::Disconnected) => {}
+        _ => panic!("expected disconnected error"),
+    }
+}
+
+#[test]
+fn send_before_recv_timeout() {
+    let (sender, receiver) = oneshot::channel();
+
+    assert!(sender.send(22i128).is_ok());
+
+    let start = Instant::now();
+
+    let timeout = Duration::from_secs(1);
+    match receiver.recv_timeout(timeout) {
+        Ok(22) => {}
+        _ => panic!("expected Ok(22)"),
+    }
+
+    assert!(start.elapsed() < timeout);
+}
+
+#[test]
+fn send_error() {
+    let (sender, receiver) = oneshot::channel();
+
+    mem::drop(receiver);
+
+    let send_error = sender.send(32u128).unwrap_err();
+    assert_eq!(send_error.0, 32);
+}
+
+#[test]
+fn recv_before_send() {
+    let (sender, receiver) = oneshot::channel();
+
+    let t1 = thread::spawn(move || {
+        thread::sleep(Duration::from_millis(10));
+        sender.send(9u128).unwrap();
+    });
+    let t2 = thread::spawn(move || {
+        assert_eq!(receiver.recv(), Ok(9));
+    });
+
+    t1.join().unwrap();
+    t2.join().unwrap();
+}
+
+#[test]
+fn recv_timeout_before_send() {
+    let (sender, receiver) = oneshot::channel();
+
+    let t = thread::spawn(move || {
+        thread::sleep(Duration::from_millis(100));
+        sender.send(99u128).unwrap();
+    });
+
+    match receiver.recv_timeout(Duration::from_secs(1)) {
+        Ok(99) => {}
+        _ => panic!("expected Ok(99)"),
+    }
+
+    t.join().unwrap();
+}
+
+#[test]
+fn recv_then_drop_sender() {
+    let (sender, receiver) = oneshot::channel::<u128>();
+
+    let t1 = thread::spawn(move || match receiver.recv() {
+        Err(RecvError) => {}
+        _ => panic!("expected recv error"),
+    });
+
+    let t2 = thread::spawn(move || {
+        thread::sleep(Duration::from_millis(10));
+        mem::drop(sender);
+    });
+
+    t1.join().unwrap();
+    t2.join().unwrap();
+}
+
+#[test]
+fn drop_sender_then_recv() {
+    let (sender, receiver) = oneshot::channel::<u128>();
+
+    let t1 = thread::spawn(move || {
+        thread::sleep(Duration::from_millis(10));
+        mem::drop(sender);
+    });
+
+    let t2 = thread::spawn(move || match receiver.recv() {
+        Err(RecvError) => {}
+        _ => panic!("expected disconnected error"),
+    });
+
+    t1.join().unwrap();
+    t2.join().unwrap();
+}
+
+#[test]
+fn try_recv_empty() {
+    let (sender, receiver) = oneshot::channel::<u128>();
+    match receiver.try_recv() {
+        Err(TryRecvError::Empty(_)) => {}
+        _ => panic!("expected empty error"),
+    }
+    mem::drop(sender);
+}
+
+#[test]
+fn try_recv_then_drop_receiver() {
+    let (sender, receiver) = oneshot::channel::<u128>();
+
+    let t1 = thread::spawn(move || {
+        thread::sleep(Duration::from_millis(100));
+        let _ = sender.send(42);
+    });
+
+    let t2 = thread::spawn(move || match receiver.try_recv() {
+        Ok(_) => {}
+        Err(TryRecvError::Empty(r)) => {
+            mem::drop(r);
+        }
+        Err(TryRecvError::Disconnected) => {}
+    });
+
+    t2.join().unwrap();
+    t1.join().unwrap();
+}
+
+#[test]
+fn recv_no_time() {
+    let (_sender, receiver) = oneshot::channel::<u128>();
+
+    let start = Instant::now();
+    match receiver.recv_deadline(start) {
+        Err(RecvTimeoutError::Timeout(_)) => {}
+        _ => panic!("expected timeout error"),
+    }
+
+    let (_sender, receiver) = oneshot::channel::<u128>();
+    match receiver.recv_timeout(Duration::from_millis(0)) {
+        Err(RecvTimeoutError::Timeout(_)) => {}
+        _ => panic!("expected timeout error"),
+    }
+}
+
+#[test]
+fn recv_deadline_passed() {
+    let (_sender, receiver) = oneshot::channel::<u128>();
+
+    let start = Instant::now();
+    let timeout = Duration::from_millis(100);
+
+    match receiver.recv_deadline(start + timeout) {
+        Err(RecvTimeoutError::Timeout(_)) => {}
+        _ => panic!("expected timeout error"),
+    }
+
+    assert!(start.elapsed() >= timeout);
+    assert!(start.elapsed() < timeout * 3);
+}
+
+#[test]
+fn recv_time_passed() {
+    let (_sender, receiver) = oneshot::channel::<u128>();
+
+    let start = Instant::now();
+    let timeout = Duration::from_millis(100);
+    match receiver.recv_timeout(timeout) {
+        Err(RecvTimeoutError::Timeout(_)) => {}
+        _ => panic!("expected timeout error"),
+    }
+    assert!(start.elapsed() >= timeout);
+    assert!(start.elapsed() < timeout * 3);
+}
+
+#[test]
+fn non_send_type_can_be_used_on_same_thread() {
+    use std::ptr;
+
+    #[derive(Debug, Eq, PartialEq)]
+    struct NotSend(*mut ());
+
+    let (sender, receiver) = oneshot::channel();
+    sender.send(NotSend(ptr::null_mut())).unwrap();
+    let reply = receiver.try_recv().unwrap();
+    assert_eq!(reply, NotSend(ptr::null_mut()));
+}
+
+/// Helper for testing drop behavior (taken directly from the `oneshot` crate).
+struct DropCounter {
+    count: std::rc::Rc<std::cell::RefCell<usize>>,
+}
+
+impl DropCounter {
+    fn new() -> (DropTracker, DropCounter) {
+        let count = std::rc::Rc::new(std::cell::RefCell::new(0));
+        (DropTracker { count: count.clone() }, DropCounter { count })
+    }
+
+    fn count(&self) -> usize {
+        *self.count.borrow()
+    }
+}
+
+struct DropTracker {
+    count: std::rc::Rc<std::cell::RefCell<usize>>,
+}
+
+impl Drop for DropTracker {
+    fn drop(&mut self) {
+        *self.count.borrow_mut() += 1;
+    }
+}
+
+#[test]
+fn message_in_channel_dropped_on_receiver_drop() {
+    let (sender, receiver) = oneshot::channel();
+
+    let (message, counter) = DropCounter::new();
+    assert_eq!(counter.count(), 0);
+
+    sender.send(message).unwrap();
+    assert_eq!(counter.count(), 0);
+
+    mem::drop(receiver);
+    assert_eq!(counter.count(), 1);
+}
+
+#[test]
+fn send_error_drops_message_correctly() {
+    let (sender, receiver) = oneshot::channel();
+    mem::drop(receiver);
+
+    let (message, counter) = DropCounter::new();
+
+    let send_error = sender.send(message).unwrap_err();
+    assert_eq!(counter.count(), 0);
+
+    mem::drop(send_error);
+    assert_eq!(counter.count(), 1);
+}
+
+#[test]
+fn send_error_drops_message_correctly_on_extract() {
+    let (sender, receiver) = oneshot::channel();
+    mem::drop(receiver);
+
+    let (message, counter) = DropCounter::new();
+
+    let send_error = sender.send(message).unwrap_err();
+    assert_eq!(counter.count(), 0);
+
+    let message = send_error.0; // Access the inner value directly
+    assert_eq!(counter.count(), 0);
+
+    mem::drop(message);
+    assert_eq!(counter.count(), 1);
+}
diff --git a/library/std_detect/Cargo.toml b/library/std_detect/Cargo.toml
index 2739bb592300..a6785bb20555 100644
--- a/library/std_detect/Cargo.toml
+++ b/library/std_detect/Cargo.toml
@@ -7,11 +7,6 @@ authors = [
     "Gonzalo Brito Gadeschi <gonzalobg88@gmail.com>",
 ]
 description = "`std::detect` - Rust's standard library run-time CPU feature detection."
-homepage = "https://github.com/rust-lang/stdarch"
-repository = "https://github.com/rust-lang/stdarch"
-readme = "README.md"
-keywords = ["std", "run-time", "feature", "detection"]
-categories = ["hardware-support"]
 license = "MIT OR Apache-2.0"
 edition = "2024"
 
@@ -25,10 +20,7 @@ core = { version = "1.0.0", package = 'rustc-std-workspace-core' }
 alloc = { version = "1.0.0", package = 'rustc-std-workspace-alloc' }
 
 [target.'cfg(not(windows))'.dependencies]
-libc = { version = "0.2.0", optional = true, default-features = false }
+libc = { version = "0.2.0", default-features = false }
 
 [features]
-default = []
-std_detect_file_io = [ "libc" ]
-std_detect_dlsym_getauxval = [ "libc" ]
-std_detect_env_override = [ "libc" ]
+std_detect_env_override = []
diff --git a/library/std_detect/README.md b/library/std_detect/README.md
index 177848dec104..895f3426d049 100644
--- a/library/std_detect/README.md
+++ b/library/std_detect/README.md
@@ -21,32 +21,6 @@ run-time feature detection support than the one offered by Rust's standard
 library. We intend to make `std_detect` more flexible and configurable in this
 regard to better serve the needs of `#[no_std]` targets.
 
-# Features
-
-* `std_detect_dlsym_getauxval` (enabled by default, requires `libc`): Enable to
-use `libc::dlsym` to query whether [`getauxval`] is linked into the binary. When
-this is not the case, this feature allows other fallback methods to perform
-run-time feature detection. When this feature is disabled, `std_detect` assumes
-that [`getauxval`] is linked to the binary. If that is not the case the behavior
-is undefined.
-
-  Note: This feature is ignored on `*-linux-{gnu,musl,ohos}*` and `*-android*` targets
-  because we can safely assume `getauxval` is linked to the binary.
-  * `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
-    have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
-  * `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
-    use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
-  * `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
-  * `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
-    have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
-
-* `std_detect_file_io` (enabled by default, requires `std`): Enable to perform run-time feature
-detection using file APIs (e.g. `/proc/self/auxv`, etc.) if other more performant
-methods fail. This feature requires `libstd` as a dependency, preventing the
-crate from working on applications in which `std` is not available.
-
-[`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
-
 # Platform support
 
 * All `x86`/`x86_64` targets are supported on all platforms by querying the
diff --git a/library/std_detect/src/detect/arch/riscv.rs b/library/std_detect/src/detect/arch/riscv.rs
index 846d7f10d68f..ecad1a58d5f2 100644
--- a/library/std_detect/src/detect/arch/riscv.rs
+++ b/library/std_detect/src/detect/arch/riscv.rs
@@ -196,26 +196,26 @@ features! {
     @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] unaligned_vector_mem: "unaligned-vector-mem";
     /// Has reasonably performant unaligned vector
 
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicsr: "zicsr";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zicsr: "zicsr";
     /// "Zicsr" Extension for Control and Status Register (CSR) Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicntr: "zicntr";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zicntr: "zicntr";
     /// "Zicntr" Extension for Base Counters and Timers
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihpm: "zihpm";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zihpm: "zihpm";
     /// "Zihpm" Extension for Hardware Performance Counters
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zifencei: "zifencei";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zifencei: "zifencei";
     /// "Zifencei" Extension for Instruction-Fetch Fence
 
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintntl: "zihintntl";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zihintntl: "zihintntl";
     /// "Zihintntl" Extension for Non-Temporal Locality Hints
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintpause: "zihintpause";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zihintpause: "zihintpause";
     /// "Zihintpause" Extension for Pause Hint
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zimop: "zimop";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zimop: "zimop";
     /// "Zimop" Extension for May-Be-Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicbom: "zicbom";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zicbom: "zicbom";
     /// "Zicbom" Extension for Cache-Block Management Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicboz: "zicboz";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zicboz: "zicboz";
     /// "Zicboz" Extension for Cache-Block Zero Instruction
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicond: "zicond";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zicond: "zicond";
     /// "Zicond" Extension for Integer Conditional Operations
 
     @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] m: "m";
@@ -223,20 +223,20 @@ features! {
 
     @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] a: "a";
     /// "A" Extension for Atomic Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zalrsc: "zalrsc";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zalrsc: "zalrsc";
     /// "Zalrsc" Extension for Load-Reserved/Store-Conditional Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zaamo: "zaamo";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zaamo: "zaamo";
     /// "Zaamo" Extension for Atomic Memory Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zawrs: "zawrs";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zawrs: "zawrs";
     /// "Zawrs" Extension for Wait-on-Reservation-Set Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zabha: "zabha";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zabha: "zabha";
     /// "Zabha" Extension for Byte and Halfword Atomic Memory Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zacas: "zacas";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zacas: "zacas";
     /// "Zacas" Extension for Atomic Compare-and-Swap (CAS) Instructions
     @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zam: "zam";
     without cfg check: true;
     /// "Zam" Extension for Misaligned Atomics
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] ztso: "ztso";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] ztso: "ztso";
     /// "Ztso" Extension for Total Store Ordering
 
     @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] f: "f";
@@ -266,7 +266,7 @@ features! {
 
     @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] c: "c";
     /// "C" Extension for Compressed Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zca: "zca";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zca: "zca";
     /// "Zca" Compressed Instructions excluding Floating-Point Loads/Stores
     @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcf: "zcf";
     without cfg check: true;
@@ -274,12 +274,12 @@ features! {
     @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcd: "zcd";
     without cfg check: true;
     /// "Zcd" Compressed Instructions for Double-Precision Floating-Point Loads/Stores
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcb: "zcb";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zcb: "zcb";
     /// "Zcb" Simple Code-size Saving Compressed Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcmop: "zcmop";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] zcmop: "zcmop";
     /// "Zcmop" Extension for Compressed May-Be-Operations
 
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] b: "b";
+    @FEATURE: #[stable(feature = "riscv_ratified_v2", since = "CURRENT_RUSTC_VERSION")] b: "b";
     /// "B" Extension for Bit Manipulation
     @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zba: "zba";
     /// "Zba" Extension for Address Generation
diff --git a/library/std_detect/src/detect/mod.rs b/library/std_detect/src/detect/mod.rs
index ae6fb2ab3727..c888dd34d9db 100644
--- a/library/std_detect/src/detect/mod.rs
+++ b/library/std_detect/src/detect/mod.rs
@@ -47,21 +47,21 @@ cfg_select! {
         #[path = "os/x86.rs"]
         mod os;
     }
-    all(any(target_os = "linux", target_os = "android"), feature = "libc") => {
+    any(target_os = "linux", target_os = "android") => {
         #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
         #[path = "os/riscv.rs"]
         mod riscv;
         #[path = "os/linux/mod.rs"]
         mod os;
     }
-    all(target_os = "freebsd", feature = "libc") => {
+    target_os = "freebsd" => {
         #[cfg(target_arch = "aarch64")]
         #[path = "os/aarch64.rs"]
         mod aarch64;
         #[path = "os/freebsd/mod.rs"]
         mod os;
     }
-    all(target_os = "openbsd", feature = "libc") => {
+    target_os = "openbsd" => {
         #[allow(dead_code)] // we don't use code that calls the mrs instruction.
         #[cfg(target_arch = "aarch64")]
         #[path = "os/aarch64.rs"]
@@ -73,7 +73,7 @@ cfg_select! {
         #[path = "os/windows/aarch64.rs"]
         mod os;
     }
-    all(target_vendor = "apple", target_arch = "aarch64", feature = "libc") => {
+    all(target_vendor = "apple", target_arch = "aarch64") => {
         #[path = "os/darwin/aarch64.rs"]
         mod os;
     }
diff --git a/library/std_detect/src/detect/os/linux/aarch64/tests.rs b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
index a3562f2fd936..4d7c9a419d38 100644
--- a/library/std_detect/src/detect/os/linux/aarch64/tests.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
@@ -1,77 +1,70 @@
+use super::auxvec::auxv_from_file;
 use super::*;
-
-#[cfg(feature = "std_detect_file_io")]
-mod auxv_from_file {
-    use super::auxvec::auxv_from_file;
-    use super::*;
-    // The baseline hwcaps used in the (artificial) auxv test files.
-    fn baseline_hwcaps() -> AtHwcap {
-        AtHwcap {
-            fp: true,
-            asimd: true,
-            aes: true,
-            pmull: true,
-            sha1: true,
-            sha2: true,
-            crc32: true,
-            atomics: true,
-            fphp: true,
-            asimdhp: true,
-            asimdrdm: true,
-            lrcpc: true,
-            dcpop: true,
-            asimddp: true,
-            ssbs: true,
-            ..AtHwcap::default()
-        }
-    }
-
-    #[test]
-    fn linux_empty_hwcap2_aarch64() {
-        let file = concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
-        );
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-    }
-    #[test]
-    fn linux_no_hwcap2_aarch64() {
-        let file = concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
-        );
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-    }
-    #[test]
-    fn linux_hwcap2_aarch64() {
-        let file =
-            concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-hwcap2-aarch64.auxv");
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(
-            AtHwcap::from(v),
-            AtHwcap {
-                // Some other HWCAP bits.
-                paca: true,
-                pacg: true,
-                // HWCAP2-only bits.
-                dcpodp: true,
-                frint: true,
-                rng: true,
-                bti: true,
-                mte: true,
-                ..baseline_hwcaps()
-            }
-        );
+// The baseline hwcaps used in the (artificial) auxv test files.
+fn baseline_hwcaps() -> AtHwcap {
+    AtHwcap {
+        fp: true,
+        asimd: true,
+        aes: true,
+        pmull: true,
+        sha1: true,
+        sha2: true,
+        crc32: true,
+        atomics: true,
+        fphp: true,
+        asimdhp: true,
+        asimdrdm: true,
+        lrcpc: true,
+        dcpop: true,
+        asimddp: true,
+        ssbs: true,
+        ..AtHwcap::default()
     }
 }
+
+#[test]
+fn linux_empty_hwcap2_aarch64() {
+    let file = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
+    );
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+}
+#[test]
+fn linux_no_hwcap2_aarch64() {
+    let file =
+        concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+}
+#[test]
+fn linux_hwcap2_aarch64() {
+    let file =
+        concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-hwcap2-aarch64.auxv");
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(
+        AtHwcap::from(v),
+        AtHwcap {
+            // Some other HWCAP bits.
+            paca: true,
+            pacg: true,
+            // HWCAP2-only bits.
+            dcpodp: true,
+            frint: true,
+            rng: true,
+            bti: true,
+            mte: true,
+            ..baseline_hwcaps()
+        }
+    );
+}
diff --git a/library/std_detect/src/detect/os/linux/auxvec.rs b/library/std_detect/src/detect/os/linux/auxvec.rs
index 75e01bdc4499..c0bbc7d4efa8 100644
--- a/library/std_detect/src/detect/os/linux/auxvec.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec.rs
@@ -44,20 +44,16 @@ pub(crate) struct AuxVec {
 ///
 /// There is no perfect way of reading the auxiliary vector.
 ///
-/// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use
-///   `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.
-///   When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is
-///   linked to the binary - if that is not the case the behavior is undefined.
-/// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will
+/// - If [`getauxval`] is linked to the binary we use it, and otherwise it will
 ///   try to read `/proc/self/auxv`.
 /// - If that fails, this function returns an error.
 ///
 /// Note that run-time feature detection is not invoked for features that can
 /// be detected at compile-time.
 ///
-///  Note: The `std_detect_dlsym_getauxval` cargo feature is ignored on
-/// `*-linux-{gnu,musl,ohos}*` and `*-android*` targets because we can safely assume `getauxval`
-/// is linked to the binary.
+///  Note: We always directly use `getauxval` on `*-linux-{gnu,musl,ohos}*` and
+/// `*-android*` targets rather than `dlsym` it because we can safely assume
+/// `getauxval` is linked to the binary.
 /// - `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
 ///   have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
 /// - `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
@@ -71,6 +67,7 @@ pub(crate) struct AuxVec {
 ///
 /// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h
 /// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv/
+/// [`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
 pub(crate) fn auxv() -> Result<AuxVec, ()> {
     // Try to call a getauxval function.
     if let Ok(hwcap) = getauxval(AT_HWCAP) {
@@ -115,16 +112,9 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
         let _ = hwcap;
     }
 
-    #[cfg(feature = "std_detect_file_io")]
-    {
-        // If calling getauxval fails, try to read the auxiliary vector from
-        // its file:
-        auxv_from_file("/proc/self/auxv").map_err(|_| ())
-    }
-    #[cfg(not(feature = "std_detect_file_io"))]
-    {
-        Err(())
-    }
+    // If calling getauxval fails, try to read the auxiliary vector from
+    // its file:
+    auxv_from_file("/proc/self/auxv").map_err(|_| ())
 }
 
 /// Tries to read the `key` from the auxiliary vector by calling the
@@ -132,14 +122,16 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
 fn getauxval(key: usize) -> Result<usize, ()> {
     type F = unsafe extern "C" fn(libc::c_ulong) -> libc::c_ulong;
     cfg_select! {
-        all(
-            feature = "std_detect_dlsym_getauxval",
-            not(all(
+        any(
+            all(
                 target_os = "linux",
                 any(target_env = "gnu", target_env = "musl", target_env = "ohos"),
-            )),
-            not(target_os = "android"),
+            ),
+            target_os = "android",
         ) => {
+            let ffi_getauxval: F = libc::getauxval;
+        }
+        _ => {
             let ffi_getauxval: F = unsafe {
                 let ptr = libc::dlsym(libc::RTLD_DEFAULT, c"getauxval".as_ptr());
                 if ptr.is_null() {
@@ -148,23 +140,18 @@ fn getauxval(key: usize) -> Result<usize, ()> {
                 core::mem::transmute(ptr)
             };
         }
-        _ => {
-            let ffi_getauxval: F = libc::getauxval;
-        }
     }
     Ok(unsafe { ffi_getauxval(key as libc::c_ulong) as usize })
 }
 
 /// Tries to read the auxiliary vector from the `file`. If this fails, this
 /// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
 pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, alloc::string::String> {
     let file = super::read_file(file)?;
     auxv_from_file_bytes(&file)
 }
 
 /// Read auxiliary vector from a slice of bytes.
-#[cfg(feature = "std_detect_file_io")]
 pub(super) fn auxv_from_file_bytes(bytes: &[u8]) -> Result<AuxVec, alloc::string::String> {
     // See <https://github.com/torvalds/linux/blob/v5.15/include/uapi/linux/auxvec.h>.
     //
@@ -181,7 +168,6 @@ pub(super) fn auxv_from_file_bytes(bytes: &[u8]) -> Result<AuxVec, alloc::string
 
 /// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
 /// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, alloc::string::String> {
     // Targets with only AT_HWCAP:
     #[cfg(any(
diff --git a/library/std_detect/src/detect/os/linux/auxvec/tests.rs b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
index 631a3e5e9ef1..88f0d6d49337 100644
--- a/library/std_detect/src/detect/os/linux/auxvec/tests.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
@@ -41,7 +41,6 @@ fn auxv_dump() {
     }
 }
 
-#[cfg(feature = "std_detect_file_io")]
 cfg_select! {
     target_arch = "arm" => {
         // The tests below can be executed under qemu, where we do not have access to the test
@@ -86,7 +85,6 @@ cfg_select! {
 }
 
 #[test]
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_dump_procfs() {
     if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
         println!("{:?}", auxvec);
@@ -103,7 +101,6 @@ fn auxv_dump_procfs() {
     target_arch = "s390x",
 ))]
 #[test]
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_crate_procfs() {
     if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
         assert_eq!(auxv().unwrap(), procfs_auxv);
diff --git a/library/std_detect/src/detect/os/linux/mod.rs b/library/std_detect/src/detect/os/linux/mod.rs
index 5273c16c0893..aec94f963f5c 100644
--- a/library/std_detect/src/detect/os/linux/mod.rs
+++ b/library/std_detect/src/detect/os/linux/mod.rs
@@ -1,11 +1,9 @@
 //! Run-time feature detection on Linux
-//!
-#[cfg(feature = "std_detect_file_io")]
+
 use alloc::vec::Vec;
 
 mod auxvec;
 
-#[cfg(feature = "std_detect_file_io")]
 fn read_file(orig_path: &str) -> Result<Vec<u8>, alloc::string::String> {
     use alloc::format;
 
diff --git a/library/std_detect/src/lib.rs b/library/std_detect/src/lib.rs
index 73e2f5dd9644..5e1d21bbfd17 100644
--- a/library/std_detect/src/lib.rs
+++ b/library/std_detect/src/lib.rs
@@ -27,8 +27,7 @@
 extern crate std;
 
 // rust-lang/rust#83888: removing `extern crate` gives an error that `vec_spare>
-#[cfg_attr(feature = "std_detect_file_io", allow(unused_extern_crates))]
-#[cfg(feature = "std_detect_file_io")]
+#[allow(unused_extern_crates)]
 extern crate alloc;
 
 #[doc(hidden)]
diff --git a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
index da931bdf508f..7743e52f4fe1 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
@@ -961,7 +961,7 @@ pub fn vbcaxq_u64(a: uint64x2_t, b: uint64x2_t, c: uint64x2_t) -> uint64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcadd_rot270_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -979,7 +979,7 @@ pub fn vcadd_rot270_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcaddq_rot270_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -1045,7 +1045,7 @@ pub fn vcaddq_rot270_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcadd_rot90_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -1063,7 +1063,7 @@ pub fn vcadd_rot90_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcaddq_rot90_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -1501,7 +1501,7 @@ pub fn vceqh_f16(a: f16, b: f16) -> u16 {
 #[inline]
 #[cfg_attr(test, assert_instr(fcmeq))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
@@ -1512,7 +1512,7 @@ pub fn vceqz_f16(a: float16x4_t) -> uint16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcmeq))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
@@ -2837,7 +2837,7 @@ pub fn vcltzh_f16(a: f16) -> u16 {
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
@@ -2855,7 +2855,7 @@ pub fn vcmla_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
@@ -2923,7 +2923,7 @@ pub fn vcmlaq_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> float64x2_t
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -2952,7 +2952,7 @@ pub fn vcmla_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3030,7 +3030,7 @@ pub fn vcmlaq_lane_f32<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3059,7 +3059,7 @@ pub fn vcmla_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3135,7 +3135,7 @@ pub fn vcmlaq_laneq_f32<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot180_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
@@ -3153,7 +3153,7 @@ pub fn vcmla_rot180_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot180_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
@@ -3221,7 +3221,7 @@ pub fn vcmlaq_rot180_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> floa
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot180_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3250,7 +3250,7 @@ pub fn vcmla_rot180_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot180_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3328,7 +3328,7 @@ pub fn vcmlaq_rot180_lane_f32<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot180_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3357,7 +3357,7 @@ pub fn vcmla_rot180_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot180_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3433,7 +3433,7 @@ pub fn vcmlaq_rot180_laneq_f32<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot270_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
@@ -3451,7 +3451,7 @@ pub fn vcmla_rot270_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot270_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
@@ -3519,7 +3519,7 @@ pub fn vcmlaq_rot270_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> floa
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot270_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3548,7 +3548,7 @@ pub fn vcmla_rot270_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot270_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3626,7 +3626,7 @@ pub fn vcmlaq_rot270_lane_f32<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot270_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3655,7 +3655,7 @@ pub fn vcmla_rot270_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot270_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3731,7 +3731,7 @@ pub fn vcmlaq_rot270_laneq_f32<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot90_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
@@ -3749,7 +3749,7 @@ pub fn vcmla_rot90_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float1
 #[inline]
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot90_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
@@ -3817,7 +3817,7 @@ pub fn vcmlaq_rot90_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> float
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot90_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3846,7 +3846,7 @@ pub fn vcmla_rot90_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot90_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -3924,7 +3924,7 @@ pub fn vcmlaq_rot90_lane_f32<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot90_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -3953,7 +3953,7 @@ pub fn vcmla_rot90_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fcmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_neon_fcma", issue = "117222")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot90_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -7219,7 +7219,7 @@ pub fn vcvtq_f64_u64(a: uint64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(fcvtn2))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_high_f16_f32(a: float16x4_t, b: float32x4_t) -> float16x8_t {
     vcombine_f16(a, vcvt_f16_f32(b))
@@ -7229,7 +7229,7 @@ pub fn vcvt_high_f16_f32(a: float16x4_t, b: float32x4_t) -> float16x8_t {
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(fcvtl2))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_high_f32_f16(a: float16x8_t) -> float32x4_t {
     vcvt_f32_f16(vget_high_f16(a))
@@ -7468,7 +7468,7 @@ pub fn vcvtq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvta_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
@@ -7485,7 +7485,7 @@ pub fn vcvta_s16_f16(a: float16x4_t) -> int16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtaq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
@@ -7566,7 +7566,7 @@ pub fn vcvtaq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvta_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -7583,7 +7583,7 @@ pub fn vcvta_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtaq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -8154,7 +8154,7 @@ pub fn vcvth_u64_f16(a: f16) -> u64 {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtm_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
@@ -8171,7 +8171,7 @@ pub fn vcvtm_s16_f16(a: float16x4_t) -> int16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
@@ -8252,7 +8252,7 @@ pub fn vcvtmq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtm_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -8269,7 +8269,7 @@ pub fn vcvtm_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -8502,7 +8502,7 @@ pub fn vcvtmd_u64_f64(a: f64) -> u64 {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtn_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
@@ -8519,7 +8519,7 @@ pub fn vcvtn_s16_f16(a: float16x4_t) -> int16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
@@ -8600,7 +8600,7 @@ pub fn vcvtnq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtn_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -8617,7 +8617,7 @@ pub fn vcvtn_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -8850,7 +8850,7 @@ pub fn vcvtnd_u64_f64(a: f64) -> u64 {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtp_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
@@ -8867,7 +8867,7 @@ pub fn vcvtp_s16_f16(a: float16x4_t) -> int16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtpq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
@@ -8948,7 +8948,7 @@ pub fn vcvtpq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtp_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -8965,7 +8965,7 @@ pub fn vcvtp_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtpq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -9429,7 +9429,7 @@ pub fn vcvtxd_f32_f64(a: f64) -> f32 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fdiv))]
 pub fn vdiv_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -9439,7 +9439,7 @@ pub fn vdiv_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fdiv))]
 pub fn vdivq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -10106,7 +10106,7 @@ pub fn vfma_f64(a: float64x1_t, b: float64x1_t, c: float64x1_t) -> float64x1_t {
 #[cfg_attr(test, assert_instr(fmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -10122,7 +10122,7 @@ pub fn vfma_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -10138,7 +10138,7 @@ pub fn vfma_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -10154,7 +10154,7 @@ pub fn vfmaq_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmla, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -10432,7 +10432,7 @@ pub fn vfmad_laneq_f64<const LANE: i32>(a: f64, b: f64, c: float64x2_t) -> f64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal2))]
 pub fn vfmlal_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
@@ -10450,7 +10450,7 @@ pub fn vfmlal_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float3
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal2))]
 pub fn vfmlalq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
@@ -10470,7 +10470,7 @@ pub fn vfmlalq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_lane_high_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10487,7 +10487,7 @@ pub fn vfmlal_lane_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_laneq_high_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10504,7 +10504,7 @@ pub fn vfmlal_laneq_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_lane_high_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10521,7 +10521,7 @@ pub fn vfmlalq_lane_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_laneq_high_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10538,7 +10538,7 @@ pub fn vfmlalq_laneq_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_lane_low_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10555,7 +10555,7 @@ pub fn vfmlal_lane_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_laneq_low_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10572,7 +10572,7 @@ pub fn vfmlal_laneq_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_lane_low_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10589,7 +10589,7 @@ pub fn vfmlalq_lane_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_laneq_low_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10604,7 +10604,7 @@ pub fn vfmlalq_laneq_low_f16<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal))]
 pub fn vfmlal_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
@@ -10622,7 +10622,7 @@ pub fn vfmlal_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal))]
 pub fn vfmlalq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
@@ -10640,7 +10640,7 @@ pub fn vfmlalq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float3
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl2))]
 pub fn vfmlsl_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
@@ -10658,7 +10658,7 @@ pub fn vfmlsl_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float3
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl2))]
 pub fn vfmlslq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
@@ -10678,7 +10678,7 @@ pub fn vfmlslq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_lane_high_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10695,7 +10695,7 @@ pub fn vfmlsl_lane_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_laneq_high_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10712,7 +10712,7 @@ pub fn vfmlsl_laneq_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_lane_high_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10729,7 +10729,7 @@ pub fn vfmlslq_lane_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_laneq_high_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10746,7 +10746,7 @@ pub fn vfmlslq_laneq_high_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_lane_low_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10763,7 +10763,7 @@ pub fn vfmlsl_lane_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_laneq_low_f16<const LANE: i32>(
     r: float32x2_t,
@@ -10780,7 +10780,7 @@ pub fn vfmlsl_laneq_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_lane_low_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10797,7 +10797,7 @@ pub fn vfmlslq_lane_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_laneq_low_f16<const LANE: i32>(
     r: float32x4_t,
@@ -10812,7 +10812,7 @@ pub fn vfmlslq_laneq_low_f16<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl))]
 pub fn vfmlsl_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
@@ -10830,7 +10830,7 @@ pub fn vfmlsl_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl))]
 pub fn vfmlslq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
@@ -10861,7 +10861,7 @@ pub fn vfms_f64(a: float64x1_t, b: float64x1_t, c: float64x1_t) -> float64x1_t {
 #[cfg_attr(test, assert_instr(fmls, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_lane_f16<const LANE: i32>(
     a: float16x4_t,
@@ -10877,7 +10877,7 @@ pub fn vfms_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmls, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_laneq_f16<const LANE: i32>(
     a: float16x4_t,
@@ -10893,7 +10893,7 @@ pub fn vfms_laneq_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmls, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_lane_f16<const LANE: i32>(
     a: float16x8_t,
@@ -10909,7 +10909,7 @@ pub fn vfmsq_lane_f16<const LANE: i32>(
 #[cfg_attr(test, assert_instr(fmls, LANE = 0))]
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
@@ -14739,7 +14739,7 @@ pub fn vmul_lane_f64<const LANE: i32>(a: float64x1_t, b: float64x1_t) -> float64
 #[cfg_attr(test, assert_instr(fmul, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 3);
@@ -14756,7 +14756,7 @@ pub fn vmul_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float1
 #[cfg_attr(test, assert_instr(fmul, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_laneq_f16<const LANE: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
@@ -15263,7 +15263,7 @@ pub fn vmuld_laneq_f64<const LANE: i32>(a: f64, b: float64x2_t) -> f64 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmulx))]
 pub fn vmulx_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -15280,7 +15280,7 @@ pub fn vmulx_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmulx))]
 pub fn vmulxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -15363,7 +15363,7 @@ pub fn vmulxq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[cfg_attr(test, assert_instr(fmulx, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulx_lane_f16<const LANE: i32>(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
@@ -15380,7 +15380,7 @@ pub fn vmulx_lane_f16<const LANE: i32>(a: float16x4_t, b: float16x4_t) -> float1
 #[cfg_attr(test, assert_instr(fmulx, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulx_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 3);
@@ -15397,7 +15397,7 @@ pub fn vmulx_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float
 #[cfg_attr(test, assert_instr(fmulx, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxq_lane_f16<const LANE: i32>(a: float16x8_t, b: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 2);
@@ -15427,7 +15427,7 @@ pub fn vmulxq_lane_f16<const LANE: i32>(a: float16x8_t, b: float16x4_t) -> float
 #[cfg_attr(test, assert_instr(fmulx, LANE = 0))]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxq_laneq_f16<const LANE: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
@@ -15789,7 +15789,7 @@ pub fn vpaddd_u64(a: uint64x2_t) -> u64 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(faddp))]
 pub fn vpaddq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -16008,7 +16008,7 @@ pub fn vpaddq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxp))]
 pub fn vpmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -16025,7 +16025,7 @@ pub fn vpmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxp))]
 pub fn vpmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -16042,7 +16042,7 @@ pub fn vpmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnm_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmp))]
 pub fn vpmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -16059,7 +16059,7 @@ pub fn vpmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmp))]
 pub fn vpmaxnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -16316,7 +16316,7 @@ pub fn vpmaxs_f32(a: float32x2_t) -> f32 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminp))]
 pub fn vpmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -16333,7 +16333,7 @@ pub fn vpmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminp))]
 pub fn vpminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -16350,7 +16350,7 @@ pub fn vpminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnm_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmp))]
 pub fn vpminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -16367,7 +16367,7 @@ pub fn vpminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmp))]
 pub fn vpminnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -21493,7 +21493,7 @@ pub fn vrecpxh_f16(a: f16) -> f16 {
 #[inline]
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
@@ -21504,7 +21504,7 @@ pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
 #[inline]
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
@@ -21516,7 +21516,7 @@ pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
 #[inline]
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
@@ -21527,7 +21527,7 @@ pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
 #[inline]
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
@@ -21542,7 +21542,7 @@ pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
 #[inline]
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
@@ -21553,7 +21553,7 @@ pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
 #[inline]
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
@@ -21567,7 +21567,7 @@ pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
 #[inline]
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
@@ -21578,7 +21578,7 @@ pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
 #[inline]
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
@@ -23157,7 +23157,7 @@ pub fn vrnd64z_f64(a: float64x1_t) -> float64x1_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrnd_f16(a: float16x4_t) -> float16x4_t {
@@ -23167,7 +23167,7 @@ pub fn vrnd_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrndq_f16(a: float16x8_t) -> float16x8_t {
@@ -23213,7 +23213,7 @@ pub fn vrndq_f64(a: float64x2_t) -> float64x2_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrnda_f16(a: float16x4_t) -> float16x4_t {
@@ -23223,7 +23223,7 @@ pub fn vrnda_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrndaq_f16(a: float16x8_t) -> float16x8_t {
@@ -23289,7 +23289,7 @@ pub fn vrndh_f16(a: f16) -> f16 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinti))]
 pub fn vrndi_f16(a: float16x4_t) -> float16x4_t {
@@ -23306,7 +23306,7 @@ pub fn vrndi_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndiq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinti))]
 pub fn vrndiq_f16(a: float16x8_t) -> float16x8_t {
@@ -23404,7 +23404,7 @@ pub fn vrndih_f16(a: f16) -> f16 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndm_f16(a: float16x4_t) -> float16x4_t {
@@ -23414,7 +23414,7 @@ pub fn vrndm_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndmq_f16(a: float16x8_t) -> float16x8_t {
@@ -23535,7 +23535,7 @@ pub fn vrndns_f32(a: f32) -> f32 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndp_f16(a: float16x4_t) -> float16x4_t {
@@ -23545,7 +23545,7 @@ pub fn vrndp_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndpq_f16(a: float16x8_t) -> float16x8_t {
@@ -23601,7 +23601,7 @@ pub fn vrndph_f16(a: f16) -> f16 {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndx_f16(a: float16x4_t) -> float16x4_t {
@@ -23611,7 +23611,7 @@ pub fn vrndx_f16(a: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndxq_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndxq_f16(a: float16x8_t) -> float16x8_t {
@@ -25034,7 +25034,7 @@ pub fn vsqadds_u32(a: u32, b: i32) -> u32 {
 #[inline]
 #[cfg_attr(test, assert_instr(fsqrt))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vsqrt_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_fsqrt(a) }
@@ -25044,7 +25044,7 @@ pub fn vsqrt_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[cfg_attr(test, assert_instr(fsqrt))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vsqrtq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_fsqrt(a) }
@@ -27532,7 +27532,7 @@ pub fn vtbx4_p8(a: poly8x8_t, b: poly8x8x4_t, c: uint8x8_t) -> poly8x8_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn1))]
 pub fn vtrn1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -27542,7 +27542,7 @@ pub fn vtrn1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn1))]
 pub fn vtrn1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -27768,7 +27768,7 @@ pub fn vtrn1q_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn2))]
 pub fn vtrn2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -27778,7 +27778,7 @@ pub fn vtrn2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn2))]
 pub fn vtrn2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -28309,7 +28309,7 @@ pub fn vusdotq_laneq_s32<const LANE: i32>(a: int32x4_t, b: uint8x16_t, c: int8x1
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp1))]
 pub fn vuzp1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -28319,7 +28319,7 @@ pub fn vuzp1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp1))]
 pub fn vuzp1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -28545,7 +28545,7 @@ pub fn vuzp1q_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp2))]
 pub fn vuzp2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -28555,7 +28555,7 @@ pub fn vuzp2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp2))]
 pub fn vuzp2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -28799,7 +28799,7 @@ pub fn vxarq_u64<const IMM6: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip1))]
 pub fn vzip1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -28809,7 +28809,7 @@ pub fn vzip1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip1))]
 pub fn vzip1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
@@ -29035,7 +29035,7 @@ pub fn vzip1q_p64(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip2))]
 pub fn vzip2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
@@ -29045,7 +29045,7 @@ pub fn vzip2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f16)"]
 #[inline]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip2))]
 pub fn vzip2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index 314965cc208f..0aeb740efcd0 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
@@ -819,7 +819,14 @@ pub fn vabaq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_t {
     assert_instr(fabd)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vabd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -842,7 +849,14 @@ pub fn vabd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fabd)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vabdq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -1406,7 +1420,14 @@ pub fn vabdl_u32(a: uint32x2_t, b: uint32x2_t) -> uint64x2_t {
     assert_instr(fabs)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vabs_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_fabs(a) }
@@ -1421,7 +1442,14 @@ pub fn vabs_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(fabs)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vabsq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_fabs(a) }
@@ -1643,7 +1671,14 @@ pub fn vabsh_f16(a: f16) -> f16 {
     assert_instr(fadd)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_add(a, b) }
@@ -1658,7 +1693,14 @@ pub fn vadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fadd)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vaddq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_add(a, b) }
@@ -3835,7 +3877,14 @@ pub fn vbicq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(bsl)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vbsl_f16(a: uint16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     let not = int16x4_t::splat(-1);
@@ -3856,7 +3905,14 @@ pub fn vbsl_f16(a: uint16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(bsl)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vbslq_f16(a: uint16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     let not = int16x8_t::splat(-1);
@@ -4471,7 +4527,14 @@ pub fn vbslq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_t {
     assert_instr(facge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcage_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -4494,7 +4557,14 @@ pub fn vcage_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(facge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcageq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -4575,7 +4645,14 @@ pub fn vcageq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
     assert_instr(facgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcagt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
@@ -4598,7 +4675,14 @@ pub fn vcagt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(facgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcagtq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
@@ -4679,7 +4763,14 @@ pub fn vcagtq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
     assert_instr(facge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcale_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     vcage_f16(b, a)
@@ -4694,7 +4785,14 @@ pub fn vcale_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(facge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcaleq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     vcageq_f16(b, a)
@@ -4751,7 +4849,14 @@ pub fn vcaleq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
     assert_instr(facgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcalt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     vcagt_f16(b, a)
@@ -4766,7 +4871,14 @@ pub fn vcalt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(facgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcaltq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     vcagtq_f16(b, a)
@@ -4823,7 +4935,14 @@ pub fn vcaltq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
     assert_instr(fcmeq)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vceq_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_eq(a, b) }
@@ -4838,7 +4957,14 @@ pub fn vceq_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(fcmeq)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_eq(a, b) }
@@ -5189,7 +5315,14 @@ pub fn vceqq_p8(a: poly8x16_t, b: poly8x16_t) -> uint8x16_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcge_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_ge(a, b) }
@@ -5204,7 +5337,14 @@ pub fn vcge_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgeq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_ge(a, b) }
@@ -5513,7 +5653,14 @@ pub fn vcgeq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgez_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
@@ -5529,7 +5676,14 @@ pub fn vcgez_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgezq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
@@ -5545,7 +5699,14 @@ pub fn vcgezq_f16(a: float16x8_t) -> uint16x8_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_gt(a, b) }
@@ -5560,7 +5721,14 @@ pub fn vcgt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_gt(a, b) }
@@ -5869,7 +6037,14 @@ pub fn vcgtq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
@@ -5885,7 +6060,14 @@ pub fn vcgtz_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
@@ -5901,7 +6083,14 @@ pub fn vcgtzq_f16(a: float16x8_t) -> uint16x8_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcle_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_le(a, b) }
@@ -5916,7 +6105,14 @@ pub fn vcle_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(fcmge)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcleq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_le(a, b) }
@@ -6225,7 +6421,14 @@ pub fn vcleq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fcmle)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vclez_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
@@ -6241,7 +6444,14 @@ pub fn vclez_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(fcmle)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vclezq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
@@ -6557,7 +6767,14 @@ pub fn vclsq_u32(a: uint32x4_t) -> int32x4_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vclt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_lt(a, b) }
@@ -6572,7 +6789,14 @@ pub fn vclt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     assert_instr(fcmgt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_lt(a, b) }
@@ -6881,7 +7105,14 @@ pub fn vcltq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fcmlt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
@@ -6897,7 +7128,14 @@ pub fn vcltz_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(fcmlt)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
@@ -7572,7 +7810,14 @@ pub fn vcntq_p8(a: poly8x16_t) -> poly8x16_t {
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vcombine_f16(a: float16x4_t, b: float16x4_t) -> float16x8_t {
@@ -7794,7 +8039,14 @@ pub fn vcombine_p64(a: poly64x1_t, b: poly64x1_t) -> poly64x2_t {
     assert_instr(nop)
 )]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcreate_f16(a: u64) -> float16x4_t {
     unsafe { transmute(a) }
@@ -7811,7 +8063,14 @@ pub fn vcreate_f16(a: u64) -> float16x4_t {
     assert_instr(nop)
 )]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcreate_f16(a: u64) -> float16x4_t {
     unsafe {
@@ -8316,7 +8575,14 @@ pub fn vcreate_p64(a: u64) -> poly64x1_t {
     assert_instr(fcvtn)
 )]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_f32(a: float32x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
@@ -8331,7 +8597,14 @@ pub fn vcvt_f16_f32(a: float32x4_t) -> float16x4_t {
     assert_instr(scvtf)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_s16(a: int16x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
@@ -8346,7 +8619,14 @@ pub fn vcvt_f16_s16(a: int16x4_t) -> float16x4_t {
     assert_instr(scvtf)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_f16_s16(a: int16x8_t) -> float16x8_t {
     unsafe { simd_cast(a) }
@@ -8361,7 +8641,14 @@ pub fn vcvtq_f16_s16(a: int16x8_t) -> float16x8_t {
     assert_instr(ucvtf)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_u16(a: uint16x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
@@ -8376,7 +8663,14 @@ pub fn vcvt_f16_u16(a: uint16x4_t) -> float16x4_t {
     assert_instr(ucvtf)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_f16_u16(a: uint16x8_t) -> float16x8_t {
     unsafe { simd_cast(a) }
@@ -8392,7 +8686,14 @@ pub fn vcvtq_f16_u16(a: uint16x8_t) -> float16x8_t {
     assert_instr(fcvtl)
 )]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f32_f16(a: float16x4_t) -> float32x4_t {
     unsafe { simd_cast(a) }
@@ -8492,7 +8793,14 @@ pub fn vcvtq_f32_u32(a: uint32x4_t) -> float32x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_f16_s16<const N: i32>(a: int16x4_t) -> float16x4_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8520,7 +8828,14 @@ pub fn vcvt_n_f16_s16<const N: i32>(a: int16x4_t) -> float16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_f16_s16<const N: i32>(a: int16x8_t) -> float16x8_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8548,7 +8863,14 @@ pub fn vcvtq_n_f16_s16<const N: i32>(a: int16x8_t) -> float16x8_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_f16_u16<const N: i32>(a: uint16x4_t) -> float16x4_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8576,7 +8898,14 @@ pub fn vcvt_n_f16_u16<const N: i32>(a: uint16x4_t) -> float16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_f16_u16<const N: i32>(a: uint16x8_t) -> float16x8_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8756,7 +9085,14 @@ pub fn vcvtq_n_f32_u32<const N: i32>(a: uint32x4_t) -> float32x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_s16_f16<const N: i32>(a: float16x4_t) -> int16x4_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8784,7 +9120,14 @@ pub fn vcvt_n_s16_f16<const N: i32>(a: float16x4_t) -> int16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_s16_f16<const N: i32>(a: float16x8_t) -> int16x8_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8888,7 +9231,14 @@ pub fn vcvtq_n_s32_f32<const N: i32>(a: float32x4_t) -> int32x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_u16_f16<const N: i32>(a: float16x4_t) -> uint16x4_t {
     static_assert!(N >= 1 && N <= 16);
@@ -8916,7 +9266,14 @@ pub fn vcvt_n_u16_f16<const N: i32>(a: float16x4_t) -> uint16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_u16_f16<const N: i32>(a: float16x8_t) -> uint16x8_t {
     static_assert!(N >= 1 && N <= 16);
@@ -9019,7 +9376,14 @@ pub fn vcvtq_n_u32_f32<const N: i32>(a: float32x4_t) -> uint32x4_t {
     assert_instr(fcvtzs)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe { simd_cast(a) }
@@ -9034,7 +9398,14 @@ pub fn vcvt_s16_f16(a: float16x4_t) -> int16x4_t {
     assert_instr(fcvtzs)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe { simd_cast(a) }
@@ -9107,7 +9478,14 @@ pub fn vcvtq_s32_f32(a: float32x4_t) -> int32x4_t {
     assert_instr(fcvtzu)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe { simd_cast(a) }
@@ -9122,7 +9500,14 @@ pub fn vcvt_u16_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(fcvtzu)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe { simd_cast(a) }
@@ -9559,7 +9944,14 @@ pub fn vdotq_u32(a: uint32x4_t, b: uint8x16_t, c: uint8x16_t) -> uint32x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vdup_lane_f16<const N: i32>(a: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 2);
@@ -9577,7 +9969,14 @@ pub fn vdup_lane_f16<const N: i32>(a: float16x4_t) -> float16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vdupq_lane_f16<const N: i32>(a: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 2);
@@ -10124,7 +10523,14 @@ pub fn vdup_lane_u64<const N: i32>(a: uint64x1_t) -> uint64x1_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vdup_laneq_f16<const N: i32>(a: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 3);
@@ -10142,7 +10548,14 @@ pub fn vdup_laneq_f16<const N: i32>(a: float16x8_t) -> float16x4_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vdupq_laneq_f16<const N: i32>(a: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 3);
@@ -11652,7 +12065,14 @@ pub fn veorq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 )]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vext_f16<const N: i32>(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 2);
@@ -12024,7 +12444,14 @@ pub fn vextq_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 )]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vextq_f16<const N: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 3);
@@ -12605,7 +13032,14 @@ pub fn vextq_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
     assert_instr(fmla)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe { simd_fma(b, c, a) }
@@ -12620,7 +13054,14 @@ pub fn vfma_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     assert_instr(fmla)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe { simd_fma(b, c, a) }
@@ -12720,7 +13161,14 @@ pub fn vfmaq_n_f32(a: float32x4_t, b: float32x4_t, c: f32) -> float32x4_t {
     assert_instr(fmls)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe {
@@ -12739,7 +13187,14 @@ pub fn vfms_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     assert_instr(fmls)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe {
@@ -12843,7 +13298,14 @@ pub fn vfmsq_n_f32(a: float32x4_t, b: float32x4_t, c: f32) -> float32x4_t {
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vget_high_f16(a: float16x8_t) -> float16x4_t {
@@ -12855,7 +13317,14 @@ pub fn vget_high_f16(a: float16x8_t) -> float16x4_t {
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "fp16"))]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vget_low_f16(a: float16x8_t) -> float16x4_t {
@@ -19431,7 +19900,7 @@ unsafe fn vld1q_v8i16<const ALIGN: i32>(a: *const i8) -> int16x8_t {
 #[target_feature(enable = "neon,v7")]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")]
 #[cfg(not(target_arch = "arm64ec"))]
 unsafe fn vld1_v4f16(a: *const i8, b: i32) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -19445,7 +19914,7 @@ unsafe fn vld1_v4f16(a: *const i8, b: i32) -> float16x4_t {
 #[target_feature(enable = "neon,v7")]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")]
 #[cfg(not(target_arch = "arm64ec"))]
 unsafe fn vld1q_v8f16(a: *const i8, b: i32) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -27522,7 +27991,14 @@ pub unsafe fn vldrq_p128(a: *const p128) -> p128 {
     assert_instr(fmax)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -27545,7 +28021,14 @@ pub fn vmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fmax)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -27914,7 +28397,14 @@ pub fn vmaxq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fmaxnm)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_fmax(a, b) }
@@ -27929,7 +28419,14 @@ pub fn vmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fmaxnm)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_fmax(a, b) }
@@ -27986,7 +28483,14 @@ pub fn vmaxnmq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
     assert_instr(fmin)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -28009,7 +28513,14 @@ pub fn vmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fmin)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -28378,7 +28889,14 @@ pub fn vminq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(fminnm)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_fmin(a, b) }
@@ -28393,7 +28911,14 @@ pub fn vminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fminnm)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vminnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_fmin(a, b) }
@@ -32322,7 +32847,14 @@ pub fn vmovn_u64(a: uint64x2_t) -> uint32x2_t {
     assert_instr(fmul)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_mul(a, b) }
@@ -32337,7 +32869,14 @@ pub fn vmul_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fmul)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_mul(a, b) }
@@ -32395,7 +32934,14 @@ pub fn vmulq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
 )]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_lane_f16<const LANE: i32>(a: float16x4_t, v: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
@@ -32417,7 +32963,14 @@ pub fn vmul_lane_f16<const LANE: i32>(a: float16x4_t, v: float16x4_t) -> float16
 )]
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_lane_f16<const LANE: i32>(a: float16x8_t, v: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 2);
@@ -34382,7 +34935,14 @@ pub fn vmvnq_u8(a: uint8x16_t) -> uint8x16_t {
     assert_instr(fneg)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vneg_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_neg(a) }
@@ -34397,7 +34957,14 @@ pub fn vneg_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(fneg)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vnegq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_neg(a) }
@@ -35628,7 +36195,14 @@ pub fn vpadalq_u32(a: uint64x2_t, b: uint32x4_t) -> uint64x2_t {
     assert_instr(faddp)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vpadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -41703,7 +42277,14 @@ pub fn vraddhn_u64(a: uint64x2_t, b: uint64x2_t) -> uint32x2_t {
     assert_instr(frecpe)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpe_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -41726,7 +42307,14 @@ pub fn vrecpe_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(frecpe)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpeq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -41865,7 +42453,14 @@ pub fn vrecpeq_u32(a: uint32x4_t) -> uint32x4_t {
     assert_instr(frecps)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecps_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -41888,7 +42483,14 @@ pub fn vrecps_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(frecps)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpsq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -41970,7 +42572,14 @@ pub fn vrecpsq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     unsafe { transmute(a) }
@@ -41986,7 +42595,14 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42006,7 +42622,14 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     unsafe { transmute(a) }
@@ -42022,7 +42645,14 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42042,7 +42672,14 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe { transmute(a) }
@@ -42058,7 +42695,14 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42078,7 +42722,14 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     unsafe { transmute(a) }
@@ -42094,7 +42745,14 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42114,7 +42772,14 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
@@ -42130,7 +42795,14 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42147,7 +42819,14 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     unsafe { transmute(a) }
@@ -42163,7 +42842,14 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42183,7 +42869,14 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe { transmute(a) }
@@ -42199,7 +42892,14 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42219,7 +42919,14 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     unsafe { transmute(a) }
@@ -42235,7 +42942,14 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42255,7 +42969,14 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     unsafe { transmute(a) }
@@ -42271,7 +42992,14 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42288,7 +43016,14 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     unsafe { transmute(a) }
@@ -42304,7 +43039,14 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42324,7 +43066,14 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     unsafe { transmute(a) }
@@ -42340,7 +43089,14 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42360,7 +43116,14 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     unsafe { transmute(a) }
@@ -42376,7 +43139,14 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42396,7 +43166,14 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     unsafe { transmute(a) }
@@ -42412,7 +43189,14 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42436,7 +43220,14 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe { transmute(a) }
@@ -42452,7 +43243,14 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42472,7 +43270,14 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     unsafe { transmute(a) }
@@ -42488,7 +43293,14 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42508,7 +43320,14 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     unsafe { transmute(a) }
@@ -42524,7 +43343,14 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42544,7 +43370,14 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     unsafe { transmute(a) }
@@ -42560,7 +43393,14 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42584,7 +43424,14 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe { transmute(a) }
@@ -42600,7 +43447,14 @@ pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42620,7 +43474,14 @@ pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
@@ -42636,7 +43497,14 @@ pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42656,7 +43524,14 @@ pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     unsafe { transmute(a) }
@@ -42672,7 +43547,14 @@ pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42692,7 +43574,14 @@ pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     unsafe { transmute(a) }
@@ -42708,7 +43597,14 @@ pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42732,7 +43628,14 @@ pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     unsafe { transmute(a) }
@@ -42748,7 +43651,14 @@ pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42768,7 +43678,14 @@ pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -42784,7 +43701,14 @@ pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -42804,7 +43728,14 @@ pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -42820,7 +43751,14 @@ pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42840,7 +43778,14 @@ pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -42856,7 +43801,14 @@ pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42876,7 +43828,14 @@ pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -42892,7 +43851,14 @@ pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     let a: int8x16_t =
@@ -42913,7 +43879,14 @@ pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -42929,7 +43902,14 @@ pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -42949,7 +43929,14 @@ pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -42965,7 +43952,14 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -42985,7 +43979,14 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43001,7 +44002,14 @@ pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -43021,7 +44029,14 @@ pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43037,7 +44052,14 @@ pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -43057,7 +44079,14 @@ pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43073,7 +44102,14 @@ pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     unsafe {
@@ -43092,7 +44128,14 @@ pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43108,7 +44151,14 @@ pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -43128,7 +44178,14 @@ pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43144,7 +44201,14 @@ pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43164,7 +44228,14 @@ pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43180,7 +44251,14 @@ pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     let a: uint8x16_t =
@@ -43201,7 +44279,14 @@ pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43217,7 +44302,14 @@ pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -43237,7 +44329,14 @@ pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43253,7 +44352,14 @@ pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43273,7 +44379,14 @@ pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43289,7 +44402,14 @@ pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -43309,7 +44429,14 @@ pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43325,7 +44452,14 @@ pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -43345,7 +44479,14 @@ pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43361,7 +44502,14 @@ pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     unsafe {
@@ -43380,7 +44528,14 @@ pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43396,7 +44551,14 @@ pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -43416,7 +44578,14 @@ pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43432,7 +44601,14 @@ pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43452,7 +44628,14 @@ pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43468,7 +44651,14 @@ pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     let a: poly8x16_t =
@@ -43489,7 +44679,14 @@ pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43505,7 +44702,14 @@ pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -43525,7 +44729,14 @@ pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43541,7 +44752,14 @@ pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43561,7 +44779,14 @@ pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43577,7 +44802,14 @@ pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     unsafe {
@@ -43596,7 +44828,14 @@ pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     unsafe { transmute(a) }
@@ -43612,7 +44851,14 @@ pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -43629,7 +44875,14 @@ pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     unsafe { transmute(a) }
@@ -43645,7 +44898,14 @@ pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43662,7 +44922,14 @@ pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
@@ -43678,7 +44945,14 @@ pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43698,7 +44972,14 @@ pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -43714,7 +44995,14 @@ pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     unsafe {
@@ -43733,7 +45021,14 @@ pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -43749,7 +45044,14 @@ pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     assert_instr(nop)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -57746,7 +59048,14 @@ pub fn vrev64q_u8(a: uint8x16_t) -> uint8x16_t {
     assert_instr(rev64)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrev64_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) }
@@ -57761,7 +59070,14 @@ pub fn vrev64_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(rev64)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrev64q_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, a, [3, 2, 1, 0, 7, 6, 5, 4]) }
@@ -58124,7 +59440,14 @@ pub fn vrhaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     assert_instr(frintn)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -58146,7 +59469,14 @@ pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(frintn)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrndnq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -59230,7 +60560,14 @@ pub fn vrshrn_n_u64<const N: i32>(a: uint64x2_t) -> uint32x2_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(frsqrte)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrte_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -59253,7 +60590,14 @@ pub fn vrsqrte_f16(a: float16x4_t) -> float16x4_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(frsqrte)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrteq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -59392,7 +60736,14 @@ pub fn vrsqrteq_u32(a: uint32x4_t) -> uint32x4_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(frsqrts)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrts_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -59415,7 +60766,14 @@ pub fn vrsqrts_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(frsqrts)
 )]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrtsq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -66926,7 +68284,7 @@ unsafe fn vst1q_v8i16<const ALIGN: i32>(addr: *const i8, val: int16x8_t) {
 #[cfg(target_arch = "arm")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 unsafe fn vst1_v4f16(addr: *const i8, val: float16x4_t, align: i32) {
@@ -66944,7 +68302,7 @@ unsafe fn vst1_v4f16(addr: *const i8, val: float16x4_t, align: i32) {
 #[cfg(target_arch = "arm")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 unsafe fn vst1q_v8f16(addr: *const i8, val: float16x8_t, align: i32) {
@@ -70962,7 +72320,14 @@ pub unsafe fn vstrq_p128(a: *mut p128, b: p128) {
     assert_instr(fsub)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vsub_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_sub(a, b) }
@@ -70977,7 +72342,14 @@ pub fn vsub_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(fsub)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vsubq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_sub(a, b) }
@@ -72910,7 +74282,14 @@ pub fn vtbx4_p8(a: poly8x8_t, b: poly8x8x4_t, c: uint8x8_t) -> poly8x8_t {
     assert_instr(trn2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vtrn_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
@@ -72933,7 +74312,14 @@ pub fn vtrn_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     assert_instr(trn2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vtrnq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
@@ -74112,7 +75498,14 @@ pub fn vusmmlaq_s32(a: int32x4_t, b: uint8x16_t, c: int8x16_t) -> int32x4_t {
     assert_instr(uzp2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vuzp_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
@@ -74135,7 +75528,14 @@ pub fn vuzp_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     assert_instr(uzp2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vuzpq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
@@ -74704,7 +76104,14 @@ pub fn vuzpq_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8x2_t {
     assert_instr(zip2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vzip_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
@@ -74727,7 +76134,14 @@ pub fn vzip_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     assert_instr(zip2)
 )]
 #[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vzipq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
index fbd1967c544a..809892e0bfd4 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
@@ -104,7 +104,8 @@ types! {
 }
 
 types! {
-    #![unstable(feature = "stdarch_neon_f16", issue = "136306")]
+    #![cfg_attr(not(target_arch = "arm"), stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION"))]
+    #![cfg_attr(target_arch = "arm", unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800"))]
 
     /// Arm-specific 64-bit wide vector of four packed `f16`.
     pub struct float16x4_t(4 x pub(crate) f16);
@@ -747,19 +748,40 @@ pub struct uint32x4x4_t(
 /// Arm-specific type containing two `float16x4_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x4x2_t(pub float16x4_t, pub float16x4_t);
 
 /// Arm-specific type containing three `float16x4_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x4x3_t(pub float16x4_t, pub float16x4_t, pub float16x4_t);
 
 /// Arm-specific type containing four `float16x4_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x4x4_t(
     pub float16x4_t,
     pub float16x4_t,
@@ -770,19 +792,40 @@ pub struct float16x4x4_t(
 /// Arm-specific type containing two `float16x8_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x8x2_t(pub float16x8_t, pub float16x8_t);
 
 /// Arm-specific type containing three `float16x8_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x8x3_t(pub float16x8_t, pub float16x8_t, pub float16x8_t);
 
 /// Arm-specific type containing four `float16x8_t` vectors.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg_attr(
+    not(target_arch = "arm"),
+    stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")
+)]
+#[cfg_attr(
+    target_arch = "arm",
+    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
+)]
 pub struct float16x8x4_t(
     pub float16x8_t,
     pub float16x8_t,
diff --git a/library/stdarch/crates/core_arch/src/x86/abm.rs b/library/stdarch/crates/core_arch/src/x86/abm.rs
index b73076361d86..078c0c5980e4 100644
--- a/library/stdarch/crates/core_arch/src/x86/abm.rs
+++ b/library/stdarch/crates/core_arch/src/x86/abm.rs
@@ -54,12 +54,12 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "lzcnt")]
-    const unsafe fn test_lzcnt_u32() {
+    const fn test_lzcnt_u32() {
         assert_eq!(_lzcnt_u32(0b0101_1010), 25);
     }
 
     #[simd_test(enable = "popcnt")]
-    const unsafe fn test_popcnt32() {
+    const fn test_popcnt32() {
         assert_eq!(_popcnt32(0b0101_1010), 4);
     }
 }
diff --git a/library/stdarch/crates/core_arch/src/x86/aes.rs b/library/stdarch/crates/core_arch/src/x86/aes.rs
index be01d6ddd8d0..d07ab4dc2a01 100644
--- a/library/stdarch/crates/core_arch/src/x86/aes.rs
+++ b/library/stdarch/crates/core_arch/src/x86/aes.rs
@@ -112,7 +112,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aesdec_si128() {
+    fn test_mm_aesdec_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664949.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let k = _mm_set_epi64x(0x1133557799bbddff, 0x0022446688aaccee);
@@ -122,7 +122,7 @@ mod tests {
     }
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aesdeclast_si128() {
+    fn test_mm_aesdeclast_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714178.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let k = _mm_set_epi64x(0x1133557799bbddff, 0x0022446688aaccee);
@@ -132,7 +132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aesenc_si128() {
+    fn test_mm_aesenc_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664810.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let k = _mm_set_epi64x(0x1133557799bbddff, 0x0022446688aaccee);
@@ -142,7 +142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aesenclast_si128() {
+    fn test_mm_aesenclast_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714136.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let k = _mm_set_epi64x(0x1133557799bbddff, 0x0022446688aaccee);
@@ -152,7 +152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aesimc_si128() {
+    fn test_mm_aesimc_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714195.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let e = _mm_set_epi64x(0xc66c82284ee40aa0, 0x6633441122770055);
@@ -161,7 +161,7 @@ mod tests {
     }
 
     #[simd_test(enable = "aes")]
-    unsafe fn test_mm_aeskeygenassist_si128() {
+    fn test_mm_aeskeygenassist_si128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714138.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let e = _mm_set_epi64x(0x857c266b7c266e85, 0xeac4eea9c4eeacea);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx.rs b/library/stdarch/crates/core_arch/src/x86/avx.rs
index 6d4f79fc7cfe..e0e01ae6d034 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx.rs
@@ -2946,7 +2946,11 @@ pub const fn _mm256_castsi256_si128(a: __m256i) -> __m128i {
 }
 
 /// Casts vector of type __m128 to type __m256;
-/// the upper 128 bits of the result are undefined.
+/// the upper 128 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castps128_ps256)
 #[inline]
@@ -2960,7 +2964,11 @@ pub const fn _mm256_castps128_ps256(a: __m128) -> __m256 {
 }
 
 /// Casts vector of type __m128d to type __m256d;
-/// the upper 128 bits of the result are undefined.
+/// the upper 128 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castpd128_pd256)
 #[inline]
@@ -2974,7 +2982,11 @@ pub const fn _mm256_castpd128_pd256(a: __m128d) -> __m256d {
 }
 
 /// Casts vector of type __m128i to type __m256i;
-/// the upper 128 bits of the result are undefined.
+/// the upper 128 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_castsi128_si256)
 #[inline]
@@ -3364,7 +3376,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_add_pd() {
+    const fn test_mm256_add_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_add_pd(a, b);
@@ -3373,7 +3385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_add_ps() {
+    const fn test_mm256_add_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm256_add_ps(a, b);
@@ -3382,7 +3394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_and_pd() {
+    const fn test_mm256_and_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(0.6);
         let r = _mm256_and_pd(a, b);
@@ -3391,7 +3403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_and_ps() {
+    const fn test_mm256_and_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(0.6);
         let r = _mm256_and_ps(a, b);
@@ -3400,7 +3412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_or_pd() {
+    const fn test_mm256_or_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(0.6);
         let r = _mm256_or_pd(a, b);
@@ -3409,7 +3421,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_or_ps() {
+    const fn test_mm256_or_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(0.6);
         let r = _mm256_or_ps(a, b);
@@ -3418,7 +3430,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_shuffle_pd() {
+    const fn test_mm256_shuffle_pd() {
         let a = _mm256_setr_pd(1., 4., 5., 8.);
         let b = _mm256_setr_pd(2., 3., 6., 7.);
         let r = _mm256_shuffle_pd::<0b11_11_11_11>(a, b);
@@ -3427,7 +3439,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_shuffle_ps() {
+    const fn test_mm256_shuffle_ps() {
         let a = _mm256_setr_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_setr_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_shuffle_ps::<0b00_00_11_11>(a, b);
@@ -3436,7 +3448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_andnot_pd() {
+    const fn test_mm256_andnot_pd() {
         let a = _mm256_set1_pd(0.);
         let b = _mm256_set1_pd(0.6);
         let r = _mm256_andnot_pd(a, b);
@@ -3444,7 +3456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_andnot_ps() {
+    const fn test_mm256_andnot_ps() {
         let a = _mm256_set1_ps(0.);
         let b = _mm256_set1_ps(0.6);
         let r = _mm256_andnot_ps(a, b);
@@ -3556,7 +3568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_mul_pd() {
+    const fn test_mm256_mul_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_mul_pd(a, b);
@@ -3565,7 +3577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_mul_ps() {
+    const fn test_mm256_mul_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm256_mul_ps(a, b);
@@ -3574,7 +3586,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_addsub_pd() {
+    const fn test_mm256_addsub_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_addsub_pd(a, b);
@@ -3583,7 +3595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_addsub_ps() {
+    const fn test_mm256_addsub_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 1., 2., 3., 4.);
         let b = _mm256_setr_ps(5., 6., 7., 8., 5., 6., 7., 8.);
         let r = _mm256_addsub_ps(a, b);
@@ -3592,7 +3604,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_sub_pd() {
+    const fn test_mm256_sub_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_sub_pd(a, b);
@@ -3601,7 +3613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_sub_ps() {
+    const fn test_mm256_sub_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., -1., -2., -3., -4.);
         let b = _mm256_setr_ps(5., 6., 7., 8., 3., 2., 1., 0.);
         let r = _mm256_sub_ps(a, b);
@@ -3610,7 +3622,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_round_pd() {
+    fn test_mm256_round_pd() {
         let a = _mm256_setr_pd(1.55, 2.2, 3.99, -1.2);
         let result_closest = _mm256_round_pd::<0b0000>(a);
         let result_down = _mm256_round_pd::<0b0001>(a);
@@ -3624,7 +3636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_floor_pd() {
+    const fn test_mm256_floor_pd() {
         let a = _mm256_setr_pd(1.55, 2.2, 3.99, -1.2);
         let result_down = _mm256_floor_pd(a);
         let expected_down = _mm256_setr_pd(1., 2., 3., -2.);
@@ -3632,7 +3644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_ceil_pd() {
+    const fn test_mm256_ceil_pd() {
         let a = _mm256_setr_pd(1.55, 2.2, 3.99, -1.2);
         let result_up = _mm256_ceil_pd(a);
         let expected_up = _mm256_setr_pd(2., 3., 4., -1.);
@@ -3640,7 +3652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_round_ps() {
+    fn test_mm256_round_ps() {
         let a = _mm256_setr_ps(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_closest = _mm256_round_ps::<0b0000>(a);
         let result_down = _mm256_round_ps::<0b0001>(a);
@@ -3654,7 +3666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_floor_ps() {
+    const fn test_mm256_floor_ps() {
         let a = _mm256_setr_ps(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_down = _mm256_floor_ps(a);
         let expected_down = _mm256_setr_ps(1., 2., 3., -2., 1., 2., 3., -2.);
@@ -3662,7 +3674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_ceil_ps() {
+    const fn test_mm256_ceil_ps() {
         let a = _mm256_setr_ps(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_up = _mm256_ceil_ps(a);
         let expected_up = _mm256_setr_ps(2., 3., 4., -1., 2., 3., 4., -1.);
@@ -3670,7 +3682,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_sqrt_pd() {
+    fn test_mm256_sqrt_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let r = _mm256_sqrt_pd(a);
         let e = _mm256_setr_pd(2., 3., 4., 5.);
@@ -3678,7 +3690,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_sqrt_ps() {
+    fn test_mm256_sqrt_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let r = _mm256_sqrt_ps(a);
         let e = _mm256_setr_ps(2., 3., 4., 5., 2., 3., 4., 5.);
@@ -3686,7 +3698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_div_ps() {
+    const fn test_mm256_div_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_div_ps(a, b);
@@ -3695,7 +3707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_div_pd() {
+    const fn test_mm256_div_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_div_pd(a, b);
@@ -3704,7 +3716,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_blend_pd() {
+    const fn test_mm256_blend_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_blend_pd::<0x0>(a, b);
@@ -3716,7 +3728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_blend_ps() {
+    const fn test_mm256_blend_ps() {
         let a = _mm256_setr_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_setr_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_blend_ps::<0x0>(a, b);
@@ -3728,7 +3740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_blendv_pd() {
+    const fn test_mm256_blendv_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_setr_pd(4., 3., 2., 5.);
         let c = _mm256_setr_pd(0., 0., !0 as f64, !0 as f64);
@@ -3738,7 +3750,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_blendv_ps() {
+    const fn test_mm256_blendv_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         #[rustfmt::skip]
@@ -3751,7 +3763,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_dp_ps() {
+    fn test_mm256_dp_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_dp_ps::<0xFF>(a, b);
@@ -3760,7 +3772,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_hadd_pd() {
+    const fn test_mm256_hadd_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_hadd_pd(a, b);
@@ -3775,7 +3787,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_hadd_ps() {
+    const fn test_mm256_hadd_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_hadd_ps(a, b);
@@ -3790,7 +3802,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_hsub_pd() {
+    const fn test_mm256_hsub_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_hsub_pd(a, b);
@@ -3805,7 +3817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_hsub_ps() {
+    const fn test_mm256_hsub_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_hsub_ps(a, b);
@@ -3820,7 +3832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_xor_pd() {
+    const fn test_mm256_xor_pd() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let b = _mm256_set1_pd(0.);
         let r = _mm256_xor_pd(a, b);
@@ -3828,7 +3840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_xor_ps() {
+    const fn test_mm256_xor_ps() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let b = _mm256_set1_ps(0.);
         let r = _mm256_xor_ps(a, b);
@@ -3836,7 +3848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_cmp_pd() {
+    fn test_mm_cmp_pd() {
         let a = _mm_setr_pd(4., 9.);
         let b = _mm_setr_pd(4., 3.);
         let r = _mm_cmp_pd::<_CMP_GE_OS>(a, b);
@@ -3845,7 +3857,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cmp_pd() {
+    fn test_mm256_cmp_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_cmp_pd::<_CMP_GE_OS>(a, b);
@@ -3854,7 +3866,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_cmp_ps() {
+    fn test_mm_cmp_ps() {
         let a = _mm_setr_ps(4., 3., 2., 5.);
         let b = _mm_setr_ps(4., 9., 16., 25.);
         let r = _mm_cmp_ps::<_CMP_GE_OS>(a, b);
@@ -3865,7 +3877,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cmp_ps() {
+    fn test_mm256_cmp_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 1., 2., 3., 4.);
         let b = _mm256_setr_ps(5., 6., 7., 8., 5., 6., 7., 8.);
         let r = _mm256_cmp_ps::<_CMP_GE_OS>(a, b);
@@ -3874,7 +3886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_cmp_sd() {
+    fn test_mm_cmp_sd() {
         let a = _mm_setr_pd(4., 9.);
         let b = _mm_setr_pd(4., 3.);
         let r = _mm_cmp_sd::<_CMP_GE_OS>(a, b);
@@ -3883,7 +3895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_cmp_ss() {
+    fn test_mm_cmp_ss() {
         let a = _mm_setr_ps(4., 3., 2., 5.);
         let b = _mm_setr_ps(4., 9., 16., 25.);
         let r = _mm_cmp_ss::<_CMP_GE_OS>(a, b);
@@ -3894,7 +3906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtepi32_pd() {
+    const fn test_mm256_cvtepi32_pd() {
         let a = _mm_setr_epi32(4, 9, 16, 25);
         let r = _mm256_cvtepi32_pd(a);
         let e = _mm256_setr_pd(4., 9., 16., 25.);
@@ -3902,7 +3914,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtepi32_ps() {
+    const fn test_mm256_cvtepi32_ps() {
         let a = _mm256_setr_epi32(4, 9, 16, 25, 4, 9, 16, 25);
         let r = _mm256_cvtepi32_ps(a);
         let e = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
@@ -3910,7 +3922,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtpd_ps() {
+    const fn test_mm256_cvtpd_ps() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let r = _mm256_cvtpd_ps(a);
         let e = _mm_setr_ps(4., 9., 16., 25.);
@@ -3918,7 +3930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cvtps_epi32() {
+    fn test_mm256_cvtps_epi32() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let r = _mm256_cvtps_epi32(a);
         let e = _mm256_setr_epi32(4, 9, 16, 25, 4, 9, 16, 25);
@@ -3926,7 +3938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtps_pd() {
+    const fn test_mm256_cvtps_pd() {
         let a = _mm_setr_ps(4., 9., 16., 25.);
         let r = _mm256_cvtps_pd(a);
         let e = _mm256_setr_pd(4., 9., 16., 25.);
@@ -3934,14 +3946,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtsd_f64() {
+    const fn test_mm256_cvtsd_f64() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_cvtsd_f64(a);
         assert_eq!(r, 1.);
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cvttpd_epi32() {
+    fn test_mm256_cvttpd_epi32() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let r = _mm256_cvttpd_epi32(a);
         let e = _mm_setr_epi32(4, 9, 16, 25);
@@ -3949,7 +3961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cvtpd_epi32() {
+    fn test_mm256_cvtpd_epi32() {
         let a = _mm256_setr_pd(4., 9., 16., 25.);
         let r = _mm256_cvtpd_epi32(a);
         let e = _mm_setr_epi32(4, 9, 16, 25);
@@ -3957,7 +3969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_cvttps_epi32() {
+    fn test_mm256_cvttps_epi32() {
         let a = _mm256_setr_ps(4., 9., 16., 25., 4., 9., 16., 25.);
         let r = _mm256_cvttps_epi32(a);
         let e = _mm256_setr_epi32(4, 9, 16, 25, 4, 9, 16, 25);
@@ -3965,7 +3977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_extractf128_ps() {
+    const fn test_mm256_extractf128_ps() {
         let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_extractf128_ps::<0>(a);
         let e = _mm_setr_ps(4., 3., 2., 5.);
@@ -3973,7 +3985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_extractf128_pd() {
+    const fn test_mm256_extractf128_pd() {
         let a = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_extractf128_pd::<0>(a);
         let e = _mm_setr_pd(4., 3.);
@@ -3981,7 +3993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_extractf128_si256() {
+    const fn test_mm256_extractf128_si256() {
         let a = _mm256_setr_epi64x(4, 3, 2, 5);
         let r = _mm256_extractf128_si256::<0>(a);
         let e = _mm_setr_epi64x(4, 3);
@@ -3989,7 +4001,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_extract_epi32() {
+    const fn test_mm256_extract_epi32() {
         let a = _mm256_setr_epi32(-1, 1, 2, 3, 4, 5, 6, 7);
         let r1 = _mm256_extract_epi32::<0>(a);
         let r2 = _mm256_extract_epi32::<3>(a);
@@ -3998,7 +4010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtsi256_si32() {
+    const fn test_mm256_cvtsi256_si32() {
         let a = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_cvtsi256_si32(a);
         assert_eq!(r, 1);
@@ -4006,18 +4018,18 @@ mod tests {
 
     #[simd_test(enable = "avx")]
     #[cfg_attr(miri, ignore)] // Register-level operation not supported by Miri
-    unsafe fn test_mm256_zeroall() {
+    fn test_mm256_zeroall() {
         _mm256_zeroall();
     }
 
     #[simd_test(enable = "avx")]
     #[cfg_attr(miri, ignore)] // Register-level operation not supported by Miri
-    unsafe fn test_mm256_zeroupper() {
+    fn test_mm256_zeroupper() {
         _mm256_zeroupper();
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_permutevar_ps() {
+    fn test_mm256_permutevar_ps() {
         let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let b = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_permutevar_ps(a, b);
@@ -4026,7 +4038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_permutevar_ps() {
+    fn test_mm_permutevar_ps() {
         let a = _mm_setr_ps(4., 3., 2., 5.);
         let b = _mm_setr_epi32(1, 2, 3, 4);
         let r = _mm_permutevar_ps(a, b);
@@ -4035,7 +4047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_permute_ps() {
+    const fn test_mm256_permute_ps() {
         let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let r = _mm256_permute_ps::<0x1b>(a);
         let e = _mm256_setr_ps(5., 2., 3., 4., 50., 64., 9., 8.);
@@ -4043,7 +4055,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_permute_ps() {
+    const fn test_mm_permute_ps() {
         let a = _mm_setr_ps(4., 3., 2., 5.);
         let r = _mm_permute_ps::<0x1b>(a);
         let e = _mm_setr_ps(5., 2., 3., 4.);
@@ -4051,7 +4063,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_permutevar_pd() {
+    fn test_mm256_permutevar_pd() {
         let a = _mm256_setr_pd(4., 3., 2., 5.);
         let b = _mm256_setr_epi64x(1, 2, 3, 4);
         let r = _mm256_permutevar_pd(a, b);
@@ -4060,7 +4072,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_permutevar_pd() {
+    fn test_mm_permutevar_pd() {
         let a = _mm_setr_pd(4., 3.);
         let b = _mm_setr_epi64x(3, 0);
         let r = _mm_permutevar_pd(a, b);
@@ -4069,7 +4081,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_permute_pd() {
+    const fn test_mm256_permute_pd() {
         let a = _mm256_setr_pd(4., 3., 2., 5.);
         let r = _mm256_permute_pd::<5>(a);
         let e = _mm256_setr_pd(3., 4., 5., 2.);
@@ -4077,7 +4089,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_permute_pd() {
+    const fn test_mm_permute_pd() {
         let a = _mm_setr_pd(4., 3.);
         let r = _mm_permute_pd::<1>(a);
         let e = _mm_setr_pd(3., 4.);
@@ -4085,7 +4097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_permute2f128_ps() {
+    const fn test_mm256_permute2f128_ps() {
         let a = _mm256_setr_ps(11., 12., 13., 14., 15., 16., 17., 18.);
         let b = _mm256_setr_ps(21., 22., 23., 24., 25., 26., 27., 28.);
         let r = _mm256_permute2f128_ps::<0b0001_0011>(a, b);
@@ -4099,7 +4111,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_permute2f128_pd() {
+    const fn test_mm256_permute2f128_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_permute2f128_pd::<0b0011_0001>(a, b);
@@ -4113,7 +4125,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_permute2f128_si256() {
+    const fn test_mm256_permute2f128_si256() {
         let a = _mm256_setr_epi32(11, 12, 13, 14, 15, 16, 17, 18);
         let b = _mm256_setr_epi32(21, 22, 23, 24, 25, 26, 27, 28);
         let r = _mm256_permute2f128_si256::<0b0010_0000>(a, b);
@@ -4127,28 +4139,28 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_broadcast_ss() {
+    const fn test_mm256_broadcast_ss() {
         let r = _mm256_broadcast_ss(&3.);
         let e = _mm256_set1_ps(3.);
         assert_eq_m256(r, e);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_broadcast_ss() {
+    const fn test_mm_broadcast_ss() {
         let r = _mm_broadcast_ss(&3.);
         let e = _mm_set1_ps(3.);
         assert_eq_m128(r, e);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_broadcast_sd() {
+    const fn test_mm256_broadcast_sd() {
         let r = _mm256_broadcast_sd(&3.);
         let e = _mm256_set1_pd(3.);
         assert_eq_m256d(r, e);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_broadcast_ps() {
+    const fn test_mm256_broadcast_ps() {
         let a = _mm_setr_ps(4., 3., 2., 5.);
         let r = _mm256_broadcast_ps(&a);
         let e = _mm256_setr_ps(4., 3., 2., 5., 4., 3., 2., 5.);
@@ -4156,7 +4168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_broadcast_pd() {
+    const fn test_mm256_broadcast_pd() {
         let a = _mm_setr_pd(4., 3.);
         let r = _mm256_broadcast_pd(&a);
         let e = _mm256_setr_pd(4., 3., 4., 3.);
@@ -4164,7 +4176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insertf128_ps() {
+    const fn test_mm256_insertf128_ps() {
         let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
         let b = _mm_setr_ps(4., 9., 16., 25.);
         let r = _mm256_insertf128_ps::<0>(a, b);
@@ -4173,7 +4185,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insertf128_pd() {
+    const fn test_mm256_insertf128_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm_setr_pd(5., 6.);
         let r = _mm256_insertf128_pd::<0>(a, b);
@@ -4182,7 +4194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insertf128_si256() {
+    const fn test_mm256_insertf128_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let b = _mm_setr_epi64x(5, 6);
         let r = _mm256_insertf128_si256::<0>(a, b);
@@ -4191,7 +4203,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insert_epi8() {
+    const fn test_mm256_insert_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -4211,7 +4223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insert_epi16() {
+    const fn test_mm256_insert_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4227,7 +4239,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insert_epi32() {
+    const fn test_mm256_insert_epi32() {
         let a = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_insert_epi32::<7>(a, 0);
         let e = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 0);
@@ -4417,7 +4429,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_movehdup_ps() {
+    const fn test_mm256_movehdup_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_movehdup_ps(a);
         let e = _mm256_setr_ps(2., 2., 4., 4., 6., 6., 8., 8.);
@@ -4425,7 +4437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_moveldup_ps() {
+    const fn test_mm256_moveldup_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_moveldup_ps(a);
         let e = _mm256_setr_ps(1., 1., 3., 3., 5., 5., 7., 7.);
@@ -4433,7 +4445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_movedup_pd() {
+    const fn test_mm256_movedup_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_movedup_pd(a);
         let e = _mm256_setr_pd(1., 1., 3., 3.);
@@ -4506,7 +4518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_rcp_ps() {
+    fn test_mm256_rcp_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_rcp_ps(a);
         #[rustfmt::skip]
@@ -4521,7 +4533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_rsqrt_ps() {
+    fn test_mm256_rsqrt_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_rsqrt_ps(a);
         #[rustfmt::skip]
@@ -4536,7 +4548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_unpackhi_pd() {
+    const fn test_mm256_unpackhi_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_unpackhi_pd(a, b);
@@ -4545,7 +4557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_unpackhi_ps() {
+    const fn test_mm256_unpackhi_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm256_unpackhi_ps(a, b);
@@ -4554,7 +4566,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_unpacklo_pd() {
+    const fn test_mm256_unpacklo_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_unpacklo_pd(a, b);
@@ -4563,7 +4575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_unpacklo_ps() {
+    const fn test_mm256_unpacklo_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm256_unpacklo_ps(a, b);
@@ -4572,7 +4584,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_testz_si256() {
+    const fn test_mm256_testz_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let b = _mm256_setr_epi64x(5, 6, 7, 8);
         let r = _mm256_testz_si256(a, b);
@@ -4583,7 +4595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_testc_si256() {
+    const fn test_mm256_testc_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let b = _mm256_setr_epi64x(5, 6, 7, 8);
         let r = _mm256_testc_si256(a, b);
@@ -4594,7 +4606,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testnzc_si256() {
+    fn test_mm256_testnzc_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let b = _mm256_setr_epi64x(5, 6, 7, 8);
         let r = _mm256_testnzc_si256(a, b);
@@ -4606,7 +4618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testz_pd() {
+    fn test_mm256_testz_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_testz_pd(a, b);
@@ -4617,7 +4629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testc_pd() {
+    fn test_mm256_testc_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_testc_pd(a, b);
@@ -4629,7 +4641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testnzc_pd() {
+    fn test_mm256_testnzc_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
         let r = _mm256_testnzc_pd(a, b);
@@ -4641,7 +4653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_testz_pd() {
+    const fn test_mm_testz_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 6.);
         let r = _mm_testz_pd(a, b);
@@ -4652,7 +4664,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_testc_pd() {
+    const fn test_mm_testc_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 6.);
         let r = _mm_testc_pd(a, b);
@@ -4664,7 +4676,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_testnzc_pd() {
+    fn test_mm_testnzc_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 6.);
         let r = _mm_testnzc_pd(a, b);
@@ -4676,7 +4688,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testz_ps() {
+    fn test_mm256_testz_ps() {
         let a = _mm256_set1_ps(1.);
         let r = _mm256_testz_ps(a, a);
         assert_eq!(r, 1);
@@ -4686,7 +4698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testc_ps() {
+    fn test_mm256_testc_ps() {
         let a = _mm256_set1_ps(1.);
         let r = _mm256_testc_ps(a, a);
         assert_eq!(r, 1);
@@ -4696,7 +4708,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm256_testnzc_ps() {
+    fn test_mm256_testnzc_ps() {
         let a = _mm256_set1_ps(1.);
         let r = _mm256_testnzc_ps(a, a);
         assert_eq!(r, 0);
@@ -4707,7 +4719,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_testz_ps() {
+    const fn test_mm_testz_ps() {
         let a = _mm_set1_ps(1.);
         let r = _mm_testz_ps(a, a);
         assert_eq!(r, 1);
@@ -4717,7 +4729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm_testc_ps() {
+    const fn test_mm_testc_ps() {
         let a = _mm_set1_ps(1.);
         let r = _mm_testc_ps(a, a);
         assert_eq!(r, 1);
@@ -4727,7 +4739,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    unsafe fn test_mm_testnzc_ps() {
+    fn test_mm_testnzc_ps() {
         let a = _mm_set1_ps(1.);
         let r = _mm_testnzc_ps(a, a);
         assert_eq!(r, 0);
@@ -4738,51 +4750,51 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_movemask_pd() {
+    const fn test_mm256_movemask_pd() {
         let a = _mm256_setr_pd(1., -2., 3., -4.);
         let r = _mm256_movemask_pd(a);
         assert_eq!(r, 0xA);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_movemask_ps() {
+    const fn test_mm256_movemask_ps() {
         let a = _mm256_setr_ps(1., -2., 3., -4., 1., -2., 3., -4.);
         let r = _mm256_movemask_ps(a);
         assert_eq!(r, 0xAA);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setzero_pd() {
+    const fn test_mm256_setzero_pd() {
         let r = _mm256_setzero_pd();
         assert_eq_m256d(r, _mm256_set1_pd(0.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setzero_ps() {
+    const fn test_mm256_setzero_ps() {
         let r = _mm256_setzero_ps();
         assert_eq_m256(r, _mm256_set1_ps(0.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setzero_si256() {
+    const fn test_mm256_setzero_si256() {
         let r = _mm256_setzero_si256();
         assert_eq_m256i(r, _mm256_set1_epi8(0));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_pd() {
+    const fn test_mm256_set_pd() {
         let r = _mm256_set_pd(1., 2., 3., 4.);
         assert_eq_m256d(r, _mm256_setr_pd(4., 3., 2., 1.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_ps() {
+    const fn test_mm256_set_ps() {
         let r = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         assert_eq_m256(r, _mm256_setr_ps(8., 7., 6., 5., 4., 3., 2., 1.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_epi8() {
+    const fn test_mm256_set_epi8() {
         #[rustfmt::skip]
         let r = _mm256_set_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -4801,7 +4813,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_epi16() {
+    const fn test_mm256_set_epi16() {
         #[rustfmt::skip]
         let r = _mm256_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -4816,31 +4828,31 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_epi32() {
+    const fn test_mm256_set_epi32() {
         let r = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         assert_eq_m256i(r, _mm256_setr_epi32(8, 7, 6, 5, 4, 3, 2, 1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_epi64x() {
+    const fn test_mm256_set_epi64x() {
         let r = _mm256_set_epi64x(1, 2, 3, 4);
         assert_eq_m256i(r, _mm256_setr_epi64x(4, 3, 2, 1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_pd() {
+    const fn test_mm256_setr_pd() {
         let r = _mm256_setr_pd(1., 2., 3., 4.);
         assert_eq_m256d(r, _mm256_setr_pd(1., 2., 3., 4.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_ps() {
+    const fn test_mm256_setr_ps() {
         let r = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         assert_eq_m256(r, _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_epi8() {
+    const fn test_mm256_setr_epi8() {
         #[rustfmt::skip]
         let r = _mm256_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -4860,7 +4872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_epi16() {
+    const fn test_mm256_setr_epi16() {
         #[rustfmt::skip]
         let r = _mm256_setr_epi16(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -4875,55 +4887,55 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_epi32() {
+    const fn test_mm256_setr_epi32() {
         let r = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         assert_eq_m256i(r, _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_epi64x() {
+    const fn test_mm256_setr_epi64x() {
         let r = _mm256_setr_epi64x(1, 2, 3, 4);
         assert_eq_m256i(r, _mm256_setr_epi64x(1, 2, 3, 4));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_pd() {
+    const fn test_mm256_set1_pd() {
         let r = _mm256_set1_pd(1.);
         assert_eq_m256d(r, _mm256_set1_pd(1.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_ps() {
+    const fn test_mm256_set1_ps() {
         let r = _mm256_set1_ps(1.);
         assert_eq_m256(r, _mm256_set1_ps(1.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_epi8() {
+    const fn test_mm256_set1_epi8() {
         let r = _mm256_set1_epi8(1);
         assert_eq_m256i(r, _mm256_set1_epi8(1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_epi16() {
+    const fn test_mm256_set1_epi16() {
         let r = _mm256_set1_epi16(1);
         assert_eq_m256i(r, _mm256_set1_epi16(1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_epi32() {
+    const fn test_mm256_set1_epi32() {
         let r = _mm256_set1_epi32(1);
         assert_eq_m256i(r, _mm256_set1_epi32(1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set1_epi64x() {
+    const fn test_mm256_set1_epi64x() {
         let r = _mm256_set1_epi64x(1);
         assert_eq_m256i(r, _mm256_set1_epi64x(1));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castpd_ps() {
+    const fn test_mm256_castpd_ps() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_castpd_ps(a);
         let e = _mm256_setr_ps(0., 1.875, 0., 2., 0., 2.125, 0., 2.25);
@@ -4931,7 +4943,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castps_pd() {
+    const fn test_mm256_castps_pd() {
         let a = _mm256_setr_ps(0., 1.875, 0., 2., 0., 2.125, 0., 2.25);
         let r = _mm256_castps_pd(a);
         let e = _mm256_setr_pd(1., 2., 3., 4.);
@@ -4939,7 +4951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castps_si256() {
+    const fn test_mm256_castps_si256() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_castps_si256(a);
         #[rustfmt::skip]
@@ -4953,7 +4965,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castsi256_ps() {
+    const fn test_mm256_castsi256_ps() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 0, -128, 63, 0, 0, 0, 64,
@@ -4967,63 +4979,63 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castpd_si256() {
+    const fn test_mm256_castpd_si256() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_castpd_si256(a);
-        assert_eq_m256d(transmute(r), a);
+        assert_eq_m256d(unsafe { transmute(r) }, a);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castsi256_pd() {
+    const fn test_mm256_castsi256_pd() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let r = _mm256_castsi256_pd(a);
-        assert_eq_m256d(r, transmute(a));
+        assert_eq_m256d(r, unsafe { transmute(a) });
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castps256_ps128() {
+    const fn test_mm256_castps256_ps128() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_castps256_ps128(a);
         assert_eq_m128(r, _mm_setr_ps(1., 2., 3., 4.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castpd256_pd128() {
+    const fn test_mm256_castpd256_pd128() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_castpd256_pd128(a);
         assert_eq_m128d(r, _mm_setr_pd(1., 2.));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castsi256_si128() {
+    const fn test_mm256_castsi256_si128() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let r = _mm256_castsi256_si128(a);
         assert_eq_m128i(r, _mm_setr_epi64x(1, 2));
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castps128_ps256() {
+    const fn test_mm256_castps128_ps256() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let r = _mm256_castps128_ps256(a);
         assert_eq_m128(_mm256_castps256_ps128(r), a);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castpd128_pd256() {
+    const fn test_mm256_castpd128_pd256() {
         let a = _mm_setr_pd(1., 2.);
         let r = _mm256_castpd128_pd256(a);
         assert_eq_m128d(_mm256_castpd256_pd128(r), a);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_castsi128_si256() {
+    const fn test_mm256_castsi128_si256() {
         let a = _mm_setr_epi32(1, 2, 3, 4);
         let r = _mm256_castsi128_si256(a);
         assert_eq_m128i(_mm256_castsi256_si128(r), a);
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_zextps128_ps256() {
+    const fn test_mm256_zextps128_ps256() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let r = _mm256_zextps128_ps256(a);
         let e = _mm256_setr_ps(1., 2., 3., 4., 0., 0., 0., 0.);
@@ -5031,7 +5043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_zextsi128_si256() {
+    const fn test_mm256_zextsi128_si256() {
         let a = _mm_setr_epi64x(1, 2);
         let r = _mm256_zextsi128_si256(a);
         let e = _mm256_setr_epi64x(1, 2, 0, 0);
@@ -5039,7 +5051,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_zextpd128_pd256() {
+    const fn test_mm256_zextpd128_pd256() {
         let a = _mm_setr_pd(1., 2.);
         let r = _mm256_zextpd128_pd256(a);
         let e = _mm256_setr_pd(1., 2., 0., 0.);
@@ -5047,7 +5059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_m128() {
+    const fn test_mm256_set_m128() {
         let hi = _mm_setr_ps(5., 6., 7., 8.);
         let lo = _mm_setr_ps(1., 2., 3., 4.);
         let r = _mm256_set_m128(hi, lo);
@@ -5056,7 +5068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_m128d() {
+    const fn test_mm256_set_m128d() {
         let hi = _mm_setr_pd(3., 4.);
         let lo = _mm_setr_pd(1., 2.);
         let r = _mm256_set_m128d(hi, lo);
@@ -5065,7 +5077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_set_m128i() {
+    const fn test_mm256_set_m128i() {
         #[rustfmt::skip]
         let hi = _mm_setr_epi8(
             17, 18, 19, 20,
@@ -5092,7 +5104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_m128() {
+    const fn test_mm256_setr_m128() {
         let lo = _mm_setr_ps(1., 2., 3., 4.);
         let hi = _mm_setr_ps(5., 6., 7., 8.);
         let r = _mm256_setr_m128(lo, hi);
@@ -5101,7 +5113,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_m128d() {
+    const fn test_mm256_setr_m128d() {
         let lo = _mm_setr_pd(1., 2.);
         let hi = _mm_setr_pd(3., 4.);
         let r = _mm256_setr_m128d(lo, hi);
@@ -5110,7 +5122,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_setr_m128i() {
+    const fn test_mm256_setr_m128i() {
         #[rustfmt::skip]
         let lo = _mm_setr_epi8(
             1, 2, 3, 4,
@@ -5235,7 +5247,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_cvtss_f32() {
+    const fn test_mm256_cvtss_f32() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_cvtss_f32(a);
         assert_eq!(r, 1.);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx2.rs b/library/stdarch/crates/core_arch/src/x86/avx2.rs
index a297544e9e9b..6f56e937c6db 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx2.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx2.rs
@@ -1813,14 +1813,20 @@ pub const fn _mm256_inserti128_si256<const IMM1: i32>(a: __m256i, b: __m128i) ->
 #[target_feature(enable = "avx2")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm256_madd_epi16(a: __m256i, b: __m256i) -> __m256i {
-    unsafe {
-        let r: i32x16 = simd_mul(simd_cast(a.as_i16x16()), simd_cast(b.as_i16x16()));
-        let even: i32x8 = simd_shuffle!(r, r, [0, 2, 4, 6, 8, 10, 12, 14]);
-        let odd: i32x8 = simd_shuffle!(r, r, [1, 3, 5, 7, 9, 11, 13, 15]);
-        simd_add(even, odd).as_m256i()
-    }
+pub fn _mm256_madd_epi16(a: __m256i, b: __m256i) -> __m256i {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
+    //
+    // ```rust
+    // #[target_feature(enable = "avx2")]
+    // unsafe fn widening_add(mad: __m256i) -> __m256i {
+    //     _mm256_madd_epi16(mad, _mm256_set1_epi16(1))
+    // }
+    // ```
+    //
+    // If we implement this using generic vector intrinsics, the optimizer
+    // will eliminate this pattern, and `vpmaddwd` will no longer be emitted.
+    // For this reason, we use x86 intrinsics.
+    unsafe { transmute(pmaddwd(a.as_i16x16(), b.as_i16x16())) }
 }
 
 /// Vertically multiplies each unsigned 8-bit integer from `a` with the
@@ -3789,6 +3795,8 @@ unsafe extern "C" {
     fn phaddsw(a: i16x16, b: i16x16) -> i16x16;
     #[link_name = "llvm.x86.avx2.phsub.sw"]
     fn phsubsw(a: i16x16, b: i16x16) -> i16x16;
+    #[link_name = "llvm.x86.avx2.pmadd.wd"]
+    fn pmaddwd(a: i16x16, b: i16x16) -> i32x8;
     #[link_name = "llvm.x86.avx2.pmadd.ub.sw"]
     fn pmaddubsw(a: u8x32, b: i8x32) -> i16x16;
     #[link_name = "llvm.x86.avx2.mpsadbw"]
@@ -3914,7 +3922,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_abs_epi32() {
+    const fn test_mm256_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -3930,7 +3938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_abs_epi16() {
+    const fn test_mm256_abs_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0,  1, -1, 2, -2, 3, -3, 4,
@@ -3946,7 +3954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_abs_epi8() {
+    const fn test_mm256_abs_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 1, -1, 2, -2, 3, -3, 4,
@@ -3966,7 +3974,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_add_epi64() {
+    const fn test_mm256_add_epi64() {
         let a = _mm256_setr_epi64x(-10, 0, 100, 1_000_000_000);
         let b = _mm256_setr_epi64x(-1, 0, 1, 2);
         let r = _mm256_add_epi64(a, b);
@@ -3975,7 +3983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_add_epi32() {
+    const fn test_mm256_add_epi32() {
         let a = _mm256_setr_epi32(-1, 0, 1, 2, 3, 4, 5, 6);
         let b = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_add_epi32(a, b);
@@ -3984,7 +3992,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_add_epi16() {
+    const fn test_mm256_add_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4005,7 +4013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_add_epi8() {
+    const fn test_mm256_add_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4032,7 +4040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_adds_epi8() {
+    const fn test_mm256_adds_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4059,7 +4067,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epi8_saturate_positive() {
+    fn test_mm256_adds_epi8_saturate_positive() {
         let a = _mm256_set1_epi8(0x7F);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_adds_epi8(a, b);
@@ -4067,7 +4075,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epi8_saturate_negative() {
+    fn test_mm256_adds_epi8_saturate_negative() {
         let a = _mm256_set1_epi8(-0x80);
         let b = _mm256_set1_epi8(-1);
         let r = _mm256_adds_epi8(a, b);
@@ -4075,7 +4083,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_adds_epi16() {
+    const fn test_mm256_adds_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4097,7 +4105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epi16_saturate_positive() {
+    fn test_mm256_adds_epi16_saturate_positive() {
         let a = _mm256_set1_epi16(0x7FFF);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_adds_epi16(a, b);
@@ -4105,7 +4113,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epi16_saturate_negative() {
+    fn test_mm256_adds_epi16_saturate_negative() {
         let a = _mm256_set1_epi16(-0x8000);
         let b = _mm256_set1_epi16(-1);
         let r = _mm256_adds_epi16(a, b);
@@ -4113,7 +4121,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_adds_epu8() {
+    const fn test_mm256_adds_epu8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4140,7 +4148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epu8_saturate() {
+    fn test_mm256_adds_epu8_saturate() {
         let a = _mm256_set1_epi8(!0);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_adds_epu8(a, b);
@@ -4148,7 +4156,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_adds_epu16() {
+    const fn test_mm256_adds_epu16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4170,7 +4178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_adds_epu16_saturate() {
+    fn test_mm256_adds_epu16_saturate() {
         let a = _mm256_set1_epi16(!0);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_adds_epu16(a, b);
@@ -4178,7 +4186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_and_si256() {
+    const fn test_mm256_and_si256() {
         let a = _mm256_set1_epi8(5);
         let b = _mm256_set1_epi8(3);
         let got = _mm256_and_si256(a, b);
@@ -4186,7 +4194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_andnot_si256() {
+    const fn test_mm256_andnot_si256() {
         let a = _mm256_set1_epi8(5);
         let b = _mm256_set1_epi8(3);
         let got = _mm256_andnot_si256(a, b);
@@ -4194,21 +4202,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_avg_epu8() {
+    const fn test_mm256_avg_epu8() {
         let (a, b) = (_mm256_set1_epi8(3), _mm256_set1_epi8(9));
         let r = _mm256_avg_epu8(a, b);
         assert_eq_m256i(r, _mm256_set1_epi8(6));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_avg_epu16() {
+    const fn test_mm256_avg_epu16() {
         let (a, b) = (_mm256_set1_epi16(3), _mm256_set1_epi16(9));
         let r = _mm256_avg_epu16(a, b);
         assert_eq_m256i(r, _mm256_set1_epi16(6));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_blend_epi32() {
+    const fn test_mm_blend_epi32() {
         let (a, b) = (_mm_set1_epi32(3), _mm_set1_epi32(9));
         let e = _mm_setr_epi32(9, 3, 3, 3);
         let r = _mm_blend_epi32::<0x01>(a, b);
@@ -4219,7 +4227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_blend_epi32() {
+    const fn test_mm256_blend_epi32() {
         let (a, b) = (_mm256_set1_epi32(3), _mm256_set1_epi32(9));
         let e = _mm256_setr_epi32(9, 3, 3, 3, 3, 3, 3, 3);
         let r = _mm256_blend_epi32::<0x01>(a, b);
@@ -4235,7 +4243,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_blend_epi16() {
+    const fn test_mm256_blend_epi16() {
         let (a, b) = (_mm256_set1_epi16(3), _mm256_set1_epi16(9));
         let e = _mm256_setr_epi16(9, 3, 3, 3, 3, 3, 3, 3, 9, 3, 3, 3, 3, 3, 3, 3);
         let r = _mm256_blend_epi16::<0x01>(a, b);
@@ -4246,7 +4254,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_blendv_epi8() {
+    const fn test_mm256_blendv_epi8() {
         let (a, b) = (_mm256_set1_epi8(4), _mm256_set1_epi8(2));
         let mask = _mm256_insert_epi8::<2>(_mm256_set1_epi8(0), -1);
         let e = _mm256_insert_epi8::<2>(_mm256_set1_epi8(4), 2);
@@ -4255,63 +4263,63 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastb_epi8() {
+    const fn test_mm_broadcastb_epi8() {
         let a = _mm_insert_epi8::<0>(_mm_set1_epi8(0x00), 0x2a);
         let res = _mm_broadcastb_epi8(a);
         assert_eq_m128i(res, _mm_set1_epi8(0x2a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastb_epi8() {
+    const fn test_mm256_broadcastb_epi8() {
         let a = _mm_insert_epi8::<0>(_mm_set1_epi8(0x00), 0x2a);
         let res = _mm256_broadcastb_epi8(a);
         assert_eq_m256i(res, _mm256_set1_epi8(0x2a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastd_epi32() {
+    const fn test_mm_broadcastd_epi32() {
         let a = _mm_setr_epi32(0x2a, 0x8000000, 0, 0);
         let res = _mm_broadcastd_epi32(a);
         assert_eq_m128i(res, _mm_set1_epi32(0x2a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastd_epi32() {
+    const fn test_mm256_broadcastd_epi32() {
         let a = _mm_setr_epi32(0x2a, 0x8000000, 0, 0);
         let res = _mm256_broadcastd_epi32(a);
         assert_eq_m256i(res, _mm256_set1_epi32(0x2a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastq_epi64() {
+    const fn test_mm_broadcastq_epi64() {
         let a = _mm_setr_epi64x(0x1ffffffff, 0);
         let res = _mm_broadcastq_epi64(a);
         assert_eq_m128i(res, _mm_set1_epi64x(0x1ffffffff));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastq_epi64() {
+    const fn test_mm256_broadcastq_epi64() {
         let a = _mm_setr_epi64x(0x1ffffffff, 0);
         let res = _mm256_broadcastq_epi64(a);
         assert_eq_m256i(res, _mm256_set1_epi64x(0x1ffffffff));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastsd_pd() {
+    const fn test_mm_broadcastsd_pd() {
         let a = _mm_setr_pd(6.88, 3.44);
         let res = _mm_broadcastsd_pd(a);
         assert_eq_m128d(res, _mm_set1_pd(6.88));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastsd_pd() {
+    const fn test_mm256_broadcastsd_pd() {
         let a = _mm_setr_pd(6.88, 3.44);
         let res = _mm256_broadcastsd_pd(a);
         assert_eq_m256d(res, _mm256_set1_pd(6.88f64));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastsi128_si256() {
+    const fn test_mm_broadcastsi128_si256() {
         let a = _mm_setr_epi64x(0x0987654321012334, 0x5678909876543210);
         let res = _mm_broadcastsi128_si256(a);
         let retval = _mm256_setr_epi64x(
@@ -4324,7 +4332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastsi128_si256() {
+    const fn test_mm256_broadcastsi128_si256() {
         let a = _mm_setr_epi64x(0x0987654321012334, 0x5678909876543210);
         let res = _mm256_broadcastsi128_si256(a);
         let retval = _mm256_setr_epi64x(
@@ -4337,35 +4345,35 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastss_ps() {
+    const fn test_mm_broadcastss_ps() {
         let a = _mm_setr_ps(6.88, 3.44, 0.0, 0.0);
         let res = _mm_broadcastss_ps(a);
         assert_eq_m128(res, _mm_set1_ps(6.88));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastss_ps() {
+    const fn test_mm256_broadcastss_ps() {
         let a = _mm_setr_ps(6.88, 3.44, 0.0, 0.0);
         let res = _mm256_broadcastss_ps(a);
         assert_eq_m256(res, _mm256_set1_ps(6.88));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_broadcastw_epi16() {
+    const fn test_mm_broadcastw_epi16() {
         let a = _mm_insert_epi16::<0>(_mm_set1_epi16(0x2a), 0x22b);
         let res = _mm_broadcastw_epi16(a);
         assert_eq_m128i(res, _mm_set1_epi16(0x22b));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_broadcastw_epi16() {
+    const fn test_mm256_broadcastw_epi16() {
         let a = _mm_insert_epi16::<0>(_mm_set1_epi16(0x2a), 0x22b);
         let res = _mm256_broadcastw_epi16(a);
         assert_eq_m256i(res, _mm256_set1_epi16(0x22b));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpeq_epi8() {
+    const fn test_mm256_cmpeq_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4385,7 +4393,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpeq_epi16() {
+    const fn test_mm256_cmpeq_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4401,7 +4409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpeq_epi32() {
+    const fn test_mm256_cmpeq_epi32() {
         let a = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_setr_epi32(7, 6, 2, 4, 3, 2, 1, 0);
         let r = _mm256_cmpeq_epi32(a, b);
@@ -4411,7 +4419,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpeq_epi64() {
+    const fn test_mm256_cmpeq_epi64() {
         let a = _mm256_setr_epi64x(0, 1, 2, 3);
         let b = _mm256_setr_epi64x(3, 2, 2, 0);
         let r = _mm256_cmpeq_epi64(a, b);
@@ -4419,7 +4427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpgt_epi8() {
+    const fn test_mm256_cmpgt_epi8() {
         let a = _mm256_insert_epi8::<0>(_mm256_set1_epi8(0), 5);
         let b = _mm256_set1_epi8(0);
         let r = _mm256_cmpgt_epi8(a, b);
@@ -4427,7 +4435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpgt_epi16() {
+    const fn test_mm256_cmpgt_epi16() {
         let a = _mm256_insert_epi16::<0>(_mm256_set1_epi16(0), 5);
         let b = _mm256_set1_epi16(0);
         let r = _mm256_cmpgt_epi16(a, b);
@@ -4435,7 +4443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpgt_epi32() {
+    const fn test_mm256_cmpgt_epi32() {
         let a = _mm256_insert_epi32::<0>(_mm256_set1_epi32(0), 5);
         let b = _mm256_set1_epi32(0);
         let r = _mm256_cmpgt_epi32(a, b);
@@ -4443,7 +4451,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cmpgt_epi64() {
+    const fn test_mm256_cmpgt_epi64() {
         let a = _mm256_insert_epi64::<0>(_mm256_set1_epi64x(0), 5);
         let b = _mm256_set1_epi64x(0);
         let r = _mm256_cmpgt_epi64(a, b);
@@ -4451,7 +4459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi8_epi16() {
+    const fn test_mm256_cvtepi8_epi16() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 0, -1, 1, -2, 2, -3, 3,
@@ -4466,7 +4474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi8_epi32() {
+    const fn test_mm256_cvtepi8_epi32() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 0, -1, 1, -2, 2, -3, 3,
@@ -4477,7 +4485,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi8_epi64() {
+    const fn test_mm256_cvtepi8_epi64() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 0, -1, 1, -2, 2, -3, 3,
@@ -4488,49 +4496,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi16_epi32() {
+    const fn test_mm256_cvtepi16_epi32() {
         let a = _mm_setr_epi16(0, 0, -1, 1, -2, 2, -3, 3);
         let r = _mm256_setr_epi32(0, 0, -1, 1, -2, 2, -3, 3);
         assert_eq_m256i(r, _mm256_cvtepi16_epi32(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi16_epi64() {
+    const fn test_mm256_cvtepi16_epi64() {
         let a = _mm_setr_epi16(0, 0, -1, 1, -2, 2, -3, 3);
         let r = _mm256_setr_epi64x(0, 0, -1, 1);
         assert_eq_m256i(r, _mm256_cvtepi16_epi64(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepi32_epi64() {
+    const fn test_mm256_cvtepi32_epi64() {
         let a = _mm_setr_epi32(0, 0, -1, 1);
         let r = _mm256_setr_epi64x(0, 0, -1, 1);
         assert_eq_m256i(r, _mm256_cvtepi32_epi64(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu16_epi32() {
+    const fn test_mm256_cvtepu16_epi32() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         assert_eq_m256i(r, _mm256_cvtepu16_epi32(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu16_epi64() {
+    const fn test_mm256_cvtepu16_epi64() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_setr_epi64x(0, 1, 2, 3);
         assert_eq_m256i(r, _mm256_cvtepu16_epi64(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu32_epi64() {
+    const fn test_mm256_cvtepu32_epi64() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let r = _mm256_setr_epi64x(0, 1, 2, 3);
         assert_eq_m256i(r, _mm256_cvtepu32_epi64(a));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu8_epi16() {
+    const fn test_mm256_cvtepu8_epi16() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4545,7 +4553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu8_epi32() {
+    const fn test_mm256_cvtepu8_epi32() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4556,7 +4564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_cvtepu8_epi64() {
+    const fn test_mm256_cvtepu8_epi64() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4567,7 +4575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_extracti128_si256() {
+    const fn test_mm256_extracti128_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let r = _mm256_extracti128_si256::<1>(a);
         let e = _mm_setr_epi64x(3, 4);
@@ -4575,7 +4583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_hadd_epi16() {
+    const fn test_mm256_hadd_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_hadd_epi16(a, b);
@@ -4584,7 +4592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_hadd_epi32() {
+    const fn test_mm256_hadd_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_hadd_epi32(a, b);
@@ -4593,7 +4601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_hadds_epi16() {
+    fn test_mm256_hadds_epi16() {
         let a = _mm256_set1_epi16(2);
         let a = _mm256_insert_epi16::<0>(a, 0x7fff);
         let a = _mm256_insert_epi16::<1>(a, 1);
@@ -4608,7 +4616,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_hsub_epi16() {
+    const fn test_mm256_hsub_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_hsub_epi16(a, b);
@@ -4617,7 +4625,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_hsub_epi32() {
+    const fn test_mm256_hsub_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_hsub_epi32(a, b);
@@ -4626,7 +4634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_hsubs_epi16() {
+    fn test_mm256_hsubs_epi16() {
         let a = _mm256_set1_epi16(2);
         let a = _mm256_insert_epi16::<0>(a, 0x7fff);
         let a = _mm256_insert_epi16::<1>(a, -1);
@@ -4637,7 +4645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_madd_epi16() {
+    fn test_mm256_madd_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_madd_epi16(a, b);
@@ -4646,7 +4654,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_inserti128_si256() {
+    const fn test_mm256_inserti128_si256() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let b = _mm_setr_epi64x(7, 8);
         let r = _mm256_inserti128_si256::<1>(a, b);
@@ -4655,7 +4663,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_maddubs_epi16() {
+    fn test_mm256_maddubs_epi16() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_maddubs_epi16(a, b);
@@ -4744,7 +4752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epi16() {
+    const fn test_mm256_max_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_max_epi16(a, b);
@@ -4752,7 +4760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epi32() {
+    const fn test_mm256_max_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_max_epi32(a, b);
@@ -4760,7 +4768,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epi8() {
+    const fn test_mm256_max_epi8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_max_epi8(a, b);
@@ -4768,7 +4776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epu16() {
+    const fn test_mm256_max_epu16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_max_epu16(a, b);
@@ -4776,7 +4784,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epu32() {
+    const fn test_mm256_max_epu32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_max_epu32(a, b);
@@ -4784,7 +4792,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_max_epu8() {
+    const fn test_mm256_max_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_max_epu8(a, b);
@@ -4792,7 +4800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epi16() {
+    const fn test_mm256_min_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_min_epi16(a, b);
@@ -4800,7 +4808,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epi32() {
+    const fn test_mm256_min_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_min_epi32(a, b);
@@ -4808,7 +4816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epi8() {
+    const fn test_mm256_min_epi8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_min_epi8(a, b);
@@ -4816,7 +4824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epu16() {
+    const fn test_mm256_min_epu16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_min_epu16(a, b);
@@ -4824,7 +4832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epu32() {
+    const fn test_mm256_min_epu32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_min_epu32(a, b);
@@ -4832,7 +4840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_min_epu8() {
+    const fn test_mm256_min_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_min_epu8(a, b);
@@ -4840,7 +4848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_movemask_epi8() {
+    const fn test_mm256_movemask_epi8() {
         let a = _mm256_set1_epi8(-1);
         let r = _mm256_movemask_epi8(a);
         let e = -1;
@@ -4848,7 +4856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_mpsadbw_epu8() {
+    fn test_mm256_mpsadbw_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_mpsadbw_epu8::<0>(a, b);
@@ -4857,7 +4865,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mul_epi32() {
+    const fn test_mm256_mul_epi32() {
         let a = _mm256_setr_epi32(0, 0, 0, 0, 2, 2, 2, 2);
         let b = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_mul_epi32(a, b);
@@ -4866,7 +4874,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mul_epu32() {
+    const fn test_mm256_mul_epu32() {
         let a = _mm256_setr_epi32(0, 0, 0, 0, 2, 2, 2, 2);
         let b = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_mul_epu32(a, b);
@@ -4875,7 +4883,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mulhi_epi16() {
+    const fn test_mm256_mulhi_epi16() {
         let a = _mm256_set1_epi16(6535);
         let b = _mm256_set1_epi16(6535);
         let r = _mm256_mulhi_epi16(a, b);
@@ -4884,7 +4892,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mulhi_epu16() {
+    const fn test_mm256_mulhi_epu16() {
         let a = _mm256_set1_epi16(6535);
         let b = _mm256_set1_epi16(6535);
         let r = _mm256_mulhi_epu16(a, b);
@@ -4893,7 +4901,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mullo_epi16() {
+    const fn test_mm256_mullo_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_mullo_epi16(a, b);
@@ -4902,7 +4910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_mullo_epi32() {
+    const fn test_mm256_mullo_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_mullo_epi32(a, b);
@@ -4911,7 +4919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_mulhrs_epi16() {
+    fn test_mm256_mulhrs_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_mullo_epi16(a, b);
@@ -4920,7 +4928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_or_si256() {
+    const fn test_mm256_or_si256() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(0);
         let r = _mm256_or_si256(a, b);
@@ -4928,7 +4936,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_packs_epi16() {
+    fn test_mm256_packs_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_packs_epi16(a, b);
@@ -4944,7 +4952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_packs_epi32() {
+    fn test_mm256_packs_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_packs_epi32(a, b);
@@ -4954,7 +4962,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_packus_epi16() {
+    fn test_mm256_packus_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(4);
         let r = _mm256_packus_epi16(a, b);
@@ -4970,7 +4978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_packus_epi32() {
+    fn test_mm256_packus_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(4);
         let r = _mm256_packus_epi32(a, b);
@@ -4980,7 +4988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sad_epu8() {
+    fn test_mm256_sad_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_sad_epu8(a, b);
@@ -4989,7 +4997,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_shufflehi_epi16() {
+    const fn test_mm256_shufflehi_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             0, 1, 2, 3, 11, 22, 33, 44,
@@ -5005,7 +5013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_shufflelo_epi16() {
+    const fn test_mm256_shufflelo_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             11, 22, 33, 44, 0, 1, 2, 3,
@@ -5021,7 +5029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sign_epi16() {
+    fn test_mm256_sign_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(-1);
         let r = _mm256_sign_epi16(a, b);
@@ -5030,7 +5038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sign_epi32() {
+    fn test_mm256_sign_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(-1);
         let r = _mm256_sign_epi32(a, b);
@@ -5039,7 +5047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sign_epi8() {
+    fn test_mm256_sign_epi8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(-1);
         let r = _mm256_sign_epi8(a, b);
@@ -5048,7 +5056,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sll_epi16() {
+    fn test_mm256_sll_epi16() {
         let a = _mm256_set1_epi16(0xFF);
         let b = _mm_insert_epi16::<0>(_mm_set1_epi16(0), 4);
         let r = _mm256_sll_epi16(a, b);
@@ -5056,7 +5064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sll_epi32() {
+    fn test_mm256_sll_epi32() {
         let a = _mm256_set1_epi32(0xFFFF);
         let b = _mm_insert_epi32::<0>(_mm_set1_epi32(0), 4);
         let r = _mm256_sll_epi32(a, b);
@@ -5064,7 +5072,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sll_epi64() {
+    fn test_mm256_sll_epi64() {
         let a = _mm256_set1_epi64x(0xFFFFFFFF);
         let b = _mm_insert_epi64::<0>(_mm_set1_epi64x(0), 4);
         let r = _mm256_sll_epi64(a, b);
@@ -5072,7 +5080,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_slli_epi16() {
+    const fn test_mm256_slli_epi16() {
         assert_eq_m256i(
             _mm256_slli_epi16::<4>(_mm256_set1_epi16(0xFF)),
             _mm256_set1_epi16(0xFF0),
@@ -5080,7 +5088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_slli_epi32() {
+    const fn test_mm256_slli_epi32() {
         assert_eq_m256i(
             _mm256_slli_epi32::<4>(_mm256_set1_epi32(0xFFFF)),
             _mm256_set1_epi32(0xFFFF0),
@@ -5088,7 +5096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_slli_epi64() {
+    const fn test_mm256_slli_epi64() {
         assert_eq_m256i(
             _mm256_slli_epi64::<4>(_mm256_set1_epi64x(0xFFFFFFFF)),
             _mm256_set1_epi64x(0xFFFFFFFF0),
@@ -5096,14 +5104,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_slli_si256() {
+    const fn test_mm256_slli_si256() {
         let a = _mm256_set1_epi64x(0xFFFFFFFF);
         let r = _mm256_slli_si256::<3>(a);
         assert_eq_m256i(r, _mm256_set1_epi64x(0xFFFFFFFF000000));
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_sllv_epi32() {
+    const fn test_mm_sllv_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(1);
         let r = _mm_sllv_epi32(a, b);
@@ -5112,7 +5120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sllv_epi32() {
+    const fn test_mm256_sllv_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_sllv_epi32(a, b);
@@ -5121,7 +5129,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_sllv_epi64() {
+    const fn test_mm_sllv_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(1);
         let r = _mm_sllv_epi64(a, b);
@@ -5130,7 +5138,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sllv_epi64() {
+    const fn test_mm256_sllv_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_sllv_epi64(a, b);
@@ -5139,7 +5147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sra_epi16() {
+    fn test_mm256_sra_epi16() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm_setr_epi16(1, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm256_sra_epi16(a, b);
@@ -5147,7 +5155,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_sra_epi32() {
+    fn test_mm256_sra_epi32() {
         let a = _mm256_set1_epi32(-1);
         let b = _mm_insert_epi32::<0>(_mm_set1_epi32(0), 1);
         let r = _mm256_sra_epi32(a, b);
@@ -5155,7 +5163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srai_epi16() {
+    const fn test_mm256_srai_epi16() {
         assert_eq_m256i(
             _mm256_srai_epi16::<1>(_mm256_set1_epi16(-1)),
             _mm256_set1_epi16(-1),
@@ -5163,7 +5171,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srai_epi32() {
+    const fn test_mm256_srai_epi32() {
         assert_eq_m256i(
             _mm256_srai_epi32::<1>(_mm256_set1_epi32(-1)),
             _mm256_set1_epi32(-1),
@@ -5171,7 +5179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_srav_epi32() {
+    const fn test_mm_srav_epi32() {
         let a = _mm_set1_epi32(4);
         let count = _mm_set1_epi32(1);
         let r = _mm_srav_epi32(a, count);
@@ -5180,7 +5188,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srav_epi32() {
+    const fn test_mm256_srav_epi32() {
         let a = _mm256_set1_epi32(4);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_srav_epi32(a, count);
@@ -5189,7 +5197,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srli_si256() {
+    const fn test_mm256_srli_si256() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -5209,7 +5217,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_srl_epi16() {
+    fn test_mm256_srl_epi16() {
         let a = _mm256_set1_epi16(0xFF);
         let b = _mm_insert_epi16::<0>(_mm_set1_epi16(0), 4);
         let r = _mm256_srl_epi16(a, b);
@@ -5217,7 +5225,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_srl_epi32() {
+    fn test_mm256_srl_epi32() {
         let a = _mm256_set1_epi32(0xFFFF);
         let b = _mm_insert_epi32::<0>(_mm_set1_epi32(0), 4);
         let r = _mm256_srl_epi32(a, b);
@@ -5225,7 +5233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_srl_epi64() {
+    fn test_mm256_srl_epi64() {
         let a = _mm256_set1_epi64x(0xFFFFFFFF);
         let b = _mm_setr_epi64x(4, 0);
         let r = _mm256_srl_epi64(a, b);
@@ -5233,7 +5241,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srli_epi16() {
+    const fn test_mm256_srli_epi16() {
         assert_eq_m256i(
             _mm256_srli_epi16::<4>(_mm256_set1_epi16(0xFF)),
             _mm256_set1_epi16(0xF),
@@ -5241,7 +5249,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srli_epi32() {
+    const fn test_mm256_srli_epi32() {
         assert_eq_m256i(
             _mm256_srli_epi32::<4>(_mm256_set1_epi32(0xFFFF)),
             _mm256_set1_epi32(0xFFF),
@@ -5249,7 +5257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srli_epi64() {
+    const fn test_mm256_srli_epi64() {
         assert_eq_m256i(
             _mm256_srli_epi64::<4>(_mm256_set1_epi64x(0xFFFFFFFF)),
             _mm256_set1_epi64x(0xFFFFFFF),
@@ -5257,7 +5265,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_srlv_epi32() {
+    const fn test_mm_srlv_epi32() {
         let a = _mm_set1_epi32(2);
         let count = _mm_set1_epi32(1);
         let r = _mm_srlv_epi32(a, count);
@@ -5266,7 +5274,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srlv_epi32() {
+    const fn test_mm256_srlv_epi32() {
         let a = _mm256_set1_epi32(2);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_srlv_epi32(a, count);
@@ -5275,7 +5283,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm_srlv_epi64() {
+    const fn test_mm_srlv_epi64() {
         let a = _mm_set1_epi64x(2);
         let count = _mm_set1_epi64x(1);
         let r = _mm_srlv_epi64(a, count);
@@ -5284,7 +5292,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_srlv_epi64() {
+    const fn test_mm256_srlv_epi64() {
         let a = _mm256_set1_epi64x(2);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_srlv_epi64(a, count);
@@ -5300,7 +5308,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sub_epi16() {
+    const fn test_mm256_sub_epi16() {
         let a = _mm256_set1_epi16(4);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_sub_epi16(a, b);
@@ -5308,7 +5316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sub_epi32() {
+    const fn test_mm256_sub_epi32() {
         let a = _mm256_set1_epi32(4);
         let b = _mm256_set1_epi32(2);
         let r = _mm256_sub_epi32(a, b);
@@ -5316,7 +5324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sub_epi64() {
+    const fn test_mm256_sub_epi64() {
         let a = _mm256_set1_epi64x(4);
         let b = _mm256_set1_epi64x(2);
         let r = _mm256_sub_epi64(a, b);
@@ -5324,7 +5332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_sub_epi8() {
+    const fn test_mm256_sub_epi8() {
         let a = _mm256_set1_epi8(4);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_sub_epi8(a, b);
@@ -5332,7 +5340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_subs_epi16() {
+    const fn test_mm256_subs_epi16() {
         let a = _mm256_set1_epi16(4);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_subs_epi16(a, b);
@@ -5340,7 +5348,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_subs_epi8() {
+    const fn test_mm256_subs_epi8() {
         let a = _mm256_set1_epi8(4);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_subs_epi8(a, b);
@@ -5348,7 +5356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_subs_epu16() {
+    const fn test_mm256_subs_epu16() {
         let a = _mm256_set1_epi16(4);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_subs_epu16(a, b);
@@ -5356,7 +5364,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_subs_epu8() {
+    const fn test_mm256_subs_epu8() {
         let a = _mm256_set1_epi8(4);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_subs_epu8(a, b);
@@ -5364,7 +5372,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_xor_si256() {
+    const fn test_mm256_xor_si256() {
         let a = _mm256_set1_epi8(5);
         let b = _mm256_set1_epi8(3);
         let r = _mm256_xor_si256(a, b);
@@ -5372,7 +5380,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_alignr_epi8() {
+    const fn test_mm256_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -5428,7 +5436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_shuffle_epi8() {
+    fn test_mm256_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -5455,7 +5463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_permutevar8x32_epi32() {
+    fn test_mm256_permutevar8x32_epi32() {
         let a = _mm256_setr_epi32(100, 200, 300, 400, 500, 600, 700, 800);
         let b = _mm256_setr_epi32(5, 0, 5, 1, 7, 6, 3, 4);
         let expected = _mm256_setr_epi32(600, 100, 600, 200, 800, 700, 400, 500);
@@ -5464,7 +5472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_permute4x64_epi64() {
+    const fn test_mm256_permute4x64_epi64() {
         let a = _mm256_setr_epi64x(100, 200, 300, 400);
         let expected = _mm256_setr_epi64x(400, 100, 200, 100);
         let r = _mm256_permute4x64_epi64::<0b00010011>(a);
@@ -5472,7 +5480,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_permute2x128_si256() {
+    const fn test_mm256_permute2x128_si256() {
         let a = _mm256_setr_epi64x(100, 200, 500, 600);
         let b = _mm256_setr_epi64x(300, 400, 700, 800);
         let r = _mm256_permute2x128_si256::<0b00_01_00_11>(a, b);
@@ -5481,7 +5489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_permute4x64_pd() {
+    const fn test_mm256_permute4x64_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let r = _mm256_permute4x64_pd::<0b00_01_00_11>(a);
         let e = _mm256_setr_pd(4., 1., 2., 1.);
@@ -5489,7 +5497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    unsafe fn test_mm256_permutevar8x32_ps() {
+    fn test_mm256_permutevar8x32_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_epi32(5, 0, 5, 1, 7, 6, 3, 4);
         let r = _mm256_permutevar8x32_ps(a, b);
@@ -5839,7 +5847,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_extract_epi8() {
+    const fn test_mm256_extract_epi8() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi8(
             -1, 1, 2, 3, 4, 5, 6, 7,
@@ -5854,7 +5862,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx2")]
-    const unsafe fn test_mm256_extract_epi16() {
+    const fn test_mm256_extract_epi16() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi16(
             -1, 1, 2, 3, 4, 5, 6, 7,
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512bf16.rs b/library/stdarch/crates/core_arch/src/x86/avx512bf16.rs
index 85afd91fba7b..83dbc540a0c8 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512bf16.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512bf16.rs
@@ -1833,7 +1833,7 @@ mod tests {
     const BF16_EIGHT: u16 = 0b0_10000010_0000000;
 
     #[simd_test(enable = "avx512bf16")]
-    unsafe fn test_mm512_cvtpbh_ps() {
+    fn test_mm512_cvtpbh_ps() {
         let a = __m256bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
@@ -1846,7 +1846,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16")]
-    unsafe fn test_mm512_mask_cvtpbh_ps() {
+    fn test_mm512_mask_cvtpbh_ps() {
         let a = __m256bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
@@ -1863,7 +1863,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16")]
-    unsafe fn test_mm512_maskz_cvtpbh_ps() {
+    fn test_mm512_maskz_cvtpbh_ps() {
         let a = __m256bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
@@ -1877,7 +1877,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm256_cvtpbh_ps() {
+    fn test_mm256_cvtpbh_ps() {
         let a = __m128bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
         ]);
@@ -1887,7 +1887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpbh_ps() {
+    fn test_mm256_mask_cvtpbh_ps() {
         let a = __m128bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
         ]);
@@ -1899,7 +1899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpbh_ps() {
+    fn test_mm256_maskz_cvtpbh_ps() {
         let a = __m128bh([
             BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, BF16_FIVE, BF16_SIX, BF16_SEVEN, BF16_EIGHT,
         ]);
@@ -1910,7 +1910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm_cvtpbh_ps() {
+    fn test_mm_cvtpbh_ps() {
         let a = __m128bh([BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, 0, 0, 0, 0]);
         let r = _mm_cvtpbh_ps(a);
         let e = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -1918,7 +1918,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm_mask_cvtpbh_ps() {
+    fn test_mm_mask_cvtpbh_ps() {
         let a = __m128bh([BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, 0, 0, 0, 0]);
         let src = _mm_setr_ps(9., 10., 11., 12.);
         let k = 0b1010;
@@ -1928,7 +1928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpbh_ps() {
+    fn test_mm_maskz_cvtpbh_ps() {
         let a = __m128bh([BF16_ONE, BF16_TWO, BF16_THREE, BF16_FOUR, 0, 0, 0, 0]);
         let k = 0b1010;
         let r = _mm_maskz_cvtpbh_ps(k, a);
@@ -1937,7 +1937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16")]
-    unsafe fn test_mm_cvtsbh_ss() {
+    fn test_mm_cvtsbh_ss() {
         let r = _mm_cvtsbh_ss(bf16::from_bits(BF16_ONE));
         assert_eq!(r, 1.);
     }
@@ -1970,7 +1970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bf16,avx512vl")]
-    unsafe fn test_mm_cvtness_sbh() {
+    fn test_mm_cvtness_sbh() {
         let r = _mm_cvtness_sbh(1.);
         assert_eq!(r.to_bits(), BF16_ONE);
     }
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512bitalg.rs b/library/stdarch/crates/core_arch/src/x86/avx512bitalg.rs
index 497fa21c4fe1..6dd4e6b33a3b 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512bitalg.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512bitalg.rs
@@ -460,7 +460,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_popcnt_epi16() {
+    const fn test_mm512_popcnt_epi16() {
         let test_data = _mm512_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF, 0xFF_FF, -1, -100, 255, 256, 2, 4, 8, 16, 32, 64, 128, 256, 512,
@@ -475,7 +475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_maskz_popcnt_epi16() {
+    const fn test_mm512_maskz_popcnt_epi16() {
         let test_data = _mm512_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF, 0xFF_FF, -1, -100, 255, 256, 2, 4, 8, 16, 32, 64, 128, 256, 512,
@@ -491,7 +491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_mask_popcnt_epi16() {
+    const fn test_mm512_mask_popcnt_epi16() {
         let test_data = _mm512_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF, 0xFF_FF, -1, -100, 255, 256, 2, 4, 8, 16, 32, 64, 128, 256, 512,
@@ -507,7 +507,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_popcnt_epi16() {
+    const fn test_mm256_popcnt_epi16() {
         let test_data = _mm256_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF,
@@ -519,7 +519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_popcnt_epi16() {
+    const fn test_mm256_maskz_popcnt_epi16() {
         let test_data = _mm256_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF,
@@ -531,7 +531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_popcnt_epi16() {
+    const fn test_mm256_mask_popcnt_epi16() {
         let test_data = _mm256_set_epi16(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1_FF, 0x3_FF, 0x7_FF, 0xF_FF, 0x1F_FF,
             0x3F_FF, 0x7F_FF,
@@ -545,7 +545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_popcnt_epi16() {
+    const fn test_mm_popcnt_epi16() {
         let test_data = _mm_set_epi16(0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F);
         let actual_result = _mm_popcnt_epi16(test_data);
         let reference_result = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
@@ -553,7 +553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_popcnt_epi16() {
+    const fn test_mm_maskz_popcnt_epi16() {
         let test_data = _mm_set_epi16(0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F);
         let mask = 0xF0;
         let actual_result = _mm_maskz_popcnt_epi16(mask, test_data);
@@ -562,7 +562,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_popcnt_epi16() {
+    const fn test_mm_mask_popcnt_epi16() {
         let test_data = _mm_set_epi16(0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F);
         let mask = 0xF0;
         let actual_result = _mm_mask_popcnt_epi16(test_data, mask, test_data);
@@ -571,7 +571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_popcnt_epi8() {
+    const fn test_mm512_popcnt_epi8() {
         let test_data = _mm512_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 128, 171, 206, 100,
             217, 109, 253, 190, 177, 254, 179, 215, 230, 68, 201, 172, 183, 154, 84, 56, 227, 189,
@@ -588,7 +588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_maskz_popcnt_epi8() {
+    const fn test_mm512_maskz_popcnt_epi8() {
         let test_data = _mm512_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 128, 171, 206, 100,
             217, 109, 253, 190, 177, 254, 179, 215, 230, 68, 201, 172, 183, 154, 84, 56, 227, 189,
@@ -606,7 +606,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    const unsafe fn test_mm512_mask_popcnt_epi8() {
+    const fn test_mm512_mask_popcnt_epi8() {
         let test_data = _mm512_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 128, 171, 206, 100,
             217, 109, 253, 190, 177, 254, 179, 215, 230, 68, 201, 172, 183, 154, 84, 56, 227, 189,
@@ -624,7 +624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_popcnt_epi8() {
+    const fn test_mm256_popcnt_epi8() {
         let test_data = _mm256_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 128, 171, 206, 100,
             217, 109, 253, 190, 177, 254, 179, 215, 230, 68, 201, 172,
@@ -638,7 +638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_popcnt_epi8() {
+    const fn test_mm256_maskz_popcnt_epi8() {
         let test_data = _mm256_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 251, 73, 121, 143,
             145, 85, 91, 137, 90, 225, 21, 249, 211, 155, 228, 70,
@@ -653,7 +653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_popcnt_epi8() {
+    const fn test_mm256_mask_popcnt_epi8() {
         let test_data = _mm256_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64, 251, 73, 121, 143,
             145, 85, 91, 137, 90, 225, 21, 249, 211, 155, 228, 70,
@@ -668,7 +668,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_popcnt_epi8() {
+    const fn test_mm_popcnt_epi8() {
         let test_data = _mm_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, -1, 2, 4, 8, 16, 32, 64,
         );
@@ -678,7 +678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_popcnt_epi8() {
+    const fn test_mm_maskz_popcnt_epi8() {
         let test_data = _mm_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 90, 225, 21, 249, 211, 155, 228, 70,
         );
@@ -689,7 +689,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_popcnt_epi8() {
+    const fn test_mm_mask_popcnt_epi8() {
         let test_data = _mm_set_epi8(
             0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 90, 225, 21, 249, 211, 155, 228, 70,
         );
@@ -701,7 +701,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    unsafe fn test_mm512_bitshuffle_epi64_mask() {
+    fn test_mm512_bitshuffle_epi64_mask() {
         let test_indices = _mm512_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56, 32, 32, 16, 16, 0, 0,
             8, 8, 56, 48, 40, 32, 24, 16, 8, 0, 63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59,
@@ -731,7 +731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f")]
-    unsafe fn test_mm512_mask_bitshuffle_epi64_mask() {
+    fn test_mm512_mask_bitshuffle_epi64_mask() {
         let test_indices = _mm512_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56, 32, 32, 16, 16, 0, 0,
             8, 8, 56, 48, 40, 32, 24, 16, 8, 0, 63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59,
@@ -762,7 +762,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    unsafe fn test_mm256_bitshuffle_epi64_mask() {
+    fn test_mm256_bitshuffle_epi64_mask() {
         let test_indices = _mm256_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56, 32, 32, 16, 16, 0, 0,
             8, 8, 56, 48, 40, 32, 24, 16, 8, 0,
@@ -780,7 +780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_bitshuffle_epi64_mask() {
+    fn test_mm256_mask_bitshuffle_epi64_mask() {
         let test_indices = _mm256_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56, 32, 32, 16, 16, 0, 0,
             8, 8, 56, 48, 40, 32, 24, 16, 8, 0,
@@ -799,7 +799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    unsafe fn test_mm_bitshuffle_epi64_mask() {
+    fn test_mm_bitshuffle_epi64_mask() {
         let test_indices = _mm_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56,
         );
@@ -811,7 +811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bitalg,avx512f,avx512vl")]
-    unsafe fn test_mm_mask_bitshuffle_epi64_mask() {
+    fn test_mm_mask_bitshuffle_epi64_mask() {
         let test_indices = _mm_set_epi8(
             63, 62, 61, 60, 59, 58, 57, 56, 63, 62, 61, 60, 59, 58, 57, 56,
         );
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512bw.rs b/library/stdarch/crates/core_arch/src/x86/avx512bw.rs
index b6e941908a76..6b4b88621efd 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512bw.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512bw.rs
@@ -6321,22 +6321,20 @@ pub const unsafe fn _mm_mask_storeu_epi8(mem_addr: *mut i8, mask: __mmask16, a:
 #[target_feature(enable = "avx512bw")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm512_madd_epi16(a: __m512i, b: __m512i) -> __m512i {
-    unsafe {
-        let r: i32x32 = simd_mul(simd_cast(a.as_i16x32()), simd_cast(b.as_i16x32()));
-        let even: i32x16 = simd_shuffle!(
-            r,
-            r,
-            [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
-        );
-        let odd: i32x16 = simd_shuffle!(
-            r,
-            r,
-            [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]
-        );
-        simd_add(even, odd).as_m512i()
-    }
+pub fn _mm512_madd_epi16(a: __m512i, b: __m512i) -> __m512i {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
+    //
+    // ```rust
+    // #[target_feature(enable = "avx512bw")]
+    // unsafe fn widening_add(mad: __m512i) -> __m512i {
+    //     _mm512_madd_epi16(mad, _mm512_set1_epi16(1))
+    // }
+    // ```
+    //
+    // If we implement this using generic vector intrinsics, the optimizer
+    // will eliminate this pattern, and `vpmaddwd` will no longer be emitted.
+    // For this reason, we use x86 intrinsics.
+    unsafe { transmute(vpmaddwd(a.as_i16x32(), b.as_i16x32())) }
 }
 
 /// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).
@@ -6346,8 +6344,7 @@ pub const fn _mm512_madd_epi16(a: __m512i, b: __m512i) -> __m512i {
 #[target_feature(enable = "avx512bw")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm512_mask_madd_epi16(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
+pub fn _mm512_mask_madd_epi16(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
     unsafe {
         let madd = _mm512_madd_epi16(a, b).as_i32x16();
         transmute(simd_select_bitmask(k, madd, src.as_i32x16()))
@@ -6361,8 +6358,7 @@ pub const fn _mm512_mask_madd_epi16(src: __m512i, k: __mmask16, a: __m512i, b: _
 #[target_feature(enable = "avx512bw")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm512_maskz_madd_epi16(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
+pub fn _mm512_maskz_madd_epi16(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
     unsafe {
         let madd = _mm512_madd_epi16(a, b).as_i32x16();
         transmute(simd_select_bitmask(k, madd, i32x16::ZERO))
@@ -6376,8 +6372,7 @@ pub const fn _mm512_maskz_madd_epi16(k: __mmask16, a: __m512i, b: __m512i) -> __
 #[target_feature(enable = "avx512bw,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm256_mask_madd_epi16(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
+pub fn _mm256_mask_madd_epi16(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
     unsafe {
         let madd = _mm256_madd_epi16(a, b).as_i32x8();
         transmute(simd_select_bitmask(k, madd, src.as_i32x8()))
@@ -6391,8 +6386,7 @@ pub const fn _mm256_mask_madd_epi16(src: __m256i, k: __mmask8, a: __m256i, b: __
 #[target_feature(enable = "avx512bw,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm256_maskz_madd_epi16(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
+pub fn _mm256_maskz_madd_epi16(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
     unsafe {
         let madd = _mm256_madd_epi16(a, b).as_i32x8();
         transmute(simd_select_bitmask(k, madd, i32x8::ZERO))
@@ -6406,8 +6400,7 @@ pub const fn _mm256_maskz_madd_epi16(k: __mmask8, a: __m256i, b: __m256i) -> __m
 #[target_feature(enable = "avx512bw,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm_mask_madd_epi16(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
+pub fn _mm_mask_madd_epi16(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
     unsafe {
         let madd = _mm_madd_epi16(a, b).as_i32x4();
         transmute(simd_select_bitmask(k, madd, src.as_i32x4()))
@@ -6421,8 +6414,7 @@ pub const fn _mm_mask_madd_epi16(src: __m128i, k: __mmask8, a: __m128i, b: __m12
 #[target_feature(enable = "avx512bw,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm_maskz_madd_epi16(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
+pub fn _mm_maskz_madd_epi16(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
     unsafe {
         let madd = _mm_madd_epi16(a, b).as_i32x4();
         transmute(simd_select_bitmask(k, madd, i32x4::ZERO))
@@ -12582,6 +12574,8 @@ unsafe extern "C" {
     #[link_name = "llvm.x86.avx512.pmul.hr.sw.512"]
     fn vpmulhrsw(a: i16x32, b: i16x32) -> i16x32;
 
+    #[link_name = "llvm.x86.avx512.pmaddw.d.512"]
+    fn vpmaddwd(a: i16x32, b: i16x32) -> i32x16;
     #[link_name = "llvm.x86.avx512.pmaddubs.w.512"]
     fn vpmaddubsw(a: u8x64, b: i8x64) -> i16x32;
 
@@ -12662,7 +12656,7 @@ mod tests {
     use crate::mem::{self};
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_abs_epi16() {
+    const fn test_mm512_abs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let r = _mm512_abs_epi16(a);
         let e = _mm512_set1_epi16(1);
@@ -12670,7 +12664,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_abs_epi16() {
+    const fn test_mm512_mask_abs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let r = _mm512_mask_abs_epi16(a, 0, a);
         assert_eq_m512i(r, a);
@@ -12682,7 +12676,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_abs_epi16() {
+    const fn test_mm512_maskz_abs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let r = _mm512_maskz_abs_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -12694,7 +12688,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_abs_epi16() {
+    const fn test_mm256_mask_abs_epi16() {
         let a = _mm256_set1_epi16(-1);
         let r = _mm256_mask_abs_epi16(a, 0, a);
         assert_eq_m256i(r, a);
@@ -12704,7 +12698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_abs_epi16() {
+    const fn test_mm256_maskz_abs_epi16() {
         let a = _mm256_set1_epi16(-1);
         let r = _mm256_maskz_abs_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -12714,7 +12708,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_abs_epi16() {
+    const fn test_mm_mask_abs_epi16() {
         let a = _mm_set1_epi16(-1);
         let r = _mm_mask_abs_epi16(a, 0, a);
         assert_eq_m128i(r, a);
@@ -12724,7 +12718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_abs_epi16() {
+    const fn test_mm_maskz_abs_epi16() {
         let a = _mm_set1_epi16(-1);
         let r = _mm_maskz_abs_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -12734,7 +12728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_abs_epi8() {
+    const fn test_mm512_abs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let r = _mm512_abs_epi8(a);
         let e = _mm512_set1_epi8(1);
@@ -12742,7 +12736,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_abs_epi8() {
+    const fn test_mm512_mask_abs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let r = _mm512_mask_abs_epi8(a, 0, a);
         assert_eq_m512i(r, a);
@@ -12760,7 +12754,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_abs_epi8() {
+    const fn test_mm512_maskz_abs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let r = _mm512_maskz_abs_epi8(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -12777,7 +12771,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_abs_epi8() {
+    const fn test_mm256_mask_abs_epi8() {
         let a = _mm256_set1_epi8(-1);
         let r = _mm256_mask_abs_epi8(a, 0, a);
         assert_eq_m256i(r, a);
@@ -12789,7 +12783,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_abs_epi8() {
+    const fn test_mm256_maskz_abs_epi8() {
         let a = _mm256_set1_epi8(-1);
         let r = _mm256_maskz_abs_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -12801,7 +12795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_abs_epi8() {
+    const fn test_mm_mask_abs_epi8() {
         let a = _mm_set1_epi8(-1);
         let r = _mm_mask_abs_epi8(a, 0, a);
         assert_eq_m128i(r, a);
@@ -12811,7 +12805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_abs_epi8() {
+    const fn test_mm_maskz_abs_epi8() {
         let a = _mm_set1_epi8(-1);
         let r = _mm_maskz_abs_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -12822,7 +12816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_add_epi16() {
+    const fn test_mm512_add_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_add_epi16(a, b);
@@ -12831,7 +12825,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_add_epi16() {
+    const fn test_mm512_mask_add_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_mask_add_epi16(a, 0, a, b);
@@ -12844,7 +12838,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_add_epi16() {
+    const fn test_mm512_maskz_add_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_maskz_add_epi16(0, a, b);
@@ -12857,7 +12851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_add_epi16() {
+    const fn test_mm256_mask_add_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_mask_add_epi16(a, 0, a, b);
@@ -12868,7 +12862,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_epi16() {
+    const fn test_mm256_maskz_add_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_maskz_add_epi16(0, a, b);
@@ -12879,7 +12873,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_add_epi16() {
+    const fn test_mm_mask_add_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(2);
         let r = _mm_mask_add_epi16(a, 0, a, b);
@@ -12890,7 +12884,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_add_epi16() {
+    const fn test_mm_maskz_add_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(2);
         let r = _mm_maskz_add_epi16(0, a, b);
@@ -12901,7 +12895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_add_epi8() {
+    const fn test_mm512_add_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_add_epi8(a, b);
@@ -12910,7 +12904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_add_epi8() {
+    const fn test_mm512_mask_add_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_mask_add_epi8(a, 0, a, b);
@@ -12930,7 +12924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_add_epi8() {
+    const fn test_mm512_maskz_add_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_maskz_add_epi8(0, a, b);
@@ -12949,7 +12943,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_add_epi8() {
+    const fn test_mm256_mask_add_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_mask_add_epi8(a, 0, a, b);
@@ -12962,7 +12956,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_epi8() {
+    const fn test_mm256_maskz_add_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_maskz_add_epi8(0, a, b);
@@ -12975,7 +12969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_add_epi8() {
+    const fn test_mm_mask_add_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(2);
         let r = _mm_mask_add_epi8(a, 0, a, b);
@@ -12986,7 +12980,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_add_epi8() {
+    const fn test_mm_maskz_add_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(2);
         let r = _mm_maskz_add_epi8(0, a, b);
@@ -12997,7 +12991,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_adds_epu16() {
+    const fn test_mm512_adds_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_adds_epu16(a, b);
@@ -13006,7 +13000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_adds_epu16() {
+    const fn test_mm512_mask_adds_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_mask_adds_epu16(a, 0, a, b);
@@ -13019,7 +13013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_adds_epu16() {
+    const fn test_mm512_maskz_adds_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_maskz_adds_epu16(0, a, b);
@@ -13032,7 +13026,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_adds_epu16() {
+    const fn test_mm256_mask_adds_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(u16::MAX as i16);
         let r = _mm256_mask_adds_epu16(a, 0, a, b);
@@ -13044,7 +13038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_adds_epu16() {
+    const fn test_mm256_maskz_adds_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(u16::MAX as i16);
         let r = _mm256_maskz_adds_epu16(0, a, b);
@@ -13056,7 +13050,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_adds_epu16() {
+    const fn test_mm_mask_adds_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(u16::MAX as i16);
         let r = _mm_mask_adds_epu16(a, 0, a, b);
@@ -13068,7 +13062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_adds_epu16() {
+    const fn test_mm_maskz_adds_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(u16::MAX as i16);
         let r = _mm_maskz_adds_epu16(0, a, b);
@@ -13080,7 +13074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_adds_epu8() {
+    const fn test_mm512_adds_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_adds_epu8(a, b);
@@ -13089,7 +13083,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_adds_epu8() {
+    const fn test_mm512_mask_adds_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_mask_adds_epu8(a, 0, a, b);
@@ -13109,7 +13103,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_adds_epu8() {
+    const fn test_mm512_maskz_adds_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_maskz_adds_epu8(0, a, b);
@@ -13128,7 +13122,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_adds_epu8() {
+    const fn test_mm256_mask_adds_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(u8::MAX as i8);
         let r = _mm256_mask_adds_epu8(a, 0, a, b);
@@ -13141,7 +13135,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_adds_epu8() {
+    const fn test_mm256_maskz_adds_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(u8::MAX as i8);
         let r = _mm256_maskz_adds_epu8(0, a, b);
@@ -13154,7 +13148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_adds_epu8() {
+    const fn test_mm_mask_adds_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(u8::MAX as i8);
         let r = _mm_mask_adds_epu8(a, 0, a, b);
@@ -13166,7 +13160,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_adds_epu8() {
+    const fn test_mm_maskz_adds_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(u8::MAX as i8);
         let r = _mm_maskz_adds_epu8(0, a, b);
@@ -13178,7 +13172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_adds_epi16() {
+    const fn test_mm512_adds_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_adds_epi16(a, b);
@@ -13187,7 +13181,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_adds_epi16() {
+    const fn test_mm512_mask_adds_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_mask_adds_epi16(a, 0, a, b);
@@ -13200,7 +13194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_adds_epi16() {
+    const fn test_mm512_maskz_adds_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_maskz_adds_epi16(0, a, b);
@@ -13213,7 +13207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_adds_epi16() {
+    const fn test_mm256_mask_adds_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_mask_adds_epi16(a, 0, a, b);
@@ -13225,7 +13219,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_adds_epi16() {
+    const fn test_mm256_maskz_adds_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_maskz_adds_epi16(0, a, b);
@@ -13237,7 +13231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_adds_epi16() {
+    const fn test_mm_mask_adds_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(i16::MAX);
         let r = _mm_mask_adds_epi16(a, 0, a, b);
@@ -13248,7 +13242,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_adds_epi16() {
+    const fn test_mm_maskz_adds_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(i16::MAX);
         let r = _mm_maskz_adds_epi16(0, a, b);
@@ -13259,7 +13253,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_adds_epi8() {
+    const fn test_mm512_adds_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_adds_epi8(a, b);
@@ -13268,7 +13262,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_adds_epi8() {
+    const fn test_mm512_mask_adds_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_mask_adds_epi8(a, 0, a, b);
@@ -13288,7 +13282,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_adds_epi8() {
+    const fn test_mm512_maskz_adds_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_maskz_adds_epi8(0, a, b);
@@ -13307,7 +13301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_adds_epi8() {
+    const fn test_mm256_mask_adds_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(i8::MAX);
         let r = _mm256_mask_adds_epi8(a, 0, a, b);
@@ -13320,7 +13314,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_adds_epi8() {
+    const fn test_mm256_maskz_adds_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(i8::MAX);
         let r = _mm256_maskz_adds_epi8(0, a, b);
@@ -13333,7 +13327,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_adds_epi8() {
+    const fn test_mm_mask_adds_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(i8::MAX);
         let r = _mm_mask_adds_epi8(a, 0, a, b);
@@ -13345,7 +13339,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_adds_epi8() {
+    const fn test_mm_maskz_adds_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(i8::MAX);
         let r = _mm_maskz_adds_epi8(0, a, b);
@@ -13357,7 +13351,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_sub_epi16() {
+    const fn test_mm512_sub_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_sub_epi16(a, b);
@@ -13366,7 +13360,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_sub_epi16() {
+    const fn test_mm512_mask_sub_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_mask_sub_epi16(a, 0, a, b);
@@ -13379,7 +13373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_sub_epi16() {
+    const fn test_mm512_maskz_sub_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_maskz_sub_epi16(0, a, b);
@@ -13392,7 +13386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_epi16() {
+    const fn test_mm256_mask_sub_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_mask_sub_epi16(a, 0, a, b);
@@ -13403,7 +13397,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_epi16() {
+    const fn test_mm256_maskz_sub_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_maskz_sub_epi16(0, a, b);
@@ -13414,7 +13408,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_sub_epi16() {
+    const fn test_mm_mask_sub_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(2);
         let r = _mm_mask_sub_epi16(a, 0, a, b);
@@ -13425,7 +13419,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_epi16() {
+    const fn test_mm_maskz_sub_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(2);
         let r = _mm_maskz_sub_epi16(0, a, b);
@@ -13436,7 +13430,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_sub_epi8() {
+    const fn test_mm512_sub_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_sub_epi8(a, b);
@@ -13445,7 +13439,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_sub_epi8() {
+    const fn test_mm512_mask_sub_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_mask_sub_epi8(a, 0, a, b);
@@ -13465,7 +13459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_sub_epi8() {
+    const fn test_mm512_maskz_sub_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_maskz_sub_epi8(0, a, b);
@@ -13484,7 +13478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_epi8() {
+    const fn test_mm256_mask_sub_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_mask_sub_epi8(a, 0, a, b);
@@ -13497,7 +13491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_epi8() {
+    const fn test_mm256_maskz_sub_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_maskz_sub_epi8(0, a, b);
@@ -13510,7 +13504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_sub_epi8() {
+    const fn test_mm_mask_sub_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(2);
         let r = _mm_mask_sub_epi8(a, 0, a, b);
@@ -13521,7 +13515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_epi8() {
+    const fn test_mm_maskz_sub_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(2);
         let r = _mm_maskz_sub_epi8(0, a, b);
@@ -13532,7 +13526,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_subs_epu16() {
+    const fn test_mm512_subs_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_subs_epu16(a, b);
@@ -13541,7 +13535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_subs_epu16() {
+    const fn test_mm512_mask_subs_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_mask_subs_epu16(a, 0, a, b);
@@ -13554,7 +13548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_subs_epu16() {
+    const fn test_mm512_maskz_subs_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(u16::MAX as i16);
         let r = _mm512_maskz_subs_epu16(0, a, b);
@@ -13567,7 +13561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_subs_epu16() {
+    const fn test_mm256_mask_subs_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(u16::MAX as i16);
         let r = _mm256_mask_subs_epu16(a, 0, a, b);
@@ -13578,7 +13572,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_subs_epu16() {
+    const fn test_mm256_maskz_subs_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(u16::MAX as i16);
         let r = _mm256_maskz_subs_epu16(0, a, b);
@@ -13589,7 +13583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_subs_epu16() {
+    const fn test_mm_mask_subs_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(u16::MAX as i16);
         let r = _mm_mask_subs_epu16(a, 0, a, b);
@@ -13600,7 +13594,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_subs_epu16() {
+    const fn test_mm_maskz_subs_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(u16::MAX as i16);
         let r = _mm_maskz_subs_epu16(0, a, b);
@@ -13611,7 +13605,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_subs_epu8() {
+    const fn test_mm512_subs_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_subs_epu8(a, b);
@@ -13620,7 +13614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_subs_epu8() {
+    const fn test_mm512_mask_subs_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_mask_subs_epu8(a, 0, a, b);
@@ -13640,7 +13634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_subs_epu8() {
+    const fn test_mm512_maskz_subs_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(u8::MAX as i8);
         let r = _mm512_maskz_subs_epu8(0, a, b);
@@ -13659,7 +13653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_subs_epu8() {
+    const fn test_mm256_mask_subs_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(u8::MAX as i8);
         let r = _mm256_mask_subs_epu8(a, 0, a, b);
@@ -13672,7 +13666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_subs_epu8() {
+    const fn test_mm256_maskz_subs_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(u8::MAX as i8);
         let r = _mm256_maskz_subs_epu8(0, a, b);
@@ -13685,7 +13679,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_subs_epu8() {
+    const fn test_mm_mask_subs_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(u8::MAX as i8);
         let r = _mm_mask_subs_epu8(a, 0, a, b);
@@ -13696,7 +13690,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_subs_epu8() {
+    const fn test_mm_maskz_subs_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(u8::MAX as i8);
         let r = _mm_maskz_subs_epu8(0, a, b);
@@ -13707,7 +13701,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_subs_epi16() {
+    const fn test_mm512_subs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_subs_epi16(a, b);
@@ -13716,7 +13710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_subs_epi16() {
+    const fn test_mm512_mask_subs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_mask_subs_epi16(a, 0, a, b);
@@ -13729,7 +13723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_subs_epi16() {
+    const fn test_mm512_maskz_subs_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_maskz_subs_epi16(0, a, b);
@@ -13742,7 +13736,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_subs_epi16() {
+    const fn test_mm256_mask_subs_epi16() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_mask_subs_epi16(a, 0, a, b);
@@ -13754,7 +13748,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_subs_epi16() {
+    const fn test_mm256_maskz_subs_epi16() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_maskz_subs_epi16(0, a, b);
@@ -13766,7 +13760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_subs_epi16() {
+    const fn test_mm_mask_subs_epi16() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(i16::MAX);
         let r = _mm_mask_subs_epi16(a, 0, a, b);
@@ -13777,7 +13771,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_subs_epi16() {
+    const fn test_mm_maskz_subs_epi16() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(i16::MAX);
         let r = _mm_maskz_subs_epi16(0, a, b);
@@ -13788,7 +13782,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_subs_epi8() {
+    const fn test_mm512_subs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_subs_epi8(a, b);
@@ -13797,7 +13791,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_subs_epi8() {
+    const fn test_mm512_mask_subs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_mask_subs_epi8(a, 0, a, b);
@@ -13817,7 +13811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_subs_epi8() {
+    const fn test_mm512_maskz_subs_epi8() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(i8::MAX);
         let r = _mm512_maskz_subs_epi8(0, a, b);
@@ -13836,7 +13830,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_subs_epi8() {
+    const fn test_mm256_mask_subs_epi8() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(i8::MAX);
         let r = _mm256_mask_subs_epi8(a, 0, a, b);
@@ -13849,7 +13843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_subs_epi8() {
+    const fn test_mm256_maskz_subs_epi8() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(i8::MAX);
         let r = _mm256_maskz_subs_epi8(0, a, b);
@@ -13862,7 +13856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_subs_epi8() {
+    const fn test_mm_mask_subs_epi8() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(i8::MAX);
         let r = _mm_mask_subs_epi8(a, 0, a, b);
@@ -13874,7 +13868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_subs_epi8() {
+    const fn test_mm_maskz_subs_epi8() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(i8::MAX);
         let r = _mm_maskz_subs_epi8(0, a, b);
@@ -13886,7 +13880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mulhi_epu16() {
+    const fn test_mm512_mulhi_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mulhi_epu16(a, b);
@@ -13895,7 +13889,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_mulhi_epu16() {
+    const fn test_mm512_mask_mulhi_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_mulhi_epu16(a, 0, a, b);
@@ -13908,7 +13902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_mulhi_epu16() {
+    const fn test_mm512_maskz_mulhi_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_mulhi_epu16(0, a, b);
@@ -13921,7 +13915,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_mulhi_epu16() {
+    const fn test_mm256_mask_mulhi_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_mulhi_epu16(a, 0, a, b);
@@ -13932,7 +13926,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_mulhi_epu16() {
+    const fn test_mm256_maskz_mulhi_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_mulhi_epu16(0, a, b);
@@ -13943,7 +13937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_mulhi_epu16() {
+    const fn test_mm_mask_mulhi_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_mulhi_epu16(a, 0, a, b);
@@ -13954,7 +13948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_mulhi_epu16() {
+    const fn test_mm_maskz_mulhi_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_mulhi_epu16(0, a, b);
@@ -13965,7 +13959,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mulhi_epi16() {
+    const fn test_mm512_mulhi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mulhi_epi16(a, b);
@@ -13974,7 +13968,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_mulhi_epi16() {
+    const fn test_mm512_mask_mulhi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_mulhi_epi16(a, 0, a, b);
@@ -13987,7 +13981,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_mulhi_epi16() {
+    const fn test_mm512_maskz_mulhi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_mulhi_epi16(0, a, b);
@@ -14000,7 +13994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_mulhi_epi16() {
+    const fn test_mm256_mask_mulhi_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_mulhi_epi16(a, 0, a, b);
@@ -14011,7 +14005,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_mulhi_epi16() {
+    const fn test_mm256_maskz_mulhi_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_mulhi_epi16(0, a, b);
@@ -14022,7 +14016,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_mulhi_epi16() {
+    const fn test_mm_mask_mulhi_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_mulhi_epi16(a, 0, a, b);
@@ -14033,7 +14027,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_mulhi_epi16() {
+    const fn test_mm_maskz_mulhi_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_mulhi_epi16(0, a, b);
@@ -14044,7 +14038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mulhrs_epi16() {
+    fn test_mm512_mulhrs_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mulhrs_epi16(a, b);
@@ -14053,7 +14047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_mulhrs_epi16() {
+    fn test_mm512_mask_mulhrs_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_mulhrs_epi16(a, 0, a, b);
@@ -14066,7 +14060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_mulhrs_epi16() {
+    fn test_mm512_maskz_mulhrs_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_mulhrs_epi16(0, a, b);
@@ -14079,7 +14073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_mulhrs_epi16() {
+    fn test_mm256_mask_mulhrs_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_mulhrs_epi16(a, 0, a, b);
@@ -14090,7 +14084,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_mulhrs_epi16() {
+    fn test_mm256_maskz_mulhrs_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_mulhrs_epi16(0, a, b);
@@ -14101,7 +14095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_mulhrs_epi16() {
+    fn test_mm_mask_mulhrs_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_mulhrs_epi16(a, 0, a, b);
@@ -14112,7 +14106,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_mulhrs_epi16() {
+    fn test_mm_maskz_mulhrs_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_mulhrs_epi16(0, a, b);
@@ -14123,7 +14117,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mullo_epi16() {
+    const fn test_mm512_mullo_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mullo_epi16(a, b);
@@ -14132,7 +14126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_mullo_epi16() {
+    const fn test_mm512_mask_mullo_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_mullo_epi16(a, 0, a, b);
@@ -14145,7 +14139,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_mullo_epi16() {
+    const fn test_mm512_maskz_mullo_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_mullo_epi16(0, a, b);
@@ -14158,7 +14152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_mullo_epi16() {
+    const fn test_mm256_mask_mullo_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_mullo_epi16(a, 0, a, b);
@@ -14169,7 +14163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_mullo_epi16() {
+    const fn test_mm256_maskz_mullo_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_mullo_epi16(0, a, b);
@@ -14180,7 +14174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_mullo_epi16() {
+    const fn test_mm_mask_mullo_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_mullo_epi16(a, 0, a, b);
@@ -14191,7 +14185,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_mullo_epi16() {
+    const fn test_mm_maskz_mullo_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_mullo_epi16(0, a, b);
@@ -14202,7 +14196,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_max_epu16() {
+    const fn test_mm512_max_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14217,7 +14211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_max_epu16() {
+    const fn test_mm512_mask_max_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14234,7 +14228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_max_epu16() {
+    const fn test_mm512_maskz_max_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14251,7 +14245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epu16() {
+    const fn test_mm256_mask_max_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_max_epu16(a, 0, a, b);
@@ -14262,7 +14256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epu16() {
+    const fn test_mm256_maskz_max_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_max_epu16(0, a, b);
@@ -14273,7 +14267,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_max_epu16() {
+    const fn test_mm_mask_max_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_max_epu16(a, 0, a, b);
@@ -14284,7 +14278,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epu16() {
+    const fn test_mm_maskz_max_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_max_epu16(0, a, b);
@@ -14295,7 +14289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_max_epu8() {
+    const fn test_mm512_max_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14316,7 +14310,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_max_epu8() {
+    const fn test_mm512_mask_max_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14344,7 +14338,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_max_epu8() {
+    const fn test_mm512_maskz_max_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14371,7 +14365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epu8() {
+    const fn test_mm256_mask_max_epu8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14388,7 +14382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epu8() {
+    const fn test_mm256_maskz_max_epu8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14405,7 +14399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_max_epu8() {
+    const fn test_mm_mask_max_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_max_epu8(a, 0, a, b);
@@ -14416,7 +14410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epu8() {
+    const fn test_mm_maskz_max_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_max_epu8(0, a, b);
@@ -14427,7 +14421,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_max_epi16() {
+    const fn test_mm512_max_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14442,7 +14436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_max_epi16() {
+    const fn test_mm512_mask_max_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14459,7 +14453,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_max_epi16() {
+    const fn test_mm512_maskz_max_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14476,7 +14470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epi16() {
+    const fn test_mm256_mask_max_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_max_epi16(a, 0, a, b);
@@ -14487,7 +14481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epi16() {
+    const fn test_mm256_maskz_max_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_max_epi16(0, a, b);
@@ -14498,7 +14492,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_max_epi16() {
+    const fn test_mm_mask_max_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_max_epi16(a, 0, a, b);
@@ -14509,7 +14503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epi16() {
+    const fn test_mm_maskz_max_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_max_epi16(0, a, b);
@@ -14520,7 +14514,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_max_epi8() {
+    const fn test_mm512_max_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14541,7 +14535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_max_epi8() {
+    const fn test_mm512_mask_max_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14569,7 +14563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_max_epi8() {
+    const fn test_mm512_maskz_max_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14596,7 +14590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epi8() {
+    const fn test_mm256_mask_max_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14613,7 +14607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epi8() {
+    const fn test_mm256_maskz_max_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14630,7 +14624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_max_epi8() {
+    const fn test_mm_mask_max_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_max_epi8(a, 0, a, b);
@@ -14641,7 +14635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epi8() {
+    const fn test_mm_maskz_max_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_max_epi8(0, a, b);
@@ -14652,7 +14646,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_min_epu16() {
+    const fn test_mm512_min_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14667,7 +14661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_min_epu16() {
+    const fn test_mm512_mask_min_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14684,7 +14678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_min_epu16() {
+    const fn test_mm512_maskz_min_epu16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14701,7 +14695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epu16() {
+    const fn test_mm256_mask_min_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_min_epu16(a, 0, a, b);
@@ -14712,7 +14706,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epu16() {
+    const fn test_mm256_maskz_min_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_min_epu16(0, a, b);
@@ -14723,7 +14717,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_min_epu16() {
+    const fn test_mm_mask_min_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_min_epu16(a, 0, a, b);
@@ -14734,7 +14728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epu16() {
+    const fn test_mm_maskz_min_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_min_epu16(0, a, b);
@@ -14745,7 +14739,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_min_epu8() {
+    const fn test_mm512_min_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14766,7 +14760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_min_epu8() {
+    const fn test_mm512_mask_min_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14794,7 +14788,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_min_epu8() {
+    const fn test_mm512_maskz_min_epu8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14821,7 +14815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epu8() {
+    const fn test_mm256_mask_min_epu8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14838,7 +14832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epu8() {
+    const fn test_mm256_maskz_min_epu8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14855,7 +14849,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_min_epu8() {
+    const fn test_mm_mask_min_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_min_epu8(a, 0, a, b);
@@ -14866,7 +14860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epu8() {
+    const fn test_mm_maskz_min_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_min_epu8(0, a, b);
@@ -14877,7 +14871,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_min_epi16() {
+    const fn test_mm512_min_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14892,7 +14886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_min_epi16() {
+    const fn test_mm512_mask_min_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14909,7 +14903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_min_epi16() {
+    const fn test_mm512_maskz_min_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -14926,7 +14920,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epi16() {
+    const fn test_mm256_mask_min_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_min_epi16(a, 0, a, b);
@@ -14937,7 +14931,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epi16() {
+    const fn test_mm256_maskz_min_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm256_set_epi16(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_min_epi16(0, a, b);
@@ -14948,7 +14942,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_min_epi16() {
+    const fn test_mm_mask_min_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_min_epi16(a, 0, a, b);
@@ -14959,7 +14953,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epi16() {
+    const fn test_mm_maskz_min_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_set_epi16(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_min_epi16(0, a, b);
@@ -14970,7 +14964,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_min_epi8() {
+    const fn test_mm512_min_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -14991,7 +14985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_min_epi8() {
+    const fn test_mm512_mask_min_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -15019,7 +15013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_min_epi8() {
+    const fn test_mm512_maskz_min_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -15046,7 +15040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epi8() {
+    const fn test_mm256_mask_min_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -15063,7 +15057,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epi8() {
+    const fn test_mm256_maskz_min_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -15080,7 +15074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_min_epi8() {
+    const fn test_mm_mask_min_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_mask_min_epi8(a, 0, a, b);
@@ -15091,7 +15085,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epi8() {
+    const fn test_mm_maskz_min_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_maskz_min_epi8(0, a, b);
@@ -15102,7 +15096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmplt_epu16_mask() {
+    const fn test_mm512_cmplt_epu16_mask() {
         let a = _mm512_set1_epi16(-2);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmplt_epu16_mask(a, b);
@@ -15110,7 +15104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmplt_epu16_mask() {
+    const fn test_mm512_mask_cmplt_epu16_mask() {
         let a = _mm512_set1_epi16(-2);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15119,7 +15113,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epu16_mask() {
+    const fn test_mm256_cmplt_epu16_mask() {
         let a = _mm256_set1_epi16(-2);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmplt_epu16_mask(a, b);
@@ -15127,7 +15121,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epu16_mask() {
+    const fn test_mm256_mask_cmplt_epu16_mask() {
         let a = _mm256_set1_epi16(-2);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -15136,7 +15130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmplt_epu16_mask() {
+    const fn test_mm_cmplt_epu16_mask() {
         let a = _mm_set1_epi16(-2);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmplt_epu16_mask(a, b);
@@ -15144,7 +15138,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epu16_mask() {
+    const fn test_mm_mask_cmplt_epu16_mask() {
         let a = _mm_set1_epi16(-2);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15153,7 +15147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmplt_epu8_mask() {
+    const fn test_mm512_cmplt_epu8_mask() {
         let a = _mm512_set1_epi8(-2);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmplt_epu8_mask(a, b);
@@ -15164,7 +15158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmplt_epu8_mask() {
+    const fn test_mm512_mask_cmplt_epu8_mask() {
         let a = _mm512_set1_epi8(-2);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15176,7 +15170,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epu8_mask() {
+    const fn test_mm256_cmplt_epu8_mask() {
         let a = _mm256_set1_epi8(-2);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmplt_epu8_mask(a, b);
@@ -15184,7 +15178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epu8_mask() {
+    const fn test_mm256_mask_cmplt_epu8_mask() {
         let a = _mm256_set1_epi8(-2);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15193,7 +15187,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmplt_epu8_mask() {
+    const fn test_mm_cmplt_epu8_mask() {
         let a = _mm_set1_epi8(-2);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmplt_epu8_mask(a, b);
@@ -15201,7 +15195,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epu8_mask() {
+    const fn test_mm_mask_cmplt_epu8_mask() {
         let a = _mm_set1_epi8(-2);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15210,7 +15204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmplt_epi16_mask() {
+    const fn test_mm512_cmplt_epi16_mask() {
         let a = _mm512_set1_epi16(-2);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmplt_epi16_mask(a, b);
@@ -15218,7 +15212,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmplt_epi16_mask() {
+    const fn test_mm512_mask_cmplt_epi16_mask() {
         let a = _mm512_set1_epi16(-2);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15227,7 +15221,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epi16_mask() {
+    const fn test_mm256_cmplt_epi16_mask() {
         let a = _mm256_set1_epi16(-2);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmplt_epi16_mask(a, b);
@@ -15235,7 +15229,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epi16_mask() {
+    const fn test_mm256_mask_cmplt_epi16_mask() {
         let a = _mm256_set1_epi16(-2);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -15244,7 +15238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmplt_epi16_mask() {
+    const fn test_mm_cmplt_epi16_mask() {
         let a = _mm_set1_epi16(-2);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmplt_epi16_mask(a, b);
@@ -15252,7 +15246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epi16_mask() {
+    const fn test_mm_mask_cmplt_epi16_mask() {
         let a = _mm_set1_epi16(-2);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15261,7 +15255,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmplt_epi8_mask() {
+    const fn test_mm512_cmplt_epi8_mask() {
         let a = _mm512_set1_epi8(-2);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmplt_epi8_mask(a, b);
@@ -15272,7 +15266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmplt_epi8_mask() {
+    const fn test_mm512_mask_cmplt_epi8_mask() {
         let a = _mm512_set1_epi8(-2);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15284,7 +15278,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epi8_mask() {
+    const fn test_mm256_cmplt_epi8_mask() {
         let a = _mm256_set1_epi8(-2);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmplt_epi8_mask(a, b);
@@ -15292,7 +15286,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epi8_mask() {
+    const fn test_mm256_mask_cmplt_epi8_mask() {
         let a = _mm256_set1_epi8(-2);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15301,7 +15295,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmplt_epi8_mask() {
+    const fn test_mm_cmplt_epi8_mask() {
         let a = _mm_set1_epi8(-2);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmplt_epi8_mask(a, b);
@@ -15309,7 +15303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epi8_mask() {
+    const fn test_mm_mask_cmplt_epi8_mask() {
         let a = _mm_set1_epi8(-2);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15318,7 +15312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpgt_epu16_mask() {
+    const fn test_mm512_cmpgt_epu16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmpgt_epu16_mask(a, b);
@@ -15326,7 +15320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpgt_epu16_mask() {
+    const fn test_mm512_mask_cmpgt_epu16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15335,7 +15329,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epu16_mask() {
+    const fn test_mm256_cmpgt_epu16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmpgt_epu16_mask(a, b);
@@ -15343,7 +15337,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epu16_mask() {
+    const fn test_mm256_mask_cmpgt_epu16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -15352,7 +15346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epu16_mask() {
+    const fn test_mm_cmpgt_epu16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmpgt_epu16_mask(a, b);
@@ -15360,7 +15354,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epu16_mask() {
+    const fn test_mm_mask_cmpgt_epu16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -15369,7 +15363,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpgt_epu8_mask() {
+    const fn test_mm512_cmpgt_epu8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmpgt_epu8_mask(a, b);
@@ -15380,7 +15374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpgt_epu8_mask() {
+    const fn test_mm512_mask_cmpgt_epu8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15392,7 +15386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epu8_mask() {
+    const fn test_mm256_cmpgt_epu8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmpgt_epu8_mask(a, b);
@@ -15400,7 +15394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epu8_mask() {
+    const fn test_mm256_mask_cmpgt_epu8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15409,7 +15403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epu8_mask() {
+    const fn test_mm_cmpgt_epu8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmpgt_epu8_mask(a, b);
@@ -15417,7 +15411,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epu8_mask() {
+    const fn test_mm_mask_cmpgt_epu8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -15426,7 +15420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpgt_epi16_mask() {
+    const fn test_mm512_cmpgt_epi16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmpgt_epi16_mask(a, b);
@@ -15434,7 +15428,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpgt_epi16_mask() {
+    const fn test_mm512_mask_cmpgt_epi16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15443,7 +15437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epi16_mask() {
+    const fn test_mm256_cmpgt_epi16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmpgt_epi16_mask(a, b);
@@ -15451,7 +15445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epi16_mask() {
+    const fn test_mm256_mask_cmpgt_epi16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b001010101_01010101;
@@ -15460,7 +15454,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epi16_mask() {
+    const fn test_mm_cmpgt_epi16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmpgt_epi16_mask(a, b);
@@ -15468,7 +15462,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epi16_mask() {
+    const fn test_mm_mask_cmpgt_epi16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15477,7 +15471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpgt_epi8_mask() {
+    const fn test_mm512_cmpgt_epi8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmpgt_epi8_mask(a, b);
@@ -15488,7 +15482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpgt_epi8_mask() {
+    const fn test_mm512_mask_cmpgt_epi8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15500,7 +15494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epi8_mask() {
+    const fn test_mm256_cmpgt_epi8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmpgt_epi8_mask(a, b);
@@ -15508,7 +15502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epi8_mask() {
+    const fn test_mm256_mask_cmpgt_epi8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15517,7 +15511,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epi8_mask() {
+    const fn test_mm_cmpgt_epi8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmpgt_epi8_mask(a, b);
@@ -15525,7 +15519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epi8_mask() {
+    const fn test_mm_mask_cmpgt_epi8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15534,7 +15528,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmple_epu16_mask() {
+    const fn test_mm512_cmple_epu16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmple_epu16_mask(a, b);
@@ -15542,7 +15536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmple_epu16_mask() {
+    const fn test_mm512_mask_cmple_epu16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15551,7 +15545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmple_epu16_mask() {
+    const fn test_mm256_cmple_epu16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmple_epu16_mask(a, b);
@@ -15559,7 +15553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epu16_mask() {
+    const fn test_mm256_mask_cmple_epu16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -15568,7 +15562,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmple_epu16_mask() {
+    const fn test_mm_cmple_epu16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmple_epu16_mask(a, b);
@@ -15576,7 +15570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epu16_mask() {
+    const fn test_mm_mask_cmple_epu16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15585,7 +15579,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmple_epu8_mask() {
+    const fn test_mm512_cmple_epu8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmple_epu8_mask(a, b);
@@ -15596,7 +15590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmple_epu8_mask() {
+    const fn test_mm512_mask_cmple_epu8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15608,7 +15602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmple_epu8_mask() {
+    const fn test_mm256_cmple_epu8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmple_epu8_mask(a, b);
@@ -15616,7 +15610,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epu8_mask() {
+    const fn test_mm256_mask_cmple_epu8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15625,7 +15619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmple_epu8_mask() {
+    const fn test_mm_cmple_epu8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmple_epu8_mask(a, b);
@@ -15633,7 +15627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epu8_mask() {
+    const fn test_mm_mask_cmple_epu8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15642,7 +15636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmple_epi16_mask() {
+    const fn test_mm512_cmple_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmple_epi16_mask(a, b);
@@ -15650,7 +15644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmple_epi16_mask() {
+    const fn test_mm512_mask_cmple_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15659,7 +15653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmple_epi16_mask() {
+    const fn test_mm256_cmple_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmple_epi16_mask(a, b);
@@ -15667,7 +15661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epi16_mask() {
+    const fn test_mm256_mask_cmple_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -15676,7 +15670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmple_epi16_mask() {
+    const fn test_mm_cmple_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmple_epi16_mask(a, b);
@@ -15684,7 +15678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epi16_mask() {
+    const fn test_mm_mask_cmple_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15693,7 +15687,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmple_epi8_mask() {
+    const fn test_mm512_cmple_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmple_epi8_mask(a, b);
@@ -15704,7 +15698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmple_epi8_mask() {
+    const fn test_mm512_mask_cmple_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15716,7 +15710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmple_epi8_mask() {
+    const fn test_mm256_cmple_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmple_epi8_mask(a, b);
@@ -15724,7 +15718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epi8_mask() {
+    const fn test_mm256_mask_cmple_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15733,7 +15727,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmple_epi8_mask() {
+    const fn test_mm_cmple_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmple_epi8_mask(a, b);
@@ -15741,7 +15735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epi8_mask() {
+    const fn test_mm_mask_cmple_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15750,7 +15744,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpge_epu16_mask() {
+    const fn test_mm512_cmpge_epu16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmpge_epu16_mask(a, b);
@@ -15758,7 +15752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpge_epu16_mask() {
+    const fn test_mm512_mask_cmpge_epu16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15767,7 +15761,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epu16_mask() {
+    const fn test_mm256_cmpge_epu16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmpge_epu16_mask(a, b);
@@ -15775,7 +15769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epu16_mask() {
+    const fn test_mm256_mask_cmpge_epu16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -15784,7 +15778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpge_epu16_mask() {
+    const fn test_mm_cmpge_epu16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmpge_epu16_mask(a, b);
@@ -15792,7 +15786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epu16_mask() {
+    const fn test_mm_mask_cmpge_epu16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -15801,7 +15795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpge_epu8_mask() {
+    const fn test_mm512_cmpge_epu8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmpge_epu8_mask(a, b);
@@ -15812,7 +15806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpge_epu8_mask() {
+    const fn test_mm512_mask_cmpge_epu8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15824,7 +15818,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epu8_mask() {
+    const fn test_mm256_cmpge_epu8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmpge_epu8_mask(a, b);
@@ -15832,7 +15826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epu8_mask() {
+    const fn test_mm256_mask_cmpge_epu8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15841,7 +15835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpge_epu8_mask() {
+    const fn test_mm_cmpge_epu8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmpge_epu8_mask(a, b);
@@ -15849,7 +15843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epu8_mask() {
+    const fn test_mm_mask_cmpge_epu8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -15858,7 +15852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpge_epi16_mask() {
+    const fn test_mm512_cmpge_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmpge_epi16_mask(a, b);
@@ -15866,7 +15860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpge_epi16_mask() {
+    const fn test_mm512_mask_cmpge_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15875,7 +15869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epi16_mask() {
+    const fn test_mm256_cmpge_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmpge_epi16_mask(a, b);
@@ -15883,7 +15877,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epi16_mask() {
+    const fn test_mm256_mask_cmpge_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -15892,7 +15886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpge_epi16_mask() {
+    const fn test_mm_cmpge_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmpge_epi16_mask(a, b);
@@ -15900,7 +15894,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epi16_mask() {
+    const fn test_mm_mask_cmpge_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -15909,7 +15903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpge_epi8_mask() {
+    const fn test_mm512_cmpge_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmpge_epi8_mask(a, b);
@@ -15920,7 +15914,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpge_epi8_mask() {
+    const fn test_mm512_mask_cmpge_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -15932,7 +15926,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epi8_mask() {
+    const fn test_mm256_cmpge_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmpge_epi8_mask(a, b);
@@ -15940,7 +15934,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epi8_mask() {
+    const fn test_mm256_mask_cmpge_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15949,7 +15943,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpge_epi8_mask() {
+    const fn test_mm_cmpge_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmpge_epi8_mask(a, b);
@@ -15957,7 +15951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epi8_mask() {
+    const fn test_mm_mask_cmpge_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -15966,7 +15960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpeq_epu16_mask() {
+    const fn test_mm512_cmpeq_epu16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmpeq_epu16_mask(a, b);
@@ -15974,7 +15968,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpeq_epu16_mask() {
+    const fn test_mm512_mask_cmpeq_epu16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -15983,7 +15977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epu16_mask() {
+    const fn test_mm256_cmpeq_epu16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmpeq_epu16_mask(a, b);
@@ -15991,7 +15985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epu16_mask() {
+    const fn test_mm256_mask_cmpeq_epu16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -16000,7 +15994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epu16_mask() {
+    const fn test_mm_cmpeq_epu16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmpeq_epu16_mask(a, b);
@@ -16008,7 +16002,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epu16_mask() {
+    const fn test_mm_mask_cmpeq_epu16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -16017,7 +16011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpeq_epu8_mask() {
+    const fn test_mm512_cmpeq_epu8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmpeq_epu8_mask(a, b);
@@ -16028,7 +16022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpeq_epu8_mask() {
+    const fn test_mm512_mask_cmpeq_epu8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16040,7 +16034,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epu8_mask() {
+    const fn test_mm256_cmpeq_epu8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmpeq_epu8_mask(a, b);
@@ -16048,7 +16042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epu8_mask() {
+    const fn test_mm256_mask_cmpeq_epu8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16057,7 +16051,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epu8_mask() {
+    const fn test_mm_cmpeq_epu8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmpeq_epu8_mask(a, b);
@@ -16065,7 +16059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epu8_mask() {
+    const fn test_mm_mask_cmpeq_epu8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -16074,7 +16068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpeq_epi16_mask() {
+    const fn test_mm512_cmpeq_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmpeq_epi16_mask(a, b);
@@ -16082,7 +16076,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpeq_epi16_mask() {
+    const fn test_mm512_mask_cmpeq_epi16_mask() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16091,7 +16085,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epi16_mask() {
+    const fn test_mm256_cmpeq_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmpeq_epi16_mask(a, b);
@@ -16099,7 +16093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epi16_mask() {
+    const fn test_mm256_mask_cmpeq_epi16_mask() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -16108,7 +16102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epi16_mask() {
+    const fn test_mm_cmpeq_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmpeq_epi16_mask(a, b);
@@ -16116,7 +16110,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epi16_mask() {
+    const fn test_mm_mask_cmpeq_epi16_mask() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -16125,7 +16119,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpeq_epi8_mask() {
+    const fn test_mm512_cmpeq_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmpeq_epi8_mask(a, b);
@@ -16136,7 +16130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpeq_epi8_mask() {
+    const fn test_mm512_mask_cmpeq_epi8_mask() {
         let a = _mm512_set1_epi8(-1);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16148,7 +16142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epi8_mask() {
+    const fn test_mm256_cmpeq_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmpeq_epi8_mask(a, b);
@@ -16156,7 +16150,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epi8_mask() {
+    const fn test_mm256_mask_cmpeq_epi8_mask() {
         let a = _mm256_set1_epi8(-1);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16165,7 +16159,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epi8_mask() {
+    const fn test_mm_cmpeq_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmpeq_epi8_mask(a, b);
@@ -16173,7 +16167,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epi8_mask() {
+    const fn test_mm_mask_cmpeq_epi8_mask() {
         let a = _mm_set1_epi8(-1);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -16182,7 +16176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpneq_epu16_mask() {
+    const fn test_mm512_cmpneq_epu16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmpneq_epu16_mask(a, b);
@@ -16190,7 +16184,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpneq_epu16_mask() {
+    const fn test_mm512_mask_cmpneq_epu16_mask() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16199,7 +16193,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epu16_mask() {
+    const fn test_mm256_cmpneq_epu16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmpneq_epu16_mask(a, b);
@@ -16207,7 +16201,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epu16_mask() {
+    const fn test_mm256_mask_cmpneq_epu16_mask() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -16216,7 +16210,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epu16_mask() {
+    const fn test_mm_cmpneq_epu16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmpneq_epu16_mask(a, b);
@@ -16224,7 +16218,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epu16_mask() {
+    const fn test_mm_mask_cmpneq_epu16_mask() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -16233,7 +16227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpneq_epu8_mask() {
+    const fn test_mm512_cmpneq_epu8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmpneq_epu8_mask(a, b);
@@ -16244,7 +16238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpneq_epu8_mask() {
+    const fn test_mm512_mask_cmpneq_epu8_mask() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16256,7 +16250,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epu8_mask() {
+    const fn test_mm256_cmpneq_epu8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmpneq_epu8_mask(a, b);
@@ -16264,7 +16258,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epu8_mask() {
+    const fn test_mm256_mask_cmpneq_epu8_mask() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16273,7 +16267,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epu8_mask() {
+    const fn test_mm_cmpneq_epu8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmpneq_epu8_mask(a, b);
@@ -16281,7 +16275,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epu8_mask() {
+    const fn test_mm_mask_cmpneq_epu8_mask() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -16290,7 +16284,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpneq_epi16_mask() {
+    const fn test_mm512_cmpneq_epi16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(-1);
         let m = _mm512_cmpneq_epi16_mask(a, b);
@@ -16298,7 +16292,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpneq_epi16_mask() {
+    const fn test_mm512_mask_cmpneq_epi16_mask() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16307,7 +16301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epi16_mask() {
+    const fn test_mm256_cmpneq_epi16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(-1);
         let m = _mm256_cmpneq_epi16_mask(a, b);
@@ -16315,7 +16309,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epi16_mask() {
+    const fn test_mm256_mask_cmpneq_epi16_mask() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(-1);
         let mask = 0b01010101_01010101;
@@ -16324,7 +16318,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epi16_mask() {
+    const fn test_mm_cmpneq_epi16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(-1);
         let m = _mm_cmpneq_epi16_mask(a, b);
@@ -16332,7 +16326,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epi16_mask() {
+    const fn test_mm_mask_cmpneq_epi16_mask() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(-1);
         let mask = 0b01010101;
@@ -16341,7 +16335,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmpneq_epi8_mask() {
+    const fn test_mm512_cmpneq_epi8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(-1);
         let m = _mm512_cmpneq_epi8_mask(a, b);
@@ -16352,7 +16346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmpneq_epi8_mask() {
+    const fn test_mm512_mask_cmpneq_epi8_mask() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16364,7 +16358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epi8_mask() {
+    const fn test_mm256_cmpneq_epi8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(-1);
         let m = _mm256_cmpneq_epi8_mask(a, b);
@@ -16372,7 +16366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epi8_mask() {
+    const fn test_mm256_mask_cmpneq_epi8_mask() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(-1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16381,7 +16375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epi8_mask() {
+    const fn test_mm_cmpneq_epi8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(-1);
         let m = _mm_cmpneq_epi8_mask(a, b);
@@ -16389,7 +16383,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epi8_mask() {
+    const fn test_mm_mask_cmpneq_epi8_mask() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(-1);
         let mask = 0b01010101_01010101;
@@ -16398,7 +16392,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmp_epu16_mask() {
+    const fn test_mm512_cmp_epu16_mask() {
         let a = _mm512_set1_epi16(0);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmp_epu16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16406,7 +16400,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmp_epu16_mask() {
+    const fn test_mm512_mask_cmp_epu16_mask() {
         let a = _mm512_set1_epi16(0);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16415,7 +16409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmp_epu16_mask() {
+    const fn test_mm256_cmp_epu16_mask() {
         let a = _mm256_set1_epi16(0);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmp_epu16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16423,7 +16417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epu16_mask() {
+    const fn test_mm256_mask_cmp_epu16_mask() {
         let a = _mm256_set1_epi16(0);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -16432,7 +16426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmp_epu16_mask() {
+    const fn test_mm_cmp_epu16_mask() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmp_epu16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16440,7 +16434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epu16_mask() {
+    const fn test_mm_mask_cmp_epu16_mask() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -16449,7 +16443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmp_epu8_mask() {
+    const fn test_mm512_cmp_epu8_mask() {
         let a = _mm512_set1_epi8(0);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmp_epu8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16460,7 +16454,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmp_epu8_mask() {
+    const fn test_mm512_mask_cmp_epu8_mask() {
         let a = _mm512_set1_epi8(0);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16472,7 +16466,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmp_epu8_mask() {
+    const fn test_mm256_cmp_epu8_mask() {
         let a = _mm256_set1_epi8(0);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmp_epu8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16480,7 +16474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epu8_mask() {
+    const fn test_mm256_mask_cmp_epu8_mask() {
         let a = _mm256_set1_epi8(0);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16489,7 +16483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmp_epu8_mask() {
+    const fn test_mm_cmp_epu8_mask() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmp_epu8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16497,7 +16491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epu8_mask() {
+    const fn test_mm_mask_cmp_epu8_mask() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -16506,7 +16500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmp_epi16_mask() {
+    const fn test_mm512_cmp_epi16_mask() {
         let a = _mm512_set1_epi16(0);
         let b = _mm512_set1_epi16(1);
         let m = _mm512_cmp_epi16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16514,7 +16508,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmp_epi16_mask() {
+    const fn test_mm512_mask_cmp_epi16_mask() {
         let a = _mm512_set1_epi16(0);
         let b = _mm512_set1_epi16(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16523,7 +16517,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmp_epi16_mask() {
+    const fn test_mm256_cmp_epi16_mask() {
         let a = _mm256_set1_epi16(0);
         let b = _mm256_set1_epi16(1);
         let m = _mm256_cmp_epi16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16531,7 +16525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epi16_mask() {
+    const fn test_mm256_mask_cmp_epi16_mask() {
         let a = _mm256_set1_epi16(0);
         let b = _mm256_set1_epi16(1);
         let mask = 0b01010101_01010101;
@@ -16540,7 +16534,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmp_epi16_mask() {
+    const fn test_mm_cmp_epi16_mask() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let m = _mm_cmp_epi16_mask::<_MM_CMPINT_LT>(a, b);
@@ -16548,7 +16542,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epi16_mask() {
+    const fn test_mm_mask_cmp_epi16_mask() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let mask = 0b01010101;
@@ -16557,7 +16551,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cmp_epi8_mask() {
+    const fn test_mm512_cmp_epi8_mask() {
         let a = _mm512_set1_epi8(0);
         let b = _mm512_set1_epi8(1);
         let m = _mm512_cmp_epi8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16568,7 +16562,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cmp_epi8_mask() {
+    const fn test_mm512_mask_cmp_epi8_mask() {
         let a = _mm512_set1_epi8(0);
         let b = _mm512_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101_01010101_01010101_01010101_01010101;
@@ -16580,7 +16574,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cmp_epi8_mask() {
+    const fn test_mm256_cmp_epi8_mask() {
         let a = _mm256_set1_epi8(0);
         let b = _mm256_set1_epi8(1);
         let m = _mm256_cmp_epi8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16588,7 +16582,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epi8_mask() {
+    const fn test_mm256_mask_cmp_epi8_mask() {
         let a = _mm256_set1_epi8(0);
         let b = _mm256_set1_epi8(1);
         let mask = 0b01010101_01010101_01010101_01010101;
@@ -16597,7 +16591,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cmp_epi8_mask() {
+    const fn test_mm_cmp_epi8_mask() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set1_epi8(1);
         let m = _mm_cmp_epi8_mask::<_MM_CMPINT_LT>(a, b);
@@ -16605,7 +16599,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epi8_mask() {
+    const fn test_mm_mask_cmp_epi8_mask() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set1_epi8(1);
         let mask = 0b01010101_01010101;
@@ -16614,91 +16608,91 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_add_epi16() {
+    const fn test_mm256_reduce_add_epi16() {
         let a = _mm256_set1_epi16(1);
         let e = _mm256_reduce_add_epi16(a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_add_epi16() {
+    const fn test_mm256_mask_reduce_add_epi16() {
         let a = _mm256_set1_epi16(1);
         let e = _mm256_mask_reduce_add_epi16(0b11111111_00000000, a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_add_epi16() {
+    const fn test_mm_reduce_add_epi16() {
         let a = _mm_set1_epi16(1);
         let e = _mm_reduce_add_epi16(a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_add_epi16() {
+    const fn test_mm_mask_reduce_add_epi16() {
         let a = _mm_set1_epi16(1);
         let e = _mm_mask_reduce_add_epi16(0b11110000, a);
         assert_eq!(4, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_add_epi8() {
+    const fn test_mm256_reduce_add_epi8() {
         let a = _mm256_set1_epi8(1);
         let e = _mm256_reduce_add_epi8(a);
         assert_eq!(32, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_add_epi8() {
+    const fn test_mm256_mask_reduce_add_epi8() {
         let a = _mm256_set1_epi8(1);
         let e = _mm256_mask_reduce_add_epi8(0b11111111_00000000_11111111_00000000, a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_add_epi8() {
+    const fn test_mm_reduce_add_epi8() {
         let a = _mm_set1_epi8(1);
         let e = _mm_reduce_add_epi8(a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_add_epi8() {
+    const fn test_mm_mask_reduce_add_epi8() {
         let a = _mm_set1_epi8(1);
         let e = _mm_mask_reduce_add_epi8(0b11111111_00000000, a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_and_epi16() {
+    const fn test_mm256_reduce_and_epi16() {
         let a = _mm256_set_epi16(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm256_reduce_and_epi16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_and_epi16() {
+    const fn test_mm256_mask_reduce_and_epi16() {
         let a = _mm256_set_epi16(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm256_mask_reduce_and_epi16(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_and_epi16() {
+    const fn test_mm_reduce_and_epi16() {
         let a = _mm_set_epi16(1, 1, 1, 1, 2, 2, 2, 2);
         let e = _mm_reduce_and_epi16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_and_epi16() {
+    const fn test_mm_mask_reduce_and_epi16() {
         let a = _mm_set_epi16(1, 1, 1, 1, 2, 2, 2, 2);
         let e = _mm_mask_reduce_and_epi16(0b11110000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_and_epi8() {
+    const fn test_mm256_reduce_and_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
             2, 2, 2,
@@ -16708,7 +16702,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_and_epi8() {
+    const fn test_mm256_mask_reduce_and_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
             2, 2, 2,
@@ -16718,49 +16712,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_and_epi8() {
+    const fn test_mm_reduce_and_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm_reduce_and_epi8(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_and_epi8() {
+    const fn test_mm_mask_reduce_and_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm_mask_reduce_and_epi8(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_mul_epi16() {
+    const fn test_mm256_reduce_mul_epi16() {
         let a = _mm256_set_epi16(2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1);
         let e = _mm256_reduce_mul_epi16(a);
         assert_eq!(256, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_mul_epi16() {
+    const fn test_mm256_mask_reduce_mul_epi16() {
         let a = _mm256_set_epi16(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm256_mask_reduce_mul_epi16(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_mul_epi16() {
+    const fn test_mm_reduce_mul_epi16() {
         let a = _mm_set_epi16(2, 2, 2, 2, 1, 1, 1, 1);
         let e = _mm_reduce_mul_epi16(a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_mul_epi16() {
+    const fn test_mm_mask_reduce_mul_epi16() {
         let a = _mm_set_epi16(1, 1, 1, 1, 2, 2, 2, 2);
         let e = _mm_mask_reduce_mul_epi16(0b11110000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_mul_epi8() {
+    const fn test_mm256_reduce_mul_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
             2, 2, 2,
@@ -16770,7 +16764,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_mul_epi8() {
+    const fn test_mm256_mask_reduce_mul_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
             2, 2, 2,
@@ -16780,49 +16774,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_mul_epi8() {
+    const fn test_mm_reduce_mul_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2);
         let e = _mm_reduce_mul_epi8(a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_mul_epi8() {
+    const fn test_mm_mask_reduce_mul_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2);
         let e = _mm_mask_reduce_mul_epi8(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_max_epi16() {
+    const fn test_mm256_reduce_max_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i16 = _mm256_reduce_max_epi16(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_max_epi16() {
+    const fn test_mm256_mask_reduce_max_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i16 = _mm256_mask_reduce_max_epi16(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_max_epi16() {
+    const fn test_mm_reduce_max_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i16 = _mm_reduce_max_epi16(a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_max_epi16() {
+    const fn test_mm_mask_reduce_max_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i16 = _mm_mask_reduce_max_epi16(0b11110000, a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_max_epi8() {
+    const fn test_mm256_reduce_max_epi8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16832,7 +16826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_max_epi8() {
+    const fn test_mm256_mask_reduce_max_epi8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16842,49 +16836,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_max_epi8() {
+    const fn test_mm_reduce_max_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i8 = _mm_reduce_max_epi8(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_max_epi8() {
+    const fn test_mm_mask_reduce_max_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i8 = _mm_mask_reduce_max_epi8(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_max_epu16() {
+    const fn test_mm256_reduce_max_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u16 = _mm256_reduce_max_epu16(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_max_epu16() {
+    const fn test_mm256_mask_reduce_max_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u16 = _mm256_mask_reduce_max_epu16(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_max_epu16() {
+    const fn test_mm_reduce_max_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u16 = _mm_reduce_max_epu16(a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_max_epu16() {
+    const fn test_mm_mask_reduce_max_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u16 = _mm_mask_reduce_max_epu16(0b11110000, a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_max_epu8() {
+    const fn test_mm256_reduce_max_epu8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16894,7 +16888,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_max_epu8() {
+    const fn test_mm256_mask_reduce_max_epu8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16904,49 +16898,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_max_epu8() {
+    const fn test_mm_reduce_max_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u8 = _mm_reduce_max_epu8(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_max_epu8() {
+    const fn test_mm_mask_reduce_max_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u8 = _mm_mask_reduce_max_epu8(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_min_epi16() {
+    const fn test_mm256_reduce_min_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i16 = _mm256_reduce_min_epi16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_min_epi16() {
+    const fn test_mm256_mask_reduce_min_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i16 = _mm256_mask_reduce_min_epi16(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_min_epi16() {
+    const fn test_mm_reduce_min_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i16 = _mm_reduce_min_epi16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_min_epi16() {
+    const fn test_mm_mask_reduce_min_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i16 = _mm_mask_reduce_min_epi16(0b11110000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_min_epi8() {
+    const fn test_mm256_reduce_min_epi8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16956,7 +16950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_min_epi8() {
+    const fn test_mm256_mask_reduce_min_epi8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -16966,49 +16960,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_min_epi8() {
+    const fn test_mm_reduce_min_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i8 = _mm_reduce_min_epi8(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_min_epi8() {
+    const fn test_mm_mask_reduce_min_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i8 = _mm_mask_reduce_min_epi8(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_min_epu16() {
+    const fn test_mm256_reduce_min_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u16 = _mm256_reduce_min_epu16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_min_epu16() {
+    const fn test_mm256_mask_reduce_min_epu16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u16 = _mm256_mask_reduce_min_epu16(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_min_epu16() {
+    const fn test_mm_reduce_min_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u16 = _mm_reduce_min_epu16(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_min_epu16() {
+    const fn test_mm_mask_reduce_min_epu16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u16 = _mm_mask_reduce_min_epu16(0b11110000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_min_epu8() {
+    const fn test_mm256_reduce_min_epu8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -17018,7 +17012,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_min_epu8() {
+    const fn test_mm256_mask_reduce_min_epu8() {
         let a = _mm256_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
             24, 25, 26, 27, 28, 29, 30, 31,
@@ -17028,49 +17022,49 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_min_epu8() {
+    const fn test_mm_reduce_min_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u8 = _mm_reduce_min_epu8(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_min_epu8() {
+    const fn test_mm_mask_reduce_min_epu8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u8 = _mm_mask_reduce_min_epu8(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_or_epi16() {
+    const fn test_mm256_reduce_or_epi16() {
         let a = _mm256_set_epi16(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm256_reduce_or_epi16(a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_or_epi16() {
+    const fn test_mm256_mask_reduce_or_epi16() {
         let a = _mm256_set_epi16(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm256_mask_reduce_or_epi16(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_or_epi16() {
+    const fn test_mm_reduce_or_epi16() {
         let a = _mm_set_epi16(1, 1, 1, 1, 2, 2, 2, 2);
         let e = _mm_reduce_or_epi16(a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_or_epi16() {
+    const fn test_mm_mask_reduce_or_epi16() {
         let a = _mm_set_epi16(1, 1, 1, 1, 2, 2, 2, 2);
         let e = _mm_mask_reduce_or_epi16(0b11110000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_reduce_or_epi8() {
+    const fn test_mm256_reduce_or_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
             2, 2, 2,
@@ -17080,7 +17074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_reduce_or_epi8() {
+    const fn test_mm256_mask_reduce_or_epi8() {
         let a = _mm256_set_epi8(
             1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
             2, 2, 2,
@@ -17090,14 +17084,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_reduce_or_epi8() {
+    const fn test_mm_reduce_or_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm_reduce_or_epi8(a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_reduce_or_epi8() {
+    const fn test_mm_mask_reduce_or_epi8() {
         let a = _mm_set_epi8(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e = _mm_mask_reduce_or_epi8(0b11111111_00000000, a);
         assert_eq!(1, e);
@@ -17486,7 +17480,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_madd_epi16() {
+    fn test_mm512_madd_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_madd_epi16(a, b);
@@ -17495,7 +17489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_madd_epi16() {
+    fn test_mm512_mask_madd_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_madd_epi16(a, 0, a, b);
@@ -17523,7 +17517,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_madd_epi16() {
+    fn test_mm512_maskz_madd_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_madd_epi16(0, a, b);
@@ -17534,7 +17528,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_madd_epi16() {
+    fn test_mm256_mask_madd_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_madd_epi16(a, 0, a, b);
@@ -17554,7 +17548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_madd_epi16() {
+    fn test_mm256_maskz_madd_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_madd_epi16(0, a, b);
@@ -17565,7 +17559,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_madd_epi16() {
+    fn test_mm_mask_madd_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_madd_epi16(a, 0, a, b);
@@ -17576,7 +17570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_madd_epi16() {
+    fn test_mm_maskz_madd_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_madd_epi16(0, a, b);
@@ -17587,7 +17581,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maddubs_epi16() {
+    fn test_mm512_maddubs_epi16() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_maddubs_epi16(a, b);
@@ -17596,7 +17590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_maddubs_epi16() {
+    fn test_mm512_mask_maddubs_epi16() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let src = _mm512_set1_epi16(1);
@@ -17610,7 +17604,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_maddubs_epi16() {
+    fn test_mm512_maskz_maddubs_epi16() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_maskz_maddubs_epi16(0, a, b);
@@ -17623,7 +17617,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_maddubs_epi16() {
+    fn test_mm256_mask_maddubs_epi16() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let src = _mm256_set1_epi16(1);
@@ -17635,7 +17629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_maddubs_epi16() {
+    fn test_mm256_maskz_maddubs_epi16() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_maskz_maddubs_epi16(0, a, b);
@@ -17646,7 +17640,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_maddubs_epi16() {
+    fn test_mm_mask_maddubs_epi16() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let src = _mm_set1_epi16(1);
@@ -17658,7 +17652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_maddubs_epi16() {
+    fn test_mm_maskz_maddubs_epi16() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_maskz_maddubs_epi16(0, a, b);
@@ -17669,7 +17663,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_packs_epi32() {
+    fn test_mm512_packs_epi32() {
         let a = _mm512_set1_epi32(i32::MAX);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_packs_epi32(a, b);
@@ -17680,7 +17674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_packs_epi32() {
+    fn test_mm512_mask_packs_epi32() {
         let a = _mm512_set1_epi32(i32::MAX);
         let b = _mm512_set1_epi32(1 << 16 | 1);
         let r = _mm512_mask_packs_epi32(a, 0, a, b);
@@ -17693,7 +17687,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_packs_epi32() {
+    fn test_mm512_maskz_packs_epi32() {
         let a = _mm512_set1_epi32(i32::MAX);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_maskz_packs_epi32(0, a, b);
@@ -17706,7 +17700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_packs_epi32() {
+    fn test_mm256_mask_packs_epi32() {
         let a = _mm256_set1_epi32(i32::MAX);
         let b = _mm256_set1_epi32(1 << 16 | 1);
         let r = _mm256_mask_packs_epi32(a, 0, a, b);
@@ -17718,7 +17712,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_packs_epi32() {
+    fn test_mm256_maskz_packs_epi32() {
         let a = _mm256_set1_epi32(i32::MAX);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_packs_epi32(0, a, b);
@@ -17730,7 +17724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_packs_epi32() {
+    fn test_mm_mask_packs_epi32() {
         let a = _mm_set1_epi32(i32::MAX);
         let b = _mm_set1_epi32(1 << 16 | 1);
         let r = _mm_mask_packs_epi32(a, 0, a, b);
@@ -17741,7 +17735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_packs_epi32() {
+    fn test_mm_maskz_packs_epi32() {
         let a = _mm_set1_epi32(i32::MAX);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_packs_epi32(0, a, b);
@@ -17752,7 +17746,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_packs_epi16() {
+    fn test_mm512_packs_epi16() {
         let a = _mm512_set1_epi16(i16::MAX);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_packs_epi16(a, b);
@@ -17765,7 +17759,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_packs_epi16() {
+    fn test_mm512_mask_packs_epi16() {
         let a = _mm512_set1_epi16(i16::MAX);
         let b = _mm512_set1_epi16(1 << 8 | 1);
         let r = _mm512_mask_packs_epi16(a, 0, a, b);
@@ -17785,7 +17779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_packs_epi16() {
+    fn test_mm512_maskz_packs_epi16() {
         let a = _mm512_set1_epi16(i16::MAX);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_packs_epi16(0, a, b);
@@ -17804,7 +17798,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_packs_epi16() {
+    fn test_mm256_mask_packs_epi16() {
         let a = _mm256_set1_epi16(i16::MAX);
         let b = _mm256_set1_epi16(1 << 8 | 1);
         let r = _mm256_mask_packs_epi16(a, 0, a, b);
@@ -17817,7 +17811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_packs_epi16() {
+    fn test_mm256_maskz_packs_epi16() {
         let a = _mm256_set1_epi16(i16::MAX);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_packs_epi16(0, a, b);
@@ -17830,7 +17824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_packs_epi16() {
+    fn test_mm_mask_packs_epi16() {
         let a = _mm_set1_epi16(i16::MAX);
         let b = _mm_set1_epi16(1 << 8 | 1);
         let r = _mm_mask_packs_epi16(a, 0, a, b);
@@ -17842,7 +17836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_packs_epi16() {
+    fn test_mm_maskz_packs_epi16() {
         let a = _mm_set1_epi16(i16::MAX);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_packs_epi16(0, a, b);
@@ -17854,7 +17848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_packus_epi32() {
+    fn test_mm512_packus_epi32() {
         let a = _mm512_set1_epi32(-1);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_packus_epi32(a, b);
@@ -17865,7 +17859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_packus_epi32() {
+    fn test_mm512_mask_packus_epi32() {
         let a = _mm512_set1_epi32(-1);
         let b = _mm512_set1_epi32(1 << 16 | 1);
         let r = _mm512_mask_packus_epi32(a, 0, a, b);
@@ -17878,7 +17872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_packus_epi32() {
+    fn test_mm512_maskz_packus_epi32() {
         let a = _mm512_set1_epi32(-1);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_maskz_packus_epi32(0, a, b);
@@ -17891,7 +17885,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_packus_epi32() {
+    fn test_mm256_mask_packus_epi32() {
         let a = _mm256_set1_epi32(-1);
         let b = _mm256_set1_epi32(1 << 16 | 1);
         let r = _mm256_mask_packus_epi32(a, 0, a, b);
@@ -17902,7 +17896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_packus_epi32() {
+    fn test_mm256_maskz_packus_epi32() {
         let a = _mm256_set1_epi32(-1);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_packus_epi32(0, a, b);
@@ -17913,7 +17907,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_packus_epi32() {
+    fn test_mm_mask_packus_epi32() {
         let a = _mm_set1_epi32(-1);
         let b = _mm_set1_epi32(1 << 16 | 1);
         let r = _mm_mask_packus_epi32(a, 0, a, b);
@@ -17924,7 +17918,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_packus_epi32() {
+    fn test_mm_maskz_packus_epi32() {
         let a = _mm_set1_epi32(-1);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_packus_epi32(0, a, b);
@@ -17935,7 +17929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_packus_epi16() {
+    fn test_mm512_packus_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_packus_epi16(a, b);
@@ -17948,7 +17942,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_packus_epi16() {
+    fn test_mm512_mask_packus_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(1 << 8 | 1);
         let r = _mm512_mask_packus_epi16(a, 0, a, b);
@@ -17968,7 +17962,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_packus_epi16() {
+    fn test_mm512_maskz_packus_epi16() {
         let a = _mm512_set1_epi16(-1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_packus_epi16(0, a, b);
@@ -17987,7 +17981,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_packus_epi16() {
+    fn test_mm256_mask_packus_epi16() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(1 << 8 | 1);
         let r = _mm256_mask_packus_epi16(a, 0, a, b);
@@ -18000,7 +17994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_packus_epi16() {
+    fn test_mm256_maskz_packus_epi16() {
         let a = _mm256_set1_epi16(-1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_packus_epi16(0, a, b);
@@ -18013,7 +18007,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_packus_epi16() {
+    fn test_mm_mask_packus_epi16() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(1 << 8 | 1);
         let r = _mm_mask_packus_epi16(a, 0, a, b);
@@ -18024,7 +18018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_packus_epi16() {
+    fn test_mm_maskz_packus_epi16() {
         let a = _mm_set1_epi16(-1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_packus_epi16(0, a, b);
@@ -18035,7 +18029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_avg_epu16() {
+    const fn test_mm512_avg_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_avg_epu16(a, b);
@@ -18044,7 +18038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_avg_epu16() {
+    const fn test_mm512_mask_avg_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_mask_avg_epu16(a, 0, a, b);
@@ -18057,7 +18051,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_avg_epu16() {
+    const fn test_mm512_maskz_avg_epu16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1);
         let r = _mm512_maskz_avg_epu16(0, a, b);
@@ -18070,7 +18064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_avg_epu16() {
+    const fn test_mm256_mask_avg_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_mask_avg_epu16(a, 0, a, b);
@@ -18081,7 +18075,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_avg_epu16() {
+    const fn test_mm256_maskz_avg_epu16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1);
         let r = _mm256_maskz_avg_epu16(0, a, b);
@@ -18092,7 +18086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_avg_epu16() {
+    const fn test_mm_mask_avg_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_mask_avg_epu16(a, 0, a, b);
@@ -18103,7 +18097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_avg_epu16() {
+    const fn test_mm_maskz_avg_epu16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1);
         let r = _mm_maskz_avg_epu16(0, a, b);
@@ -18114,7 +18108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_avg_epu8() {
+    const fn test_mm512_avg_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_avg_epu8(a, b);
@@ -18123,7 +18117,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_avg_epu8() {
+    const fn test_mm512_mask_avg_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_mask_avg_epu8(a, 0, a, b);
@@ -18143,7 +18137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_avg_epu8() {
+    const fn test_mm512_maskz_avg_epu8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_maskz_avg_epu8(0, a, b);
@@ -18162,7 +18156,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_avg_epu8() {
+    const fn test_mm256_mask_avg_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_mask_avg_epu8(a, 0, a, b);
@@ -18175,7 +18169,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_avg_epu8() {
+    const fn test_mm256_maskz_avg_epu8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_maskz_avg_epu8(0, a, b);
@@ -18188,7 +18182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_avg_epu8() {
+    const fn test_mm_mask_avg_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_mask_avg_epu8(a, 0, a, b);
@@ -18199,7 +18193,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_avg_epu8() {
+    const fn test_mm_maskz_avg_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_maskz_avg_epu8(0, a, b);
@@ -18210,7 +18204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_sll_epi16() {
+    fn test_mm512_sll_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm512_sll_epi16(a, count);
@@ -18219,7 +18213,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_sll_epi16() {
+    fn test_mm512_mask_sll_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm512_mask_sll_epi16(a, 0, a, count);
@@ -18230,7 +18224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_sll_epi16() {
+    fn test_mm512_maskz_sll_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm512_maskz_sll_epi16(0, a, count);
@@ -18241,7 +18235,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_sll_epi16() {
+    fn test_mm256_mask_sll_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm256_mask_sll_epi16(a, 0, a, count);
@@ -18252,7 +18246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_sll_epi16() {
+    fn test_mm256_maskz_sll_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm256_maskz_sll_epi16(0, a, count);
@@ -18263,7 +18257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_sll_epi16() {
+    fn test_mm_mask_sll_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm_mask_sll_epi16(a, 0, a, count);
@@ -18274,7 +18268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_sll_epi16() {
+    fn test_mm_maskz_sll_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm_maskz_sll_epi16(0, a, count);
@@ -18285,7 +18279,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_slli_epi16() {
+    const fn test_mm512_slli_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let r = _mm512_slli_epi16::<1>(a);
         let e = _mm512_set1_epi16(0);
@@ -18293,7 +18287,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_slli_epi16() {
+    const fn test_mm512_mask_slli_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let r = _mm512_mask_slli_epi16::<1>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -18303,7 +18297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_slli_epi16() {
+    const fn test_mm512_maskz_slli_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let r = _mm512_maskz_slli_epi16::<1>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -18313,7 +18307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_slli_epi16() {
+    const fn test_mm256_mask_slli_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let r = _mm256_mask_slli_epi16::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -18323,7 +18317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_slli_epi16() {
+    const fn test_mm256_maskz_slli_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let r = _mm256_maskz_slli_epi16::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -18333,7 +18327,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_slli_epi16() {
+    const fn test_mm_mask_slli_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let r = _mm_mask_slli_epi16::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -18343,7 +18337,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_slli_epi16() {
+    const fn test_mm_maskz_slli_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let r = _mm_maskz_slli_epi16::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -18353,7 +18347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_sllv_epi16() {
+    const fn test_mm512_sllv_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_sllv_epi16(a, count);
@@ -18362,7 +18356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_sllv_epi16() {
+    const fn test_mm512_mask_sllv_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_mask_sllv_epi16(a, 0, a, count);
@@ -18373,7 +18367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_sllv_epi16() {
+    const fn test_mm512_maskz_sllv_epi16() {
         let a = _mm512_set1_epi16(1 << 15);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_maskz_sllv_epi16(0, a, count);
@@ -18384,7 +18378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_sllv_epi16() {
+    const fn test_mm256_sllv_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_sllv_epi16(a, count);
@@ -18393,7 +18387,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_sllv_epi16() {
+    const fn test_mm256_mask_sllv_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_mask_sllv_epi16(a, 0, a, count);
@@ -18404,7 +18398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_sllv_epi16() {
+    const fn test_mm256_maskz_sllv_epi16() {
         let a = _mm256_set1_epi16(1 << 15);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_maskz_sllv_epi16(0, a, count);
@@ -18415,7 +18409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_sllv_epi16() {
+    const fn test_mm_sllv_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm_sllv_epi16(a, count);
@@ -18424,7 +18418,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_sllv_epi16() {
+    const fn test_mm_mask_sllv_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm_mask_sllv_epi16(a, 0, a, count);
@@ -18435,7 +18429,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_sllv_epi16() {
+    const fn test_mm_maskz_sllv_epi16() {
         let a = _mm_set1_epi16(1 << 15);
         let count = _mm_set1_epi16(2);
         let r = _mm_maskz_sllv_epi16(0, a, count);
@@ -18446,7 +18440,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_srl_epi16() {
+    fn test_mm512_srl_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm512_srl_epi16(a, count);
@@ -18455,7 +18449,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_srl_epi16() {
+    fn test_mm512_mask_srl_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm512_mask_srl_epi16(a, 0, a, count);
@@ -18466,7 +18460,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_srl_epi16() {
+    fn test_mm512_maskz_srl_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm512_maskz_srl_epi16(0, a, count);
@@ -18477,7 +18471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_srl_epi16() {
+    fn test_mm256_mask_srl_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm256_mask_srl_epi16(a, 0, a, count);
@@ -18488,7 +18482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_srl_epi16() {
+    fn test_mm256_maskz_srl_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm256_maskz_srl_epi16(0, a, count);
@@ -18499,7 +18493,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_srl_epi16() {
+    fn test_mm_mask_srl_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm_mask_srl_epi16(a, 0, a, count);
@@ -18510,7 +18504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_srl_epi16() {
+    fn test_mm_maskz_srl_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm_maskz_srl_epi16(0, a, count);
@@ -18521,7 +18515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_srli_epi16() {
+    const fn test_mm512_srli_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let r = _mm512_srli_epi16::<2>(a);
         let e = _mm512_set1_epi16(0);
@@ -18529,7 +18523,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_srli_epi16() {
+    const fn test_mm512_mask_srli_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let r = _mm512_mask_srli_epi16::<2>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -18539,7 +18533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_srli_epi16() {
+    const fn test_mm512_maskz_srli_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let r = _mm512_maskz_srli_epi16::<2>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -18549,7 +18543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_srli_epi16() {
+    const fn test_mm256_mask_srli_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let r = _mm256_mask_srli_epi16::<2>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -18559,7 +18553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_srli_epi16() {
+    const fn test_mm256_maskz_srli_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let r = _mm256_maskz_srli_epi16::<2>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -18569,7 +18563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_srli_epi16() {
+    const fn test_mm_mask_srli_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let r = _mm_mask_srli_epi16::<2>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -18579,7 +18573,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_srli_epi16() {
+    const fn test_mm_maskz_srli_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let r = _mm_maskz_srli_epi16::<2>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -18589,7 +18583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_srlv_epi16() {
+    const fn test_mm512_srlv_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_srlv_epi16(a, count);
@@ -18598,7 +18592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_srlv_epi16() {
+    const fn test_mm512_mask_srlv_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_mask_srlv_epi16(a, 0, a, count);
@@ -18609,7 +18603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_srlv_epi16() {
+    const fn test_mm512_maskz_srlv_epi16() {
         let a = _mm512_set1_epi16(1 << 1);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_maskz_srlv_epi16(0, a, count);
@@ -18620,7 +18614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_srlv_epi16() {
+    const fn test_mm256_srlv_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_srlv_epi16(a, count);
@@ -18629,7 +18623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_srlv_epi16() {
+    const fn test_mm256_mask_srlv_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_mask_srlv_epi16(a, 0, a, count);
@@ -18640,7 +18634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_srlv_epi16() {
+    const fn test_mm256_maskz_srlv_epi16() {
         let a = _mm256_set1_epi16(1 << 1);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_maskz_srlv_epi16(0, a, count);
@@ -18651,7 +18645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_srlv_epi16() {
+    const fn test_mm_srlv_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm_srlv_epi16(a, count);
@@ -18660,7 +18654,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_srlv_epi16() {
+    const fn test_mm_mask_srlv_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm_mask_srlv_epi16(a, 0, a, count);
@@ -18671,7 +18665,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_srlv_epi16() {
+    const fn test_mm_maskz_srlv_epi16() {
         let a = _mm_set1_epi16(1 << 1);
         let count = _mm_set1_epi16(2);
         let r = _mm_maskz_srlv_epi16(0, a, count);
@@ -18682,7 +18676,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_sra_epi16() {
+    fn test_mm512_sra_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm512_sra_epi16(a, count);
@@ -18691,7 +18685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_sra_epi16() {
+    fn test_mm512_mask_sra_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm512_mask_sra_epi16(a, 0, a, count);
@@ -18702,7 +18696,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_sra_epi16() {
+    fn test_mm512_maskz_sra_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm512_maskz_sra_epi16(0, a, count);
@@ -18713,7 +18707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_sra_epi16() {
+    fn test_mm256_mask_sra_epi16() {
         let a = _mm256_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm256_mask_sra_epi16(a, 0, a, count);
@@ -18724,7 +18718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_sra_epi16() {
+    fn test_mm256_maskz_sra_epi16() {
         let a = _mm256_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm256_maskz_sra_epi16(0, a, count);
@@ -18735,7 +18729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_sra_epi16() {
+    fn test_mm_mask_sra_epi16() {
         let a = _mm_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm_mask_sra_epi16(a, 0, a, count);
@@ -18746,7 +18740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_sra_epi16() {
+    fn test_mm_maskz_sra_epi16() {
         let a = _mm_set1_epi16(8);
         let count = _mm_set1_epi16(1);
         let r = _mm_maskz_sra_epi16(0, a, count);
@@ -18757,7 +18751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_srai_epi16() {
+    const fn test_mm512_srai_epi16() {
         let a = _mm512_set1_epi16(8);
         let r = _mm512_srai_epi16::<2>(a);
         let e = _mm512_set1_epi16(2);
@@ -18765,7 +18759,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_srai_epi16() {
+    const fn test_mm512_mask_srai_epi16() {
         let a = _mm512_set1_epi16(8);
         let r = _mm512_mask_srai_epi16::<2>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -18775,7 +18769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_srai_epi16() {
+    const fn test_mm512_maskz_srai_epi16() {
         let a = _mm512_set1_epi16(8);
         let r = _mm512_maskz_srai_epi16::<2>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -18785,7 +18779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_srai_epi16() {
+    const fn test_mm256_mask_srai_epi16() {
         let a = _mm256_set1_epi16(8);
         let r = _mm256_mask_srai_epi16::<2>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -18795,7 +18789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_srai_epi16() {
+    const fn test_mm256_maskz_srai_epi16() {
         let a = _mm256_set1_epi16(8);
         let r = _mm256_maskz_srai_epi16::<2>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -18805,7 +18799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_srai_epi16() {
+    const fn test_mm_mask_srai_epi16() {
         let a = _mm_set1_epi16(8);
         let r = _mm_mask_srai_epi16::<2>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -18815,7 +18809,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_srai_epi16() {
+    const fn test_mm_maskz_srai_epi16() {
         let a = _mm_set1_epi16(8);
         let r = _mm_maskz_srai_epi16::<2>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -18825,7 +18819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_srav_epi16() {
+    const fn test_mm512_srav_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_srav_epi16(a, count);
@@ -18834,7 +18828,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_srav_epi16() {
+    const fn test_mm512_mask_srav_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_mask_srav_epi16(a, 0, a, count);
@@ -18845,7 +18839,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_srav_epi16() {
+    const fn test_mm512_maskz_srav_epi16() {
         let a = _mm512_set1_epi16(8);
         let count = _mm512_set1_epi16(2);
         let r = _mm512_maskz_srav_epi16(0, a, count);
@@ -18856,7 +18850,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_srav_epi16() {
+    const fn test_mm256_srav_epi16() {
         let a = _mm256_set1_epi16(8);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_srav_epi16(a, count);
@@ -18865,7 +18859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_srav_epi16() {
+    const fn test_mm256_mask_srav_epi16() {
         let a = _mm256_set1_epi16(8);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_mask_srav_epi16(a, 0, a, count);
@@ -18876,7 +18870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_srav_epi16() {
+    const fn test_mm256_maskz_srav_epi16() {
         let a = _mm256_set1_epi16(8);
         let count = _mm256_set1_epi16(2);
         let r = _mm256_maskz_srav_epi16(0, a, count);
@@ -18887,7 +18881,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_srav_epi16() {
+    const fn test_mm_srav_epi16() {
         let a = _mm_set1_epi16(8);
         let count = _mm_set1_epi16(2);
         let r = _mm_srav_epi16(a, count);
@@ -18896,7 +18890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_srav_epi16() {
+    const fn test_mm_mask_srav_epi16() {
         let a = _mm_set1_epi16(8);
         let count = _mm_set1_epi16(2);
         let r = _mm_mask_srav_epi16(a, 0, a, count);
@@ -18907,7 +18901,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_srav_epi16() {
+    const fn test_mm_maskz_srav_epi16() {
         let a = _mm_set1_epi16(8);
         let count = _mm_set1_epi16(2);
         let r = _mm_maskz_srav_epi16(0, a, count);
@@ -18918,7 +18912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_permutex2var_epi16() {
+    fn test_mm512_permutex2var_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -18936,7 +18930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_permutex2var_epi16() {
+    fn test_mm512_mask_permutex2var_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -18956,7 +18950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_permutex2var_epi16() {
+    fn test_mm512_maskz_permutex2var_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -18976,7 +18970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask2_permutex2var_epi16() {
+    fn test_mm512_mask2_permutex2var_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -18996,7 +18990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_permutex2var_epi16() {
+    fn test_mm256_permutex2var_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm256_set_epi16(1, 1<<4, 2, 1<<4, 3, 1<<4, 4, 1<<4, 5, 1<<4, 6, 1<<4, 7, 1<<4, 8, 1<<4);
@@ -19009,7 +19003,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_epi16() {
+    fn test_mm256_mask_permutex2var_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm256_set_epi16(1, 1<<4, 2, 1<<4, 3, 1<<4, 4, 1<<4, 5, 1<<4, 6, 1<<4, 7, 1<<4, 8, 1<<4);
@@ -19024,7 +19018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_epi16() {
+    fn test_mm256_maskz_permutex2var_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm256_set_epi16(1, 1<<4, 2, 1<<4, 3, 1<<4, 4, 1<<4, 5, 1<<4, 6, 1<<4, 7, 1<<4, 8, 1<<4);
@@ -19039,7 +19033,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_epi16() {
+    fn test_mm256_mask2_permutex2var_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm256_set_epi16(1, 1<<4, 2, 1<<4, 3, 1<<4, 4, 1<<4, 5, 1<<4, 6, 1<<4, 7, 1<<4, 8, 1<<4);
@@ -19055,7 +19049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_permutex2var_epi16() {
+    fn test_mm_permutex2var_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm_set_epi16(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm_set1_epi16(100);
@@ -19065,7 +19059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_epi16() {
+    fn test_mm_mask_permutex2var_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm_set_epi16(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm_set1_epi16(100);
@@ -19077,7 +19071,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_epi16() {
+    fn test_mm_maskz_permutex2var_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm_set_epi16(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm_set1_epi16(100);
@@ -19089,7 +19083,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_epi16() {
+    fn test_mm_mask2_permutex2var_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm_set_epi16(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm_set1_epi16(100);
@@ -19101,7 +19095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_permutexvar_epi16() {
+    fn test_mm512_permutexvar_epi16() {
         let idx = _mm512_set1_epi16(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -19112,7 +19106,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_permutexvar_epi16() {
+    fn test_mm512_mask_permutexvar_epi16() {
         let idx = _mm512_set1_epi16(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -19125,7 +19119,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_permutexvar_epi16() {
+    fn test_mm512_maskz_permutexvar_epi16() {
         let idx = _mm512_set1_epi16(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -19138,7 +19132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_permutexvar_epi16() {
+    fn test_mm256_permutexvar_epi16() {
         let idx = _mm256_set1_epi16(1);
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_permutexvar_epi16(idx, a);
@@ -19147,7 +19141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_epi16() {
+    fn test_mm256_mask_permutexvar_epi16() {
         let idx = _mm256_set1_epi16(1);
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_mask_permutexvar_epi16(a, 0, idx, a);
@@ -19158,7 +19152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_epi16() {
+    fn test_mm256_maskz_permutexvar_epi16() {
         let idx = _mm256_set1_epi16(1);
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_permutexvar_epi16(0, idx, a);
@@ -19169,7 +19163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_permutexvar_epi16() {
+    fn test_mm_permutexvar_epi16() {
         let idx = _mm_set1_epi16(1);
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_permutexvar_epi16(idx, a);
@@ -19178,7 +19172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_permutexvar_epi16() {
+    fn test_mm_mask_permutexvar_epi16() {
         let idx = _mm_set1_epi16(1);
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_mask_permutexvar_epi16(a, 0, idx, a);
@@ -19189,7 +19183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_permutexvar_epi16() {
+    fn test_mm_maskz_permutexvar_epi16() {
         let idx = _mm_set1_epi16(1);
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_permutexvar_epi16(0, idx, a);
@@ -19200,7 +19194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_blend_epi16() {
+    const fn test_mm512_mask_blend_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(2);
         let r = _mm512_mask_blend_epi16(0b11111111_00000000_11111111_00000000, a, b);
@@ -19211,7 +19205,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_epi16() {
+    const fn test_mm256_mask_blend_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(2);
         let r = _mm256_mask_blend_epi16(0b11111111_00000000, a, b);
@@ -19220,7 +19214,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_blend_epi16() {
+    const fn test_mm_mask_blend_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(2);
         let r = _mm_mask_blend_epi16(0b11110000, a, b);
@@ -19229,7 +19223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_blend_epi8() {
+    const fn test_mm512_mask_blend_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(2);
         let r = _mm512_mask_blend_epi8(
@@ -19246,7 +19240,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_epi8() {
+    const fn test_mm256_mask_blend_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(2);
         let r = _mm256_mask_blend_epi8(0b11111111_00000000_11111111_00000000, a, b);
@@ -19257,7 +19251,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_blend_epi8() {
+    const fn test_mm_mask_blend_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(2);
         let r = _mm_mask_blend_epi8(0b11111111_00000000, a, b);
@@ -19266,7 +19260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_broadcastw_epi16() {
+    const fn test_mm512_broadcastw_epi16() {
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_broadcastw_epi16(a);
         let e = _mm512_set1_epi16(24);
@@ -19274,7 +19268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_broadcastw_epi16() {
+    const fn test_mm512_mask_broadcastw_epi16() {
         let src = _mm512_set1_epi16(1);
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_mask_broadcastw_epi16(src, 0, a);
@@ -19285,7 +19279,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_broadcastw_epi16() {
+    const fn test_mm512_maskz_broadcastw_epi16() {
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_maskz_broadcastw_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -19295,7 +19289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastw_epi16() {
+    const fn test_mm256_mask_broadcastw_epi16() {
         let src = _mm256_set1_epi16(1);
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_mask_broadcastw_epi16(src, 0, a);
@@ -19306,7 +19300,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastw_epi16() {
+    const fn test_mm256_maskz_broadcastw_epi16() {
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_maskz_broadcastw_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -19316,7 +19310,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_broadcastw_epi16() {
+    const fn test_mm_mask_broadcastw_epi16() {
         let src = _mm_set1_epi16(1);
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm_mask_broadcastw_epi16(src, 0, a);
@@ -19327,7 +19321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcastw_epi16() {
+    const fn test_mm_maskz_broadcastw_epi16() {
         let a = _mm_set_epi16(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm_maskz_broadcastw_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -19337,7 +19331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_broadcastb_epi8() {
+    const fn test_mm512_broadcastb_epi8() {
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
         );
@@ -19347,7 +19341,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_broadcastb_epi8() {
+    const fn test_mm512_mask_broadcastb_epi8() {
         let src = _mm512_set1_epi8(1);
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19364,7 +19358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_broadcastb_epi8() {
+    const fn test_mm512_maskz_broadcastb_epi8() {
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
         );
@@ -19379,7 +19373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastb_epi8() {
+    const fn test_mm256_mask_broadcastb_epi8() {
         let src = _mm256_set1_epi8(1);
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19392,7 +19386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastb_epi8() {
+    const fn test_mm256_maskz_broadcastb_epi8() {
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
         );
@@ -19404,7 +19398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_broadcastb_epi8() {
+    const fn test_mm_mask_broadcastb_epi8() {
         let src = _mm_set1_epi8(1);
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19417,7 +19411,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcastb_epi8() {
+    const fn test_mm_maskz_broadcastb_epi8() {
         let a = _mm_set_epi8(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
         );
@@ -19429,7 +19423,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_unpackhi_epi16() {
+    const fn test_mm512_unpackhi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19444,7 +19438,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_unpackhi_epi16() {
+    const fn test_mm512_mask_unpackhi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19461,7 +19455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_unpackhi_epi16() {
+    const fn test_mm512_maskz_unpackhi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19478,7 +19472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_epi16() {
+    const fn test_mm256_mask_unpackhi_epi16() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi16(
             33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
@@ -19491,7 +19485,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_epi16() {
+    const fn test_mm256_maskz_unpackhi_epi16() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi16(
             33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
@@ -19504,7 +19498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_epi16() {
+    const fn test_mm_mask_unpackhi_epi16() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi16(33, 34, 35, 36, 37, 38, 39, 40);
         let r = _mm_mask_unpackhi_epi16(a, 0, a, b);
@@ -19515,7 +19509,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_epi16() {
+    const fn test_mm_maskz_unpackhi_epi16() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi16(33, 34, 35, 36, 37, 38, 39, 40);
         let r = _mm_maskz_unpackhi_epi16(0, a, b);
@@ -19526,7 +19520,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_unpackhi_epi8() {
+    const fn test_mm512_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19547,7 +19541,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_unpackhi_epi8() {
+    const fn test_mm512_mask_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19575,7 +19569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_unpackhi_epi8() {
+    const fn test_mm512_maskz_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19602,7 +19596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_epi8() {
+    const fn test_mm256_mask_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19619,7 +19613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_epi8() {
+    const fn test_mm256_maskz_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19636,7 +19630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_epi8() {
+    const fn test_mm_mask_unpackhi_epi8() {
         let a = _mm_set_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_set_epi8(
             65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
@@ -19649,7 +19643,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_epi8() {
+    const fn test_mm_maskz_unpackhi_epi8() {
         let a = _mm_set_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_set_epi8(
             65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
@@ -19662,7 +19656,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_unpacklo_epi16() {
+    const fn test_mm512_unpacklo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19677,7 +19671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_unpacklo_epi16() {
+    const fn test_mm512_mask_unpacklo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19694,7 +19688,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_unpacklo_epi16() {
+    const fn test_mm512_maskz_unpacklo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19711,7 +19705,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_epi16() {
+    const fn test_mm256_mask_unpacklo_epi16() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi16(
             33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
@@ -19724,7 +19718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_epi16() {
+    const fn test_mm256_maskz_unpacklo_epi16() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi16(
             33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
@@ -19737,7 +19731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_epi16() {
+    const fn test_mm_mask_unpacklo_epi16() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi16(33, 34, 35, 36, 37, 38, 39, 40);
         let r = _mm_mask_unpacklo_epi16(a, 0, a, b);
@@ -19748,7 +19742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_epi16() {
+    const fn test_mm_maskz_unpacklo_epi16() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi16(33, 34, 35, 36, 37, 38, 39, 40);
         let r = _mm_maskz_unpacklo_epi16(0, a, b);
@@ -19759,7 +19753,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_unpacklo_epi8() {
+    const fn test_mm512_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19780,7 +19774,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_unpacklo_epi8() {
+    const fn test_mm512_mask_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19808,7 +19802,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_unpacklo_epi8() {
+    const fn test_mm512_maskz_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -19835,7 +19829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_epi8() {
+    const fn test_mm256_mask_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19852,7 +19846,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_epi8() {
+    const fn test_mm256_maskz_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
@@ -19869,7 +19863,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_epi8() {
+    const fn test_mm_mask_unpacklo_epi8() {
         let a = _mm_set_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_set_epi8(
             65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
@@ -19884,7 +19878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_epi8() {
+    const fn test_mm_maskz_unpacklo_epi8() {
         let a = _mm_set_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_set_epi8(
             65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
@@ -19899,7 +19893,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_mov_epi16() {
+    const fn test_mm512_mask_mov_epi16() {
         let src = _mm512_set1_epi16(1);
         let a = _mm512_set1_epi16(2);
         let r = _mm512_mask_mov_epi16(src, 0, a);
@@ -19909,7 +19903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_mov_epi16() {
+    const fn test_mm512_maskz_mov_epi16() {
         let a = _mm512_set1_epi16(2);
         let r = _mm512_maskz_mov_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -19918,7 +19912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_epi16() {
+    const fn test_mm256_mask_mov_epi16() {
         let src = _mm256_set1_epi16(1);
         let a = _mm256_set1_epi16(2);
         let r = _mm256_mask_mov_epi16(src, 0, a);
@@ -19928,7 +19922,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_epi16() {
+    const fn test_mm256_maskz_mov_epi16() {
         let a = _mm256_set1_epi16(2);
         let r = _mm256_maskz_mov_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -19937,7 +19931,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_mov_epi16() {
+    const fn test_mm_mask_mov_epi16() {
         let src = _mm_set1_epi16(1);
         let a = _mm_set1_epi16(2);
         let r = _mm_mask_mov_epi16(src, 0, a);
@@ -19947,7 +19941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_epi16() {
+    const fn test_mm_maskz_mov_epi16() {
         let a = _mm_set1_epi16(2);
         let r = _mm_maskz_mov_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -19956,7 +19950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_mov_epi8() {
+    const fn test_mm512_mask_mov_epi8() {
         let src = _mm512_set1_epi8(1);
         let a = _mm512_set1_epi8(2);
         let r = _mm512_mask_mov_epi8(src, 0, a);
@@ -19970,7 +19964,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_mov_epi8() {
+    const fn test_mm512_maskz_mov_epi8() {
         let a = _mm512_set1_epi8(2);
         let r = _mm512_maskz_mov_epi8(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -19982,7 +19976,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_epi8() {
+    const fn test_mm256_mask_mov_epi8() {
         let src = _mm256_set1_epi8(1);
         let a = _mm256_set1_epi8(2);
         let r = _mm256_mask_mov_epi8(src, 0, a);
@@ -19992,7 +19986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_epi8() {
+    const fn test_mm256_maskz_mov_epi8() {
         let a = _mm256_set1_epi8(2);
         let r = _mm256_maskz_mov_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -20001,7 +19995,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_mov_epi8() {
+    const fn test_mm_mask_mov_epi8() {
         let src = _mm_set1_epi8(1);
         let a = _mm_set1_epi8(2);
         let r = _mm_mask_mov_epi8(src, 0, a);
@@ -20011,7 +20005,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_epi8() {
+    const fn test_mm_maskz_mov_epi8() {
         let a = _mm_set1_epi8(2);
         let r = _mm_maskz_mov_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -20020,7 +20014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_set1_epi16() {
+    const fn test_mm512_mask_set1_epi16() {
         let src = _mm512_set1_epi16(2);
         let a: i16 = 11;
         let r = _mm512_mask_set1_epi16(src, 0, a);
@@ -20031,7 +20025,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_set1_epi16() {
+    const fn test_mm512_maskz_set1_epi16() {
         let a: i16 = 11;
         let r = _mm512_maskz_set1_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -20041,7 +20035,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_set1_epi16() {
+    const fn test_mm256_mask_set1_epi16() {
         let src = _mm256_set1_epi16(2);
         let a: i16 = 11;
         let r = _mm256_mask_set1_epi16(src, 0, a);
@@ -20052,7 +20046,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_set1_epi16() {
+    const fn test_mm256_maskz_set1_epi16() {
         let a: i16 = 11;
         let r = _mm256_maskz_set1_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -20062,7 +20056,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_set1_epi16() {
+    const fn test_mm_mask_set1_epi16() {
         let src = _mm_set1_epi16(2);
         let a: i16 = 11;
         let r = _mm_mask_set1_epi16(src, 0, a);
@@ -20073,7 +20067,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_set1_epi16() {
+    const fn test_mm_maskz_set1_epi16() {
         let a: i16 = 11;
         let r = _mm_maskz_set1_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -20083,7 +20077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_set1_epi8() {
+    const fn test_mm512_mask_set1_epi8() {
         let src = _mm512_set1_epi8(2);
         let a: i8 = 11;
         let r = _mm512_mask_set1_epi8(src, 0, a);
@@ -20098,7 +20092,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_set1_epi8() {
+    const fn test_mm512_maskz_set1_epi8() {
         let a: i8 = 11;
         let r = _mm512_maskz_set1_epi8(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -20111,7 +20105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_set1_epi8() {
+    const fn test_mm256_mask_set1_epi8() {
         let src = _mm256_set1_epi8(2);
         let a: i8 = 11;
         let r = _mm256_mask_set1_epi8(src, 0, a);
@@ -20122,7 +20116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_set1_epi8() {
+    const fn test_mm256_maskz_set1_epi8() {
         let a: i8 = 11;
         let r = _mm256_maskz_set1_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -20132,7 +20126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_set1_epi8() {
+    const fn test_mm_mask_set1_epi8() {
         let src = _mm_set1_epi8(2);
         let a: i8 = 11;
         let r = _mm_mask_set1_epi8(src, 0, a);
@@ -20143,7 +20137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_set1_epi8() {
+    const fn test_mm_maskz_set1_epi8() {
         let a: i8 = 11;
         let r = _mm_maskz_set1_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -20153,7 +20147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_shufflelo_epi16() {
+    const fn test_mm512_shufflelo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20169,7 +20163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_shufflelo_epi16() {
+    const fn test_mm512_mask_shufflelo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20191,7 +20185,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_shufflelo_epi16() {
+    const fn test_mm512_maskz_shufflelo_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20210,7 +20204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_shufflelo_epi16() {
+    const fn test_mm256_mask_shufflelo_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_mask_shufflelo_epi16::<0b00_01_01_11>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -20220,7 +20214,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_shufflelo_epi16() {
+    const fn test_mm256_maskz_shufflelo_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_shufflelo_epi16::<0b00_01_01_11>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -20230,7 +20224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_shufflelo_epi16() {
+    const fn test_mm_mask_shufflelo_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_mask_shufflelo_epi16::<0b00_01_01_11>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -20240,7 +20234,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_shufflelo_epi16() {
+    const fn test_mm_maskz_shufflelo_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_shufflelo_epi16::<0b00_01_01_11>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -20250,7 +20244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_shufflehi_epi16() {
+    const fn test_mm512_shufflehi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20266,7 +20260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_shufflehi_epi16() {
+    const fn test_mm512_mask_shufflehi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20288,7 +20282,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_shufflehi_epi16() {
+    const fn test_mm512_maskz_shufflehi_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -20307,7 +20301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_shufflehi_epi16() {
+    const fn test_mm256_mask_shufflehi_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_mask_shufflehi_epi16::<0b00_01_01_11>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -20317,7 +20311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_shufflehi_epi16() {
+    const fn test_mm256_maskz_shufflehi_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_shufflehi_epi16::<0b00_01_01_11>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -20327,7 +20321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_shufflehi_epi16() {
+    const fn test_mm_mask_shufflehi_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_mask_shufflehi_epi16::<0b00_01_01_11>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -20337,7 +20331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_shufflehi_epi16() {
+    const fn test_mm_maskz_shufflehi_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_shufflehi_epi16::<0b00_01_01_11>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -20347,7 +20341,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_shuffle_epi8() {
+    fn test_mm512_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -20364,7 +20358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_shuffle_epi8() {
+    fn test_mm512_mask_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -20388,7 +20382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_shuffle_epi8() {
+    fn test_mm512_maskz_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -20411,7 +20405,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_shuffle_epi8() {
+    fn test_mm256_mask_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -20426,7 +20420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_shuffle_epi8() {
+    fn test_mm256_maskz_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -20441,7 +20435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_shuffle_epi8() {
+    fn test_mm_mask_shuffle_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_set1_epi8(1);
         let r = _mm_mask_shuffle_epi8(a, 0, a, b);
@@ -20454,7 +20448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_shuffle_epi8() {
+    fn test_mm_maskz_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15);
         let b = _mm_set1_epi8(1);
@@ -20468,7 +20462,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_test_epi16_mask() {
+    const fn test_mm512_test_epi16_mask() {
         let a = _mm512_set1_epi16(1 << 0);
         let b = _mm512_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm512_test_epi16_mask(a, b);
@@ -20477,7 +20471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_test_epi16_mask() {
+    const fn test_mm512_mask_test_epi16_mask() {
         let a = _mm512_set1_epi16(1 << 0);
         let b = _mm512_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm512_mask_test_epi16_mask(0, a, b);
@@ -20488,7 +20482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_test_epi16_mask() {
+    const fn test_mm256_test_epi16_mask() {
         let a = _mm256_set1_epi16(1 << 0);
         let b = _mm256_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm256_test_epi16_mask(a, b);
@@ -20497,7 +20491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_test_epi16_mask() {
+    const fn test_mm256_mask_test_epi16_mask() {
         let a = _mm256_set1_epi16(1 << 0);
         let b = _mm256_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm256_mask_test_epi16_mask(0, a, b);
@@ -20508,7 +20502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_test_epi16_mask() {
+    const fn test_mm_test_epi16_mask() {
         let a = _mm_set1_epi16(1 << 0);
         let b = _mm_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm_test_epi16_mask(a, b);
@@ -20517,7 +20511,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_test_epi16_mask() {
+    const fn test_mm_mask_test_epi16_mask() {
         let a = _mm_set1_epi16(1 << 0);
         let b = _mm_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm_mask_test_epi16_mask(0, a, b);
@@ -20528,7 +20522,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_test_epi8_mask() {
+    const fn test_mm512_test_epi8_mask() {
         let a = _mm512_set1_epi8(1 << 0);
         let b = _mm512_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm512_test_epi8_mask(a, b);
@@ -20538,7 +20532,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_test_epi8_mask() {
+    const fn test_mm512_mask_test_epi8_mask() {
         let a = _mm512_set1_epi8(1 << 0);
         let b = _mm512_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm512_mask_test_epi8_mask(0, a, b);
@@ -20554,7 +20548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_test_epi8_mask() {
+    const fn test_mm256_test_epi8_mask() {
         let a = _mm256_set1_epi8(1 << 0);
         let b = _mm256_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm256_test_epi8_mask(a, b);
@@ -20563,7 +20557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_test_epi8_mask() {
+    const fn test_mm256_mask_test_epi8_mask() {
         let a = _mm256_set1_epi8(1 << 0);
         let b = _mm256_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm256_mask_test_epi8_mask(0, a, b);
@@ -20574,7 +20568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_test_epi8_mask() {
+    const fn test_mm_test_epi8_mask() {
         let a = _mm_set1_epi8(1 << 0);
         let b = _mm_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm_test_epi8_mask(a, b);
@@ -20583,7 +20577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_test_epi8_mask() {
+    const fn test_mm_mask_test_epi8_mask() {
         let a = _mm_set1_epi8(1 << 0);
         let b = _mm_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm_mask_test_epi8_mask(0, a, b);
@@ -20594,7 +20588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_testn_epi16_mask() {
+    const fn test_mm512_testn_epi16_mask() {
         let a = _mm512_set1_epi16(1 << 0);
         let b = _mm512_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm512_testn_epi16_mask(a, b);
@@ -20603,7 +20597,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_testn_epi16_mask() {
+    const fn test_mm512_mask_testn_epi16_mask() {
         let a = _mm512_set1_epi16(1 << 0);
         let b = _mm512_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm512_mask_testn_epi16_mask(0, a, b);
@@ -20614,7 +20608,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_testn_epi16_mask() {
+    const fn test_mm256_testn_epi16_mask() {
         let a = _mm256_set1_epi16(1 << 0);
         let b = _mm256_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm256_testn_epi16_mask(a, b);
@@ -20623,7 +20617,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_testn_epi16_mask() {
+    const fn test_mm256_mask_testn_epi16_mask() {
         let a = _mm256_set1_epi16(1 << 0);
         let b = _mm256_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm256_mask_testn_epi16_mask(0, a, b);
@@ -20634,7 +20628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_testn_epi16_mask() {
+    const fn test_mm_testn_epi16_mask() {
         let a = _mm_set1_epi16(1 << 0);
         let b = _mm_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm_testn_epi16_mask(a, b);
@@ -20643,7 +20637,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_testn_epi16_mask() {
+    const fn test_mm_mask_testn_epi16_mask() {
         let a = _mm_set1_epi16(1 << 0);
         let b = _mm_set1_epi16(1 << 0 | 1 << 1);
         let r = _mm_mask_testn_epi16_mask(0, a, b);
@@ -20654,7 +20648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_testn_epi8_mask() {
+    const fn test_mm512_testn_epi8_mask() {
         let a = _mm512_set1_epi8(1 << 0);
         let b = _mm512_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm512_testn_epi8_mask(a, b);
@@ -20664,7 +20658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_testn_epi8_mask() {
+    const fn test_mm512_mask_testn_epi8_mask() {
         let a = _mm512_set1_epi8(1 << 0);
         let b = _mm512_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm512_mask_testn_epi8_mask(0, a, b);
@@ -20680,7 +20674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_testn_epi8_mask() {
+    const fn test_mm256_testn_epi8_mask() {
         let a = _mm256_set1_epi8(1 << 0);
         let b = _mm256_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm256_testn_epi8_mask(a, b);
@@ -20689,7 +20683,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_testn_epi8_mask() {
+    const fn test_mm256_mask_testn_epi8_mask() {
         let a = _mm256_set1_epi8(1 << 0);
         let b = _mm256_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm256_mask_testn_epi8_mask(0, a, b);
@@ -20700,7 +20694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_testn_epi8_mask() {
+    const fn test_mm_testn_epi8_mask() {
         let a = _mm_set1_epi8(1 << 0);
         let b = _mm_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm_testn_epi8_mask(a, b);
@@ -20709,7 +20703,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_testn_epi8_mask() {
+    const fn test_mm_mask_testn_epi8_mask() {
         let a = _mm_set1_epi8(1 << 0);
         let b = _mm_set1_epi8(1 << 0 | 1 << 1);
         let r = _mm_mask_testn_epi8_mask(0, a, b);
@@ -20755,7 +20749,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_sad_epu8() {
+    fn test_mm512_sad_epu8() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(4);
         let r = _mm512_sad_epu8(a, b);
@@ -20764,7 +20758,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_dbsad_epu8() {
+    fn test_mm512_dbsad_epu8() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(4);
         let r = _mm512_dbsad_epu8::<0>(a, b);
@@ -20773,7 +20767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_dbsad_epu8() {
+    fn test_mm512_mask_dbsad_epu8() {
         let src = _mm512_set1_epi16(1);
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(4);
@@ -20785,7 +20779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_dbsad_epu8() {
+    fn test_mm512_maskz_dbsad_epu8() {
         let a = _mm512_set1_epi8(2);
         let b = _mm512_set1_epi8(4);
         let r = _mm512_maskz_dbsad_epu8::<0>(0, a, b);
@@ -20796,7 +20790,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_dbsad_epu8() {
+    fn test_mm256_dbsad_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_dbsad_epu8::<0>(a, b);
@@ -20805,7 +20799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_dbsad_epu8() {
+    fn test_mm256_mask_dbsad_epu8() {
         let src = _mm256_set1_epi16(1);
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
@@ -20817,7 +20811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_dbsad_epu8() {
+    fn test_mm256_maskz_dbsad_epu8() {
         let a = _mm256_set1_epi8(2);
         let b = _mm256_set1_epi8(4);
         let r = _mm256_maskz_dbsad_epu8::<0>(0, a, b);
@@ -20828,7 +20822,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_dbsad_epu8() {
+    fn test_mm_dbsad_epu8() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(4);
         let r = _mm_dbsad_epu8::<0>(a, b);
@@ -20837,7 +20831,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_dbsad_epu8() {
+    fn test_mm_mask_dbsad_epu8() {
         let src = _mm_set1_epi16(1);
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(4);
@@ -20849,7 +20843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_dbsad_epu8() {
+    fn test_mm_maskz_dbsad_epu8() {
         let a = _mm_set1_epi8(2);
         let b = _mm_set1_epi8(4);
         let r = _mm_maskz_dbsad_epu8::<0>(0, a, b);
@@ -20860,7 +20854,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_movepi16_mask() {
+    const fn test_mm512_movepi16_mask() {
         let a = _mm512_set1_epi16(1 << 15);
         let r = _mm512_movepi16_mask(a);
         let e: __mmask32 = 0b11111111_11111111_11111111_11111111;
@@ -20868,7 +20862,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_movepi16_mask() {
+    const fn test_mm256_movepi16_mask() {
         let a = _mm256_set1_epi16(1 << 15);
         let r = _mm256_movepi16_mask(a);
         let e: __mmask16 = 0b11111111_11111111;
@@ -20876,7 +20870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_movepi16_mask() {
+    const fn test_mm_movepi16_mask() {
         let a = _mm_set1_epi16(1 << 15);
         let r = _mm_movepi16_mask(a);
         let e: __mmask8 = 0b11111111;
@@ -20884,7 +20878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_movepi8_mask() {
+    const fn test_mm512_movepi8_mask() {
         let a = _mm512_set1_epi8(1 << 7);
         let r = _mm512_movepi8_mask(a);
         let e: __mmask64 =
@@ -20893,7 +20887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_movepi8_mask() {
+    const fn test_mm256_movepi8_mask() {
         let a = _mm256_set1_epi8(1 << 7);
         let r = _mm256_movepi8_mask(a);
         let e: __mmask32 = 0b11111111_11111111_11111111_11111111;
@@ -20901,7 +20895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_movepi8_mask() {
+    const fn test_mm_movepi8_mask() {
         let a = _mm_set1_epi8(1 << 7);
         let r = _mm_movepi8_mask(a);
         let e: __mmask16 = 0b11111111_11111111;
@@ -20909,7 +20903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_movm_epi16() {
+    const fn test_mm512_movm_epi16() {
         let a: __mmask32 = 0b11111111_11111111_11111111_11111111;
         let r = _mm512_movm_epi16(a);
         let e = _mm512_set1_epi16(
@@ -20934,7 +20928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_movm_epi16() {
+    const fn test_mm256_movm_epi16() {
         let a: __mmask16 = 0b11111111_11111111;
         let r = _mm256_movm_epi16(a);
         let e = _mm256_set1_epi16(
@@ -20959,7 +20953,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_movm_epi16() {
+    const fn test_mm_movm_epi16() {
         let a: __mmask8 = 0b11111111;
         let r = _mm_movm_epi16(a);
         let e = _mm_set1_epi16(
@@ -20984,7 +20978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_movm_epi8() {
+    const fn test_mm512_movm_epi8() {
         let a: __mmask64 =
             0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111;
         let r = _mm512_movm_epi8(a);
@@ -20994,7 +20988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_movm_epi8() {
+    const fn test_mm256_movm_epi8() {
         let a: __mmask32 = 0b11111111_11111111_11111111_11111111;
         let r = _mm256_movm_epi8(a);
         let e =
@@ -21003,7 +20997,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_movm_epi8() {
+    const fn test_mm_movm_epi8() {
         let a: __mmask16 = 0b11111111_11111111;
         let r = _mm_movm_epi8(a);
         let e =
@@ -21012,7 +21006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_cvtmask32_u32() {
+    const fn test_cvtmask32_u32() {
         let a: __mmask32 = 0b11001100_00110011_01100110_10011001;
         let r = _cvtmask32_u32(a);
         let e: u32 = 0b11001100_00110011_01100110_10011001;
@@ -21020,7 +21014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_cvtu32_mask32() {
+    const fn test_cvtu32_mask32() {
         let a: u32 = 0b11001100_00110011_01100110_10011001;
         let r = _cvtu32_mask32(a);
         let e: __mmask32 = 0b11001100_00110011_01100110_10011001;
@@ -21028,7 +21022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kadd_mask32() {
+    const fn test_kadd_mask32() {
         let a: __mmask32 = 11;
         let b: __mmask32 = 22;
         let r = _kadd_mask32(a, b);
@@ -21037,7 +21031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kadd_mask64() {
+    const fn test_kadd_mask64() {
         let a: __mmask64 = 11;
         let b: __mmask64 = 22;
         let r = _kadd_mask64(a, b);
@@ -21046,7 +21040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kand_mask32() {
+    const fn test_kand_mask32() {
         let a: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let b: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _kand_mask32(a, b);
@@ -21055,7 +21049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kand_mask64() {
+    const fn test_kand_mask64() {
         let a: __mmask64 =
             0b11001100_00110011_11001100_00110011_11001100_00110011_11001100_00110011;
         let b: __mmask64 =
@@ -21067,7 +21061,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_knot_mask32() {
+    const fn test_knot_mask32() {
         let a: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _knot_mask32(a);
         let e: __mmask32 = 0b00110011_11001100_00110011_11001100;
@@ -21075,7 +21069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_knot_mask64() {
+    const fn test_knot_mask64() {
         let a: __mmask64 =
             0b11001100_00110011_11001100_00110011_11001100_00110011_11001100_00110011;
         let r = _knot_mask64(a);
@@ -21085,7 +21079,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kandn_mask32() {
+    const fn test_kandn_mask32() {
         let a: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let b: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _kandn_mask32(a, b);
@@ -21094,7 +21088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kandn_mask64() {
+    const fn test_kandn_mask64() {
         let a: __mmask64 =
             0b11001100_00110011_11001100_00110011_11001100_00110011_11001100_00110011;
         let b: __mmask64 =
@@ -21106,7 +21100,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kor_mask32() {
+    const fn test_kor_mask32() {
         let a: __mmask32 = 0b00110011_11001100_00110011_11001100;
         let b: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _kor_mask32(a, b);
@@ -21115,7 +21109,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kor_mask64() {
+    const fn test_kor_mask64() {
         let a: __mmask64 =
             0b00110011_11001100_00110011_11001100_00110011_11001100_00110011_11001100;
         let b: __mmask64 =
@@ -21127,7 +21121,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kxor_mask32() {
+    const fn test_kxor_mask32() {
         let a: __mmask32 = 0b00110011_11001100_00110011_11001100;
         let b: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _kxor_mask32(a, b);
@@ -21136,7 +21130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kxor_mask64() {
+    const fn test_kxor_mask64() {
         let a: __mmask64 =
             0b00110011_11001100_00110011_11001100_00110011_11001100_00110011_11001100;
         let b: __mmask64 =
@@ -21148,7 +21142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kxnor_mask32() {
+    const fn test_kxnor_mask32() {
         let a: __mmask32 = 0b00110011_11001100_00110011_11001100;
         let b: __mmask32 = 0b11001100_00110011_11001100_00110011;
         let r = _kxnor_mask32(a, b);
@@ -21157,7 +21151,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kxnor_mask64() {
+    const fn test_kxnor_mask64() {
         let a: __mmask64 =
             0b00110011_11001100_00110011_11001100_00110011_11001100_00110011_11001100;
         let b: __mmask64 =
@@ -21189,7 +21183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kortestc_mask32_u8() {
+    const fn test_kortestc_mask32_u8() {
         let a: __mmask32 = 0b0110100101101001_0110100101101001;
         let b: __mmask32 = 0b1011011010110110_1011011010110110;
         let r = _kortestc_mask32_u8(a, b);
@@ -21197,7 +21191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kortestc_mask64_u8() {
+    const fn test_kortestc_mask64_u8() {
         let a: __mmask64 = 0b0110100101101001_0110100101101001;
         let b: __mmask64 = 0b1011011010110110_1011011010110110;
         let r = _kortestc_mask64_u8(a, b);
@@ -21205,7 +21199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kortestz_mask32_u8() {
+    const fn test_kortestz_mask32_u8() {
         let a: __mmask32 = 0b0110100101101001_0110100101101001;
         let b: __mmask32 = 0b1011011010110110_1011011010110110;
         let r = _kortestz_mask32_u8(a, b);
@@ -21213,7 +21207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kortestz_mask64_u8() {
+    const fn test_kortestz_mask64_u8() {
         let a: __mmask64 = 0b0110100101101001_0110100101101001;
         let b: __mmask64 = 0b1011011010110110_1011011010110110;
         let r = _kortestz_mask64_u8(a, b);
@@ -21221,7 +21215,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kshiftli_mask32() {
+    const fn test_kshiftli_mask32() {
         let a: __mmask32 = 0b0110100101101001_0110100101101001;
         let r = _kshiftli_mask32::<3>(a);
         let e: __mmask32 = 0b0100101101001011_0100101101001000;
@@ -21241,7 +21235,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kshiftli_mask64() {
+    const fn test_kshiftli_mask64() {
         let a: __mmask64 = 0b0110100101101001_0110100101101001;
         let r = _kshiftli_mask64::<3>(a);
         let e: __mmask64 = 0b0110100101101001011_0100101101001000;
@@ -21261,7 +21255,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kshiftri_mask32() {
+    const fn test_kshiftri_mask32() {
         let a: __mmask32 = 0b1010100101101001_0110100101101001;
         let r = _kshiftri_mask32::<3>(a);
         let e: __mmask32 = 0b0001010100101101_0010110100101101;
@@ -21281,7 +21275,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_kshiftri_mask64() {
+    const fn test_kshiftri_mask64() {
         let a: __mmask64 = 0b1010100101101001011_0100101101001000;
         let r = _kshiftri_mask64::<3>(a);
         let e: __mmask64 = 0b1010100101101001_0110100101101001;
@@ -21315,7 +21309,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_ktestc_mask32_u8() {
+    const fn test_ktestc_mask32_u8() {
         let a: __mmask32 = 0b0110100100111100_0110100100111100;
         let b: __mmask32 = 0b1001011011000011_1001011011000011;
         let r = _ktestc_mask32_u8(a, b);
@@ -21323,7 +21317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_ktestz_mask32_u8() {
+    const fn test_ktestz_mask32_u8() {
         let a: __mmask32 = 0b0110100100111100_0110100100111100;
         let b: __mmask32 = 0b1001011011000011_1001011011000011;
         let r = _ktestz_mask32_u8(a, b);
@@ -21341,7 +21335,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_ktestc_mask64_u8() {
+    const fn test_ktestc_mask64_u8() {
         let a: __mmask64 = 0b0110100100111100_0110100100111100;
         let b: __mmask64 = 0b1001011011000011_1001011011000011;
         let r = _ktestc_mask64_u8(a, b);
@@ -21349,7 +21343,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_ktestz_mask64_u8() {
+    const fn test_ktestz_mask64_u8() {
         let a: __mmask64 = 0b0110100100111100_0110100100111100;
         let b: __mmask64 = 0b1001011011000011_1001011011000011;
         let r = _ktestz_mask64_u8(a, b);
@@ -21357,7 +21351,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_kunpackw() {
+    const fn test_mm512_kunpackw() {
         let a: u32 = 0x00110011;
         let b: u32 = 0x00001011;
         let r = _mm512_kunpackw(a, b);
@@ -21366,7 +21360,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_kunpackd() {
+    const fn test_mm512_kunpackd() {
         let a: u64 = 0x11001100_00110011;
         let b: u64 = 0x00101110_00001011;
         let r = _mm512_kunpackd(a, b);
@@ -21375,7 +21369,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cvtepi16_epi8() {
+    const fn test_mm512_cvtepi16_epi8() {
         let a = _mm512_set1_epi16(2);
         let r = _mm512_cvtepi16_epi8(a);
         let e = _mm256_set1_epi8(2);
@@ -21383,7 +21377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cvtepi16_epi8() {
+    const fn test_mm512_mask_cvtepi16_epi8() {
         let src = _mm256_set1_epi8(1);
         let a = _mm512_set1_epi16(2);
         let r = _mm512_mask_cvtepi16_epi8(src, 0, a);
@@ -21394,7 +21388,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_cvtepi16_epi8() {
+    const fn test_mm512_maskz_cvtepi16_epi8() {
         let a = _mm512_set1_epi16(2);
         let r = _mm512_maskz_cvtepi16_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -21404,7 +21398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_cvtepi16_epi8() {
+    const fn test_mm256_cvtepi16_epi8() {
         let a = _mm256_set1_epi16(2);
         let r = _mm256_cvtepi16_epi8(a);
         let e = _mm_set1_epi8(2);
@@ -21412,7 +21406,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi16_epi8() {
+    const fn test_mm256_mask_cvtepi16_epi8() {
         let src = _mm_set1_epi8(1);
         let a = _mm256_set1_epi16(2);
         let r = _mm256_mask_cvtepi16_epi8(src, 0, a);
@@ -21423,7 +21417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi16_epi8() {
+    const fn test_mm256_maskz_cvtepi16_epi8() {
         let a = _mm256_set1_epi16(2);
         let r = _mm256_maskz_cvtepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21433,7 +21427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_cvtepi16_epi8() {
+    const fn test_mm_cvtepi16_epi8() {
         let a = _mm_set1_epi16(2);
         let r = _mm_cvtepi16_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2);
@@ -21441,7 +21435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi16_epi8() {
+    const fn test_mm_mask_cvtepi16_epi8() {
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
         let a = _mm_set1_epi16(2);
         let r = _mm_mask_cvtepi16_epi8(src, 0, a);
@@ -21452,7 +21446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi16_epi8() {
+    const fn test_mm_maskz_cvtepi16_epi8() {
         let a = _mm_set1_epi16(2);
         let r = _mm_maskz_cvtepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21462,7 +21456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_cvtsepi16_epi8() {
+    fn test_mm512_cvtsepi16_epi8() {
         let a = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_cvtsepi16_epi8(a);
         let e = _mm256_set1_epi8(i8::MAX);
@@ -21470,7 +21464,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_cvtsepi16_epi8() {
+    fn test_mm512_mask_cvtsepi16_epi8() {
         let src = _mm256_set1_epi8(1);
         let a = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_mask_cvtsepi16_epi8(src, 0, a);
@@ -21481,7 +21475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_cvtsepi16_epi8() {
+    fn test_mm256_cvtsepi16_epi8() {
         let a = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_cvtsepi16_epi8(a);
         let e = _mm_set1_epi8(i8::MAX);
@@ -21489,7 +21483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi16_epi8() {
+    fn test_mm256_mask_cvtsepi16_epi8() {
         let src = _mm_set1_epi8(1);
         let a = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_mask_cvtsepi16_epi8(src, 0, a);
@@ -21500,7 +21494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi16_epi8() {
+    fn test_mm256_maskz_cvtsepi16_epi8() {
         let a = _mm256_set1_epi16(i16::MAX);
         let r = _mm256_maskz_cvtsepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21510,7 +21504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_cvtsepi16_epi8() {
+    fn test_mm_cvtsepi16_epi8() {
         let a = _mm_set1_epi16(i16::MAX);
         let r = _mm_cvtsepi16_epi8(a);
         #[rustfmt::skip]
@@ -21519,7 +21513,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi16_epi8() {
+    fn test_mm_mask_cvtsepi16_epi8() {
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
         let a = _mm_set1_epi16(i16::MAX);
         let r = _mm_mask_cvtsepi16_epi8(src, 0, a);
@@ -21531,7 +21525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi16_epi8() {
+    fn test_mm_maskz_cvtsepi16_epi8() {
         let a = _mm_set1_epi16(i16::MAX);
         let r = _mm_maskz_cvtsepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21542,7 +21536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_cvtsepi16_epi8() {
+    fn test_mm512_maskz_cvtsepi16_epi8() {
         let a = _mm512_set1_epi16(i16::MAX);
         let r = _mm512_maskz_cvtsepi16_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -21552,7 +21546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_cvtusepi16_epi8() {
+    fn test_mm512_cvtusepi16_epi8() {
         let a = _mm512_set1_epi16(i16::MIN);
         let r = _mm512_cvtusepi16_epi8(a);
         let e = _mm256_set1_epi8(-1);
@@ -21560,7 +21554,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_mask_cvtusepi16_epi8() {
+    fn test_mm512_mask_cvtusepi16_epi8() {
         let src = _mm256_set1_epi8(1);
         let a = _mm512_set1_epi16(i16::MIN);
         let r = _mm512_mask_cvtusepi16_epi8(src, 0, a);
@@ -21571,7 +21565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    unsafe fn test_mm512_maskz_cvtusepi16_epi8() {
+    fn test_mm512_maskz_cvtusepi16_epi8() {
         let a = _mm512_set1_epi16(i16::MIN);
         let r = _mm512_maskz_cvtusepi16_epi8(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -21581,7 +21575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_cvtusepi16_epi8() {
+    fn test_mm256_cvtusepi16_epi8() {
         let a = _mm256_set1_epi16(i16::MIN);
         let r = _mm256_cvtusepi16_epi8(a);
         let e = _mm_set1_epi8(-1);
@@ -21589,7 +21583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi16_epi8() {
+    fn test_mm256_mask_cvtusepi16_epi8() {
         let src = _mm_set1_epi8(1);
         let a = _mm256_set1_epi16(i16::MIN);
         let r = _mm256_mask_cvtusepi16_epi8(src, 0, a);
@@ -21600,7 +21594,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi16_epi8() {
+    fn test_mm256_maskz_cvtusepi16_epi8() {
         let a = _mm256_set1_epi16(i16::MIN);
         let r = _mm256_maskz_cvtusepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21610,7 +21604,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_cvtusepi16_epi8() {
+    fn test_mm_cvtusepi16_epi8() {
         let a = _mm_set1_epi16(i16::MIN);
         let r = _mm_cvtusepi16_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
@@ -21618,7 +21612,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi16_epi8() {
+    fn test_mm_mask_cvtusepi16_epi8() {
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
         let a = _mm_set1_epi16(i16::MIN);
         let r = _mm_mask_cvtusepi16_epi8(src, 0, a);
@@ -21629,7 +21623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi16_epi8() {
+    fn test_mm_maskz_cvtusepi16_epi8() {
         let a = _mm_set1_epi16(i16::MIN);
         let r = _mm_maskz_cvtusepi16_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21639,7 +21633,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cvtepi8_epi16() {
+    const fn test_mm512_cvtepi8_epi16() {
         let a = _mm256_set1_epi8(2);
         let r = _mm512_cvtepi8_epi16(a);
         let e = _mm512_set1_epi16(2);
@@ -21647,7 +21641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cvtepi8_epi16() {
+    const fn test_mm512_mask_cvtepi8_epi16() {
         let src = _mm512_set1_epi16(1);
         let a = _mm256_set1_epi8(2);
         let r = _mm512_mask_cvtepi8_epi16(src, 0, a);
@@ -21658,7 +21652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_cvtepi8_epi16() {
+    const fn test_mm512_maskz_cvtepi8_epi16() {
         let a = _mm256_set1_epi8(2);
         let r = _mm512_maskz_cvtepi8_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -21668,7 +21662,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi8_epi16() {
+    const fn test_mm256_mask_cvtepi8_epi16() {
         let src = _mm256_set1_epi16(1);
         let a = _mm_set1_epi8(2);
         let r = _mm256_mask_cvtepi8_epi16(src, 0, a);
@@ -21679,7 +21673,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi8_epi16() {
+    const fn test_mm256_maskz_cvtepi8_epi16() {
         let a = _mm_set1_epi8(2);
         let r = _mm256_maskz_cvtepi8_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -21689,7 +21683,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi8_epi16() {
+    const fn test_mm_mask_cvtepi8_epi16() {
         let src = _mm_set1_epi16(1);
         let a = _mm_set1_epi8(2);
         let r = _mm_mask_cvtepi8_epi16(src, 0, a);
@@ -21700,7 +21694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi8_epi16() {
+    const fn test_mm_maskz_cvtepi8_epi16() {
         let a = _mm_set1_epi8(2);
         let r = _mm_maskz_cvtepi8_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21710,7 +21704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_cvtepu8_epi16() {
+    const fn test_mm512_cvtepu8_epi16() {
         let a = _mm256_set1_epi8(2);
         let r = _mm512_cvtepu8_epi16(a);
         let e = _mm512_set1_epi16(2);
@@ -21718,7 +21712,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_cvtepu8_epi16() {
+    const fn test_mm512_mask_cvtepu8_epi16() {
         let src = _mm512_set1_epi16(1);
         let a = _mm256_set1_epi8(2);
         let r = _mm512_mask_cvtepu8_epi16(src, 0, a);
@@ -21729,7 +21723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_cvtepu8_epi16() {
+    const fn test_mm512_maskz_cvtepu8_epi16() {
         let a = _mm256_set1_epi8(2);
         let r = _mm512_maskz_cvtepu8_epi16(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -21739,7 +21733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu8_epi16() {
+    const fn test_mm256_mask_cvtepu8_epi16() {
         let src = _mm256_set1_epi16(1);
         let a = _mm_set1_epi8(2);
         let r = _mm256_mask_cvtepu8_epi16(src, 0, a);
@@ -21750,7 +21744,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu8_epi16() {
+    const fn test_mm256_maskz_cvtepu8_epi16() {
         let a = _mm_set1_epi8(2);
         let r = _mm256_maskz_cvtepu8_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -21760,7 +21754,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu8_epi16() {
+    const fn test_mm_mask_cvtepu8_epi16() {
         let src = _mm_set1_epi16(1);
         let a = _mm_set1_epi8(2);
         let r = _mm_mask_cvtepu8_epi16(src, 0, a);
@@ -21771,7 +21765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu8_epi16() {
+    const fn test_mm_maskz_cvtepu8_epi16() {
         let a = _mm_set1_epi8(2);
         let r = _mm_maskz_cvtepu8_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -21781,7 +21775,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_bslli_epi128() {
+    const fn test_mm512_bslli_epi128() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21801,7 +21795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_bsrli_epi128() {
+    const fn test_mm512_bsrli_epi128() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
@@ -21821,7 +21815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_alignr_epi8() {
+    const fn test_mm512_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21842,7 +21836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_mask_alignr_epi8() {
+    const fn test_mm512_mask_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21870,7 +21864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_mm512_maskz_alignr_epi8() {
+    const fn test_mm512_maskz_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21897,7 +21891,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_mask_alignr_epi8() {
+    const fn test_mm256_mask_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21916,7 +21910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm256_maskz_alignr_epi8() {
+    const fn test_mm256_maskz_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(
             1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
@@ -21935,7 +21929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_mask_alignr_epi8() {
+    const fn test_mm_mask_alignr_epi8() {
         let a = _mm_set_epi8(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
         let b = _mm_set1_epi8(1);
         let r = _mm_mask_alignr_epi8::<14>(a, 0, a, b);
@@ -21946,7 +21940,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw,avx512vl")]
-    const unsafe fn test_mm_maskz_alignr_epi8() {
+    const fn test_mm_maskz_alignr_epi8() {
         let a = _mm_set_epi8(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
         let b = _mm_set1_epi8(1);
         let r = _mm_maskz_alignr_epi8::<14>(0, a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512cd.rs b/library/stdarch/crates/core_arch/src/x86/avx512cd.rs
index b163698b56c4..4082433e7075 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512cd.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512cd.rs
@@ -587,7 +587,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_broadcastmw_epi32() {
+    const fn test_mm512_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm512_broadcastmw_epi32(a);
         let e = _mm512_set1_epi32(2);
@@ -595,7 +595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_broadcastmw_epi32() {
+    const fn test_mm256_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm256_broadcastmw_epi32(a);
         let e = _mm256_set1_epi32(2);
@@ -603,7 +603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_broadcastmw_epi32() {
+    const fn test_mm_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm_broadcastmw_epi32(a);
         let e = _mm_set1_epi32(2);
@@ -611,7 +611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_broadcastmb_epi64() {
+    const fn test_mm512_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm512_broadcastmb_epi64(a);
         let e = _mm512_set1_epi64(2);
@@ -619,7 +619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_broadcastmb_epi64() {
+    const fn test_mm256_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm256_broadcastmb_epi64(a);
         let e = _mm256_set1_epi64x(2);
@@ -627,7 +627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_broadcastmb_epi64() {
+    const fn test_mm_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm_broadcastmb_epi64(a);
         let e = _mm_set1_epi64x(2);
@@ -635,7 +635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_conflict_epi32() {
+    fn test_mm512_conflict_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_conflict_epi32(a);
         let e = _mm512_set_epi32(
@@ -720,7 +720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_mask_conflict_epi32() {
+    fn test_mm512_mask_conflict_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_mask_conflict_epi32(a, 0, a);
         assert_eq_m512i(r, a);
@@ -807,7 +807,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_maskz_conflict_epi32() {
+    fn test_mm512_maskz_conflict_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_maskz_conflict_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -894,7 +894,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_conflict_epi32() {
+    fn test_mm256_conflict_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_conflict_epi32(a);
         let e = _mm256_set_epi32(
@@ -911,7 +911,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_mask_conflict_epi32() {
+    fn test_mm256_mask_conflict_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_mask_conflict_epi32(a, 0, a);
         assert_eq_m256i(r, a);
@@ -930,7 +930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_maskz_conflict_epi32() {
+    fn test_mm256_maskz_conflict_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_maskz_conflict_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -949,7 +949,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_conflict_epi32() {
+    fn test_mm_conflict_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_conflict_epi32(a);
         let e = _mm_set_epi32(1 << 2 | 1 << 1 | 1 << 0, 1 << 1 | 1 << 0, 1 << 0, 0);
@@ -957,7 +957,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_mask_conflict_epi32() {
+    fn test_mm_mask_conflict_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_mask_conflict_epi32(a, 0, a);
         assert_eq_m128i(r, a);
@@ -967,7 +967,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_maskz_conflict_epi32() {
+    fn test_mm_maskz_conflict_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_maskz_conflict_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -977,7 +977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_conflict_epi64() {
+    fn test_mm512_conflict_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_conflict_epi64(a);
         let e = _mm512_set_epi64(
@@ -994,7 +994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_mask_conflict_epi64() {
+    fn test_mm512_mask_conflict_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_mask_conflict_epi64(a, 0, a);
         assert_eq_m512i(r, a);
@@ -1013,7 +1013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_maskz_conflict_epi64() {
+    fn test_mm512_maskz_conflict_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_maskz_conflict_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -1032,7 +1032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_conflict_epi64() {
+    fn test_mm256_conflict_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_conflict_epi64(a);
         let e = _mm256_set_epi64x(1 << 2 | 1 << 1 | 1 << 0, 1 << 1 | 1 << 0, 1 << 0, 0);
@@ -1040,7 +1040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_mask_conflict_epi64() {
+    fn test_mm256_mask_conflict_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_mask_conflict_epi64(a, 0, a);
         assert_eq_m256i(r, a);
@@ -1050,7 +1050,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_maskz_conflict_epi64() {
+    fn test_mm256_maskz_conflict_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_conflict_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -1060,7 +1060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_conflict_epi64() {
+    fn test_mm_conflict_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_conflict_epi64(a);
         let e = _mm_set_epi64x(1 << 0, 0);
@@ -1068,7 +1068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_mask_conflict_epi64() {
+    fn test_mm_mask_conflict_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_mask_conflict_epi64(a, 0, a);
         assert_eq_m128i(r, a);
@@ -1078,7 +1078,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_maskz_conflict_epi64() {
+    fn test_mm_maskz_conflict_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_maskz_conflict_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -1088,7 +1088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_lzcnt_epi32() {
+    const fn test_mm512_lzcnt_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_lzcnt_epi32(a);
         let e = _mm512_set1_epi32(31);
@@ -1096,7 +1096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_mask_lzcnt_epi32() {
+    const fn test_mm512_mask_lzcnt_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m512i(r, a);
@@ -1106,7 +1106,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_maskz_lzcnt_epi32() {
+    const fn test_mm512_maskz_lzcnt_epi32() {
         let a = _mm512_set1_epi32(2);
         let r = _mm512_maskz_lzcnt_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -1116,7 +1116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_lzcnt_epi32() {
+    const fn test_mm256_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_lzcnt_epi32(a);
         let e = _mm256_set1_epi32(31);
@@ -1124,7 +1124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_mask_lzcnt_epi32() {
+    const fn test_mm256_mask_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m256i(r, a);
@@ -1134,7 +1134,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_maskz_lzcnt_epi32() {
+    const fn test_mm256_maskz_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_maskz_lzcnt_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -1144,7 +1144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_lzcnt_epi32() {
+    const fn test_mm_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_lzcnt_epi32(a);
         let e = _mm_set1_epi32(31);
@@ -1152,7 +1152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_mask_lzcnt_epi32() {
+    const fn test_mm_mask_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m128i(r, a);
@@ -1162,7 +1162,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_maskz_lzcnt_epi32() {
+    const fn test_mm_maskz_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_maskz_lzcnt_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -1172,7 +1172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_lzcnt_epi64() {
+    const fn test_mm512_lzcnt_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_lzcnt_epi64(a);
         let e = _mm512_set1_epi64(63);
@@ -1180,7 +1180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_mask_lzcnt_epi64() {
+    const fn test_mm512_mask_lzcnt_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m512i(r, a);
@@ -1190,7 +1190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    const unsafe fn test_mm512_maskz_lzcnt_epi64() {
+    const fn test_mm512_maskz_lzcnt_epi64() {
         let a = _mm512_set1_epi64(2);
         let r = _mm512_maskz_lzcnt_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -1200,7 +1200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_lzcnt_epi64() {
+    const fn test_mm256_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_lzcnt_epi64(a);
         let e = _mm256_set1_epi64x(63);
@@ -1208,7 +1208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_mask_lzcnt_epi64() {
+    const fn test_mm256_mask_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m256i(r, a);
@@ -1218,7 +1218,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm256_maskz_lzcnt_epi64() {
+    const fn test_mm256_maskz_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_lzcnt_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -1228,7 +1228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_lzcnt_epi64() {
+    const fn test_mm_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_lzcnt_epi64(a);
         let e = _mm_set1_epi64x(63);
@@ -1236,7 +1236,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_mask_lzcnt_epi64() {
+    const fn test_mm_mask_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m128i(r, a);
@@ -1246,7 +1246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    const unsafe fn test_mm_maskz_lzcnt_epi64() {
+    const fn test_mm_maskz_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_maskz_lzcnt_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512dq.rs b/library/stdarch/crates/core_arch/src/x86/avx512dq.rs
index 4ab5880c55d0..ebe75cd22d8e 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512dq.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512dq.rs
@@ -7424,7 +7424,7 @@ mod tests {
     const XOR_32: f32 = unsafe { transmute(0x66666666_u32) };
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_and_pd() {
+    const fn test_mm_mask_and_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let src = _mm_set_pd(1., 2.);
@@ -7434,7 +7434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_and_pd() {
+    const fn test_mm_maskz_and_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let r = _mm_maskz_and_pd(0b01, a, b);
@@ -7443,7 +7443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_and_pd() {
+    const fn test_mm256_mask_and_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let src = _mm256_set_pd(1., 2., 3., 4.);
@@ -7453,7 +7453,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_and_pd() {
+    const fn test_mm256_maskz_and_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let r = _mm256_maskz_and_pd(0b0101, a, b);
@@ -7462,7 +7462,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_and_pd() {
+    const fn test_mm512_and_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_and_pd(a, b);
@@ -7471,7 +7471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_and_pd() {
+    const fn test_mm512_mask_and_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let src = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7481,7 +7481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_and_pd() {
+    const fn test_mm512_maskz_and_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_maskz_and_pd(0b01010101, a, b);
@@ -7490,7 +7490,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_and_ps() {
+    const fn test_mm_mask_and_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let src = _mm_set_ps(1., 2., 3., 4.);
@@ -7500,7 +7500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_and_ps() {
+    const fn test_mm_maskz_and_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let r = _mm_maskz_and_ps(0b0101, a, b);
@@ -7509,7 +7509,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_and_ps() {
+    const fn test_mm256_mask_and_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let src = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7519,7 +7519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_and_ps() {
+    const fn test_mm256_maskz_and_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let r = _mm256_maskz_and_ps(0b01010101, a, b);
@@ -7528,7 +7528,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_and_ps() {
+    const fn test_mm512_and_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_and_ps(a, b);
@@ -7537,7 +7537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_and_ps() {
+    const fn test_mm512_mask_and_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let src = _mm512_set_ps(
@@ -7552,7 +7552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_and_ps() {
+    const fn test_mm512_maskz_and_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_maskz_and_ps(0b0101010101010101, a, b);
@@ -7564,7 +7564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_andnot_pd() {
+    const fn test_mm_mask_andnot_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let src = _mm_set_pd(1., 2.);
@@ -7574,7 +7574,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_andnot_pd() {
+    const fn test_mm_maskz_andnot_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let r = _mm_maskz_andnot_pd(0b01, a, b);
@@ -7583,7 +7583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_andnot_pd() {
+    const fn test_mm256_mask_andnot_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let src = _mm256_set_pd(1., 2., 3., 4.);
@@ -7593,7 +7593,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_andnot_pd() {
+    const fn test_mm256_maskz_andnot_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let r = _mm256_maskz_andnot_pd(0b0101, a, b);
@@ -7602,7 +7602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_andnot_pd() {
+    const fn test_mm512_andnot_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_andnot_pd(a, b);
@@ -7611,7 +7611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_andnot_pd() {
+    const fn test_mm512_mask_andnot_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let src = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7621,7 +7621,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_andnot_pd() {
+    const fn test_mm512_maskz_andnot_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_maskz_andnot_pd(0b01010101, a, b);
@@ -7630,7 +7630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_andnot_ps() {
+    const fn test_mm_mask_andnot_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let src = _mm_set_ps(1., 2., 3., 4.);
@@ -7640,7 +7640,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_andnot_ps() {
+    const fn test_mm_maskz_andnot_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let r = _mm_maskz_andnot_ps(0b0101, a, b);
@@ -7649,7 +7649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_andnot_ps() {
+    const fn test_mm256_mask_andnot_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let src = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7659,7 +7659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_andnot_ps() {
+    const fn test_mm256_maskz_andnot_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let r = _mm256_maskz_andnot_ps(0b01010101, a, b);
@@ -7668,7 +7668,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_andnot_ps() {
+    const fn test_mm512_andnot_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_andnot_ps(a, b);
@@ -7677,7 +7677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_andnot_ps() {
+    const fn test_mm512_mask_andnot_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let src = _mm512_set_ps(
@@ -7692,7 +7692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_andnot_ps() {
+    const fn test_mm512_maskz_andnot_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_maskz_andnot_ps(0b0101010101010101, a, b);
@@ -7704,7 +7704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_or_pd() {
+    const fn test_mm_mask_or_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let src = _mm_set_pd(1., 2.);
@@ -7714,7 +7714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_or_pd() {
+    const fn test_mm_maskz_or_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let r = _mm_maskz_or_pd(0b01, a, b);
@@ -7723,7 +7723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_or_pd() {
+    const fn test_mm256_mask_or_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let src = _mm256_set_pd(1., 2., 3., 4.);
@@ -7733,7 +7733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_or_pd() {
+    const fn test_mm256_maskz_or_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let r = _mm256_maskz_or_pd(0b0101, a, b);
@@ -7742,7 +7742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_or_pd() {
+    const fn test_mm512_or_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_or_pd(a, b);
@@ -7751,7 +7751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_or_pd() {
+    const fn test_mm512_mask_or_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let src = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7761,7 +7761,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_or_pd() {
+    const fn test_mm512_maskz_or_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_maskz_or_pd(0b01010101, a, b);
@@ -7770,7 +7770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_or_ps() {
+    const fn test_mm_mask_or_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let src = _mm_set_ps(1., 2., 3., 4.);
@@ -7780,7 +7780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_or_ps() {
+    const fn test_mm_maskz_or_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let r = _mm_maskz_or_ps(0b0101, a, b);
@@ -7789,7 +7789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_or_ps() {
+    const fn test_mm256_mask_or_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let src = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7799,7 +7799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_or_ps() {
+    const fn test_mm256_maskz_or_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let r = _mm256_maskz_or_ps(0b01010101, a, b);
@@ -7808,7 +7808,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_or_ps() {
+    const fn test_mm512_or_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_or_ps(a, b);
@@ -7817,7 +7817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_or_ps() {
+    const fn test_mm512_mask_or_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let src = _mm512_set_ps(
@@ -7832,7 +7832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_or_ps() {
+    const fn test_mm512_maskz_or_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_maskz_or_ps(0b0101010101010101, a, b);
@@ -7843,7 +7843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_xor_pd() {
+    const fn test_mm_mask_xor_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let src = _mm_set_pd(1., 2.);
@@ -7853,7 +7853,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_xor_pd() {
+    const fn test_mm_maskz_xor_pd() {
         let a = _mm_set1_pd(OPRND1_64);
         let b = _mm_set1_pd(OPRND2_64);
         let r = _mm_maskz_xor_pd(0b01, a, b);
@@ -7862,7 +7862,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_xor_pd() {
+    const fn test_mm256_mask_xor_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let src = _mm256_set_pd(1., 2., 3., 4.);
@@ -7872,7 +7872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_xor_pd() {
+    const fn test_mm256_maskz_xor_pd() {
         let a = _mm256_set1_pd(OPRND1_64);
         let b = _mm256_set1_pd(OPRND2_64);
         let r = _mm256_maskz_xor_pd(0b0101, a, b);
@@ -7881,7 +7881,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_xor_pd() {
+    const fn test_mm512_xor_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_xor_pd(a, b);
@@ -7890,7 +7890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_xor_pd() {
+    const fn test_mm512_mask_xor_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let src = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7900,7 +7900,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_xor_pd() {
+    const fn test_mm512_maskz_xor_pd() {
         let a = _mm512_set1_pd(OPRND1_64);
         let b = _mm512_set1_pd(OPRND2_64);
         let r = _mm512_maskz_xor_pd(0b01010101, a, b);
@@ -7909,7 +7909,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_xor_ps() {
+    const fn test_mm_mask_xor_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let src = _mm_set_ps(1., 2., 3., 4.);
@@ -7919,7 +7919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_xor_ps() {
+    const fn test_mm_maskz_xor_ps() {
         let a = _mm_set1_ps(OPRND1_32);
         let b = _mm_set1_ps(OPRND2_32);
         let r = _mm_maskz_xor_ps(0b0101, a, b);
@@ -7928,7 +7928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_xor_ps() {
+    const fn test_mm256_mask_xor_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let src = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -7938,7 +7938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_xor_ps() {
+    const fn test_mm256_maskz_xor_ps() {
         let a = _mm256_set1_ps(OPRND1_32);
         let b = _mm256_set1_ps(OPRND2_32);
         let r = _mm256_maskz_xor_ps(0b01010101, a, b);
@@ -7947,7 +7947,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_xor_ps() {
+    const fn test_mm512_xor_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_xor_ps(a, b);
@@ -7956,7 +7956,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_xor_ps() {
+    const fn test_mm512_mask_xor_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let src = _mm512_set_ps(
@@ -7971,7 +7971,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_xor_ps() {
+    const fn test_mm512_maskz_xor_ps() {
         let a = _mm512_set1_ps(OPRND1_32);
         let b = _mm512_set1_ps(OPRND2_32);
         let r = _mm512_maskz_xor_ps(0b0101010101010101, a, b);
@@ -7983,7 +7983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_broadcast_f32x2() {
+    const fn test_mm256_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_broadcast_f32x2(a);
         let e = _mm256_set_ps(3., 4., 3., 4., 3., 4., 3., 4.);
@@ -7991,7 +7991,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_f32x2() {
+    const fn test_mm256_mask_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm256_set_ps(5., 6., 7., 8., 9., 10., 11., 12.);
         let r = _mm256_mask_broadcast_f32x2(b, 0b01101001, a);
@@ -8000,7 +8000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_f32x2() {
+    const fn test_mm256_maskz_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_maskz_broadcast_f32x2(0b01101001, a);
         let e = _mm256_set_ps(0., 4., 3., 0., 3., 0., 0., 4.);
@@ -8008,7 +8008,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_f32x2() {
+    const fn test_mm512_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm512_broadcast_f32x2(a);
         let e = _mm512_set_ps(
@@ -8018,7 +8018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_f32x2() {
+    const fn test_mm512_mask_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm512_set_ps(
             5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20.,
@@ -8031,7 +8031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_f32x2() {
+    const fn test_mm512_maskz_broadcast_f32x2() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm512_maskz_broadcast_f32x2(0b0110100100111100, a);
         let e = _mm512_set_ps(
@@ -8041,7 +8041,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_f32x8() {
+    const fn test_mm512_broadcast_f32x8() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_broadcast_f32x8(a);
         let e = _mm512_set_ps(
@@ -8051,7 +8051,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_f32x8() {
+    const fn test_mm512_mask_broadcast_f32x8() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_ps(
             9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
@@ -8064,7 +8064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_f32x8() {
+    const fn test_mm512_maskz_broadcast_f32x8() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_broadcast_f32x8(0b0110100100111100, a);
         let e = _mm512_set_ps(
@@ -8074,7 +8074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_broadcast_f64x2() {
+    const fn test_mm256_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm256_broadcast_f64x2(a);
         let e = _mm256_set_pd(1., 2., 1., 2.);
@@ -8082,7 +8082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_f64x2() {
+    const fn test_mm256_mask_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm256_set_pd(3., 4., 5., 6.);
         let r = _mm256_mask_broadcast_f64x2(b, 0b0110, a);
@@ -8091,7 +8091,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_f64x2() {
+    const fn test_mm256_maskz_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm256_maskz_broadcast_f64x2(0b0110, a);
         let e = _mm256_set_pd(0., 2., 1., 0.);
@@ -8099,7 +8099,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_f64x2() {
+    const fn test_mm512_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm512_broadcast_f64x2(a);
         let e = _mm512_set_pd(1., 2., 1., 2., 1., 2., 1., 2.);
@@ -8107,7 +8107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_f64x2() {
+    const fn test_mm512_mask_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm512_set_pd(3., 4., 5., 6., 7., 8., 9., 10.);
         let r = _mm512_mask_broadcast_f64x2(b, 0b01101001, a);
@@ -8116,7 +8116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_f64x2() {
+    const fn test_mm512_maskz_broadcast_f64x2() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm512_maskz_broadcast_f64x2(0b01101001, a);
         let e = _mm512_set_pd(0., 2., 1., 0., 1., 0., 0., 2.);
@@ -8124,7 +8124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_broadcast_i32x2() {
+    const fn test_mm_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_broadcast_i32x2(a);
         let e = _mm_set_epi32(3, 4, 3, 4);
@@ -8132,7 +8132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_broadcast_i32x2() {
+    const fn test_mm_mask_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm_set_epi32(5, 6, 7, 8);
         let r = _mm_mask_broadcast_i32x2(b, 0b0110, a);
@@ -8141,7 +8141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcast_i32x2() {
+    const fn test_mm_maskz_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_broadcast_i32x2(0b0110, a);
         let e = _mm_set_epi32(0, 4, 3, 0);
@@ -8149,7 +8149,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_broadcast_i32x2() {
+    const fn test_mm256_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm256_broadcast_i32x2(a);
         let e = _mm256_set_epi32(3, 4, 3, 4, 3, 4, 3, 4);
@@ -8157,7 +8157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_i32x2() {
+    const fn test_mm256_mask_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm256_set_epi32(5, 6, 7, 8, 9, 10, 11, 12);
         let r = _mm256_mask_broadcast_i32x2(b, 0b01101001, a);
@@ -8166,7 +8166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_i32x2() {
+    const fn test_mm256_maskz_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm256_maskz_broadcast_i32x2(0b01101001, a);
         let e = _mm256_set_epi32(0, 4, 3, 0, 3, 0, 0, 4);
@@ -8174,7 +8174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_i32x2() {
+    const fn test_mm512_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm512_broadcast_i32x2(a);
         let e = _mm512_set_epi32(3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4);
@@ -8182,7 +8182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_i32x2() {
+    const fn test_mm512_mask_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm512_set_epi32(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
         let r = _mm512_mask_broadcast_i32x2(b, 0b0110100100111100, a);
@@ -8191,7 +8191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_i32x2() {
+    const fn test_mm512_maskz_broadcast_i32x2() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm512_maskz_broadcast_i32x2(0b0110100100111100, a);
         let e = _mm512_set_epi32(0, 4, 3, 0, 3, 0, 0, 4, 0, 0, 3, 4, 3, 4, 0, 0);
@@ -8199,7 +8199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_i32x8() {
+    const fn test_mm512_broadcast_i32x8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_broadcast_i32x8(a);
         let e = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
@@ -8207,7 +8207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_i32x8() {
+    const fn test_mm512_mask_broadcast_i32x8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi32(
             9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
@@ -8218,7 +8218,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_i32x8() {
+    const fn test_mm512_maskz_broadcast_i32x8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_broadcast_i32x8(0b0110100100111100, a);
         let e = _mm512_set_epi32(0, 2, 3, 0, 5, 0, 0, 8, 0, 0, 3, 4, 5, 6, 0, 0);
@@ -8226,7 +8226,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_broadcast_i64x2() {
+    const fn test_mm256_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm256_broadcast_i64x2(a);
         let e = _mm256_set_epi64x(1, 2, 1, 2);
@@ -8234,7 +8234,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_i64x2() {
+    const fn test_mm256_mask_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm256_set_epi64x(3, 4, 5, 6);
         let r = _mm256_mask_broadcast_i64x2(b, 0b0110, a);
@@ -8243,7 +8243,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_i64x2() {
+    const fn test_mm256_maskz_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm256_maskz_broadcast_i64x2(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 1, 0);
@@ -8251,7 +8251,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_broadcast_i64x2() {
+    const fn test_mm512_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm512_broadcast_i64x2(a);
         let e = _mm512_set_epi64(1, 2, 1, 2, 1, 2, 1, 2);
@@ -8259,7 +8259,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_broadcast_i64x2() {
+    const fn test_mm512_mask_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm512_set_epi64(3, 4, 5, 6, 7, 8, 9, 10);
         let r = _mm512_mask_broadcast_i64x2(b, 0b01101001, a);
@@ -8268,7 +8268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_broadcast_i64x2() {
+    const fn test_mm512_maskz_broadcast_i64x2() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm512_maskz_broadcast_i64x2(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 1, 0, 1, 0, 0, 2);
@@ -8276,7 +8276,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_extractf32x8_ps() {
+    const fn test_mm512_extractf32x8_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8286,7 +8286,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_extractf32x8_ps() {
+    const fn test_mm512_mask_extractf32x8_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8297,7 +8297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_extractf32x8_ps() {
+    const fn test_mm512_maskz_extractf32x8_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8307,7 +8307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_extractf64x2_pd() {
+    const fn test_mm256_extractf64x2_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_extractf64x2_pd::<1>(a);
         let e = _mm_set_pd(1., 2.);
@@ -8315,7 +8315,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_extractf64x2_pd() {
+    const fn test_mm256_mask_extractf64x2_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm_set_pd(5., 6.);
         let r = _mm256_mask_extractf64x2_pd::<1>(b, 0b01, a);
@@ -8324,7 +8324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_extractf64x2_pd() {
+    const fn test_mm256_maskz_extractf64x2_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_extractf64x2_pd::<1>(0b01, a);
         let e = _mm_set_pd(0., 2.);
@@ -8332,7 +8332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_extractf64x2_pd() {
+    const fn test_mm512_extractf64x2_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_extractf64x2_pd::<2>(a);
         let e = _mm_set_pd(3., 4.);
@@ -8340,7 +8340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_extractf64x2_pd() {
+    const fn test_mm512_mask_extractf64x2_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_pd(9., 10.);
         let r = _mm512_mask_extractf64x2_pd::<2>(b, 0b01, a);
@@ -8349,7 +8349,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_extractf64x2_pd() {
+    const fn test_mm512_maskz_extractf64x2_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_extractf64x2_pd::<2>(0b01, a);
         let e = _mm_set_pd(0., 4.);
@@ -8357,7 +8357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_extracti32x8_epi32() {
+    const fn test_mm512_extracti32x8_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_extracti32x8_epi32::<1>(a);
         let e = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
@@ -8365,7 +8365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_extracti32x8_epi32() {
+    const fn test_mm512_mask_extracti32x8_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_mask_extracti32x8_epi32::<1>(b, 0b01101001, a);
@@ -8374,7 +8374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_extracti32x8_epi32() {
+    const fn test_mm512_maskz_extracti32x8_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_extracti32x8_epi32::<1>(0b01101001, a);
         let e = _mm256_set_epi32(0, 2, 3, 0, 5, 0, 0, 8);
@@ -8382,7 +8382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_extracti64x2_epi64() {
+    const fn test_mm256_extracti64x2_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_extracti64x2_epi64::<1>(a);
         let e = _mm_set_epi64x(1, 2);
@@ -8390,7 +8390,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_extracti64x2_epi64() {
+    const fn test_mm256_mask_extracti64x2_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm256_mask_extracti64x2_epi64::<1>(b, 0b01, a);
@@ -8399,7 +8399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_extracti64x2_epi64() {
+    const fn test_mm256_maskz_extracti64x2_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_extracti64x2_epi64::<1>(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -8407,7 +8407,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_extracti64x2_epi64() {
+    const fn test_mm512_extracti64x2_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_extracti64x2_epi64::<2>(a);
         let e = _mm_set_epi64x(3, 4);
@@ -8415,7 +8415,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_extracti64x2_epi64() {
+    const fn test_mm512_mask_extracti64x2_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi64x(9, 10);
         let r = _mm512_mask_extracti64x2_epi64::<2>(b, 0b01, a);
@@ -8424,7 +8424,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_extracti64x2_epi64() {
+    const fn test_mm512_maskz_extracti64x2_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_extracti64x2_epi64::<2>(0b01, a);
         let e = _mm_set_epi64x(0, 4);
@@ -8432,7 +8432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_insertf32x8() {
+    const fn test_mm512_insertf32x8() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8445,7 +8445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_insertf32x8() {
+    const fn test_mm512_mask_insertf32x8() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8461,7 +8461,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_insertf32x8() {
+    const fn test_mm512_maskz_insertf32x8() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -8474,7 +8474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_insertf64x2() {
+    const fn test_mm256_insertf64x2() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm_set_pd(5., 6.);
         let r = _mm256_insertf64x2::<1>(a, b);
@@ -8483,7 +8483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_insertf64x2() {
+    const fn test_mm256_mask_insertf64x2() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm_set_pd(5., 6.);
         let src = _mm256_set_pd(7., 8., 9., 10.);
@@ -8493,7 +8493,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_insertf64x2() {
+    const fn test_mm256_maskz_insertf64x2() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm_set_pd(5., 6.);
         let r = _mm256_maskz_insertf64x2::<1>(0b0110, a, b);
@@ -8502,7 +8502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_insertf64x2() {
+    const fn test_mm512_insertf64x2() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_pd(9., 10.);
         let r = _mm512_insertf64x2::<2>(a, b);
@@ -8511,7 +8511,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_insertf64x2() {
+    const fn test_mm512_mask_insertf64x2() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_pd(9., 10.);
         let src = _mm512_set_pd(11., 12., 13., 14., 15., 16., 17., 18.);
@@ -8521,7 +8521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_insertf64x2() {
+    const fn test_mm512_maskz_insertf64x2() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_pd(9., 10.);
         let r = _mm512_maskz_insertf64x2::<2>(0b01101001, a, b);
@@ -8530,7 +8530,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_inserti32x8() {
+    const fn test_mm512_inserti32x8() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_inserti32x8::<1>(a, b);
@@ -8541,7 +8541,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_inserti32x8() {
+    const fn test_mm512_mask_inserti32x8() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let src = _mm512_set_epi32(
@@ -8555,7 +8555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_inserti32x8() {
+    const fn test_mm512_maskz_inserti32x8() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_maskz_inserti32x8::<1>(0b0110100100111100, a, b);
@@ -8564,7 +8564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_inserti64x2() {
+    const fn test_mm256_inserti64x2() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm256_inserti64x2::<1>(a, b);
@@ -8573,7 +8573,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_inserti64x2() {
+    const fn test_mm256_mask_inserti64x2() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_epi64x(5, 6);
         let src = _mm256_set_epi64x(7, 8, 9, 10);
@@ -8583,7 +8583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_inserti64x2() {
+    const fn test_mm256_maskz_inserti64x2() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm256_maskz_inserti64x2::<1>(0b0110, a, b);
@@ -8592,7 +8592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_inserti64x2() {
+    const fn test_mm512_inserti64x2() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi64x(9, 10);
         let r = _mm512_inserti64x2::<2>(a, b);
@@ -8601,7 +8601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_inserti64x2() {
+    const fn test_mm512_mask_inserti64x2() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi64x(9, 10);
         let src = _mm512_set_epi64(11, 12, 13, 14, 15, 16, 17, 18);
@@ -8611,7 +8611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_inserti64x2() {
+    const fn test_mm512_maskz_inserti64x2() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi64x(9, 10);
         let r = _mm512_maskz_inserti64x2::<2>(0b01101001, a, b);
@@ -8620,7 +8620,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundepi64_pd() {
+    fn test_mm512_cvt_roundepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepi64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8628,7 +8628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundepi64_pd() {
+    fn test_mm512_mask_cvt_roundepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvt_roundepi64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -8639,7 +8639,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundepi64_pd() {
+    fn test_mm512_maskz_cvt_roundepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepi64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -8649,7 +8649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtepi64_pd() {
+    fn test_mm_cvtepi64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepi64_pd(a);
         let e = _mm_set_pd(1., 2.);
@@ -8657,7 +8657,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_pd() {
+    fn test_mm_mask_cvtepi64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_mask_cvtepi64_pd(b, 0b01, a);
@@ -8666,7 +8666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_pd() {
+    fn test_mm_maskz_cvtepi64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepi64_pd(0b01, a);
         let e = _mm_set_pd(0., 2.);
@@ -8674,7 +8674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtepi64_pd() {
+    fn test_mm256_cvtepi64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepi64_pd(a);
         let e = _mm256_set_pd(1., 2., 3., 4.);
@@ -8682,7 +8682,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi64_pd() {
+    fn test_mm256_mask_cvtepi64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_pd(5., 6., 7., 8.);
         let r = _mm256_mask_cvtepi64_pd(b, 0b0110, a);
@@ -8691,7 +8691,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi64_pd() {
+    fn test_mm256_maskz_cvtepi64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepi64_pd(0b0110, a);
         let e = _mm256_set_pd(0., 2., 3., 0.);
@@ -8699,7 +8699,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtepi64_pd() {
+    fn test_mm512_cvtepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepi64_pd(a);
         let e = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8707,7 +8707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtepi64_pd() {
+    fn test_mm512_mask_cvtepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvtepi64_pd(b, 0b01101001, a);
@@ -8716,7 +8716,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtepi64_pd() {
+    fn test_mm512_maskz_cvtepi64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepi64_pd(0b01101001, a);
         let e = _mm512_set_pd(0., 2., 3., 0., 5., 0., 0., 8.);
@@ -8724,7 +8724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundepi64_ps() {
+    fn test_mm512_cvt_roundepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepi64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8732,7 +8732,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundepi64_ps() {
+    fn test_mm512_mask_cvt_roundepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvt_roundepi64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -8743,7 +8743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundepi64_ps() {
+    fn test_mm512_maskz_cvt_roundepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepi64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -8753,7 +8753,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtepi64_ps() {
+    fn test_mm_cvtepi64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepi64_ps(a);
         let e = _mm_set_ps(0., 0., 1., 2.);
@@ -8761,7 +8761,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_ps() {
+    fn test_mm_mask_cvtepi64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_ps(3., 4., 5., 6.);
         let r = _mm_mask_cvtepi64_ps(b, 0b01, a);
@@ -8770,7 +8770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_ps() {
+    fn test_mm_maskz_cvtepi64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepi64_ps(0b01, a);
         let e = _mm_set_ps(0., 0., 0., 2.);
@@ -8778,7 +8778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtepi64_ps() {
+    fn test_mm256_cvtepi64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepi64_ps(a);
         let e = _mm_set_ps(1., 2., 3., 4.);
@@ -8786,7 +8786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi64_ps() {
+    fn test_mm256_mask_cvtepi64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_ps(5., 6., 7., 8.);
         let r = _mm256_mask_cvtepi64_ps(b, 0b0110, a);
@@ -8795,7 +8795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi64_ps() {
+    fn test_mm256_maskz_cvtepi64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepi64_ps(0b0110, a);
         let e = _mm_set_ps(0., 2., 3., 0.);
@@ -8803,7 +8803,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtepi64_ps() {
+    fn test_mm512_cvtepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepi64_ps(a);
         let e = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8811,7 +8811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtepi64_ps() {
+    fn test_mm512_mask_cvtepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvtepi64_ps(b, 0b01101001, a);
@@ -8820,7 +8820,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtepi64_ps() {
+    fn test_mm512_maskz_cvtepi64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepi64_ps(0b01101001, a);
         let e = _mm256_set_ps(0., 2., 3., 0., 5., 0., 0., 8.);
@@ -8828,7 +8828,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundepu64_pd() {
+    fn test_mm512_cvt_roundepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepu64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8836,7 +8836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundepu64_pd() {
+    fn test_mm512_mask_cvt_roundepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvt_roundepu64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -8847,7 +8847,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundepu64_pd() {
+    fn test_mm512_maskz_cvt_roundepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepu64_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -8857,7 +8857,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtepu64_pd() {
+    fn test_mm_cvtepu64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepu64_pd(a);
         let e = _mm_set_pd(1., 2.);
@@ -8865,7 +8865,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtepu64_pd() {
+    fn test_mm_mask_cvtepu64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_mask_cvtepu64_pd(b, 0b01, a);
@@ -8874,7 +8874,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepu64_pd() {
+    fn test_mm_maskz_cvtepu64_pd() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepu64_pd(0b01, a);
         let e = _mm_set_pd(0., 2.);
@@ -8882,7 +8882,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtepu64_pd() {
+    fn test_mm256_cvtepu64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepu64_pd(a);
         let e = _mm256_set_pd(1., 2., 3., 4.);
@@ -8890,7 +8890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepu64_pd() {
+    fn test_mm256_mask_cvtepu64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_pd(5., 6., 7., 8.);
         let r = _mm256_mask_cvtepu64_pd(b, 0b0110, a);
@@ -8899,7 +8899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepu64_pd() {
+    fn test_mm256_maskz_cvtepu64_pd() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepu64_pd(0b0110, a);
         let e = _mm256_set_pd(0., 2., 3., 0.);
@@ -8907,7 +8907,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtepu64_pd() {
+    fn test_mm512_cvtepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepu64_pd(a);
         let e = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8915,7 +8915,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtepu64_pd() {
+    fn test_mm512_mask_cvtepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvtepu64_pd(b, 0b01101001, a);
@@ -8924,7 +8924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtepu64_pd() {
+    fn test_mm512_maskz_cvtepu64_pd() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepu64_pd(0b01101001, a);
         let e = _mm512_set_pd(0., 2., 3., 0., 5., 0., 0., 8.);
@@ -8932,7 +8932,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundepu64_ps() {
+    fn test_mm512_cvt_roundepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepu64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -8940,7 +8940,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundepu64_ps() {
+    fn test_mm512_mask_cvt_roundepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvt_roundepu64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -8951,7 +8951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundepu64_ps() {
+    fn test_mm512_maskz_cvt_roundepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepu64_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -8961,7 +8961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtepu64_ps() {
+    fn test_mm_cvtepu64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepu64_ps(a);
         let e = _mm_set_ps(0., 0., 1., 2.);
@@ -8969,7 +8969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtepu64_ps() {
+    fn test_mm_mask_cvtepu64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_ps(3., 4., 5., 6.);
         let r = _mm_mask_cvtepu64_ps(b, 0b01, a);
@@ -8978,7 +8978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepu64_ps() {
+    fn test_mm_maskz_cvtepu64_ps() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepu64_ps(0b01, a);
         let e = _mm_set_ps(0., 0., 0., 2.);
@@ -8986,7 +8986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtepu64_ps() {
+    fn test_mm256_cvtepu64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepu64_ps(a);
         let e = _mm_set_ps(1., 2., 3., 4.);
@@ -8994,7 +8994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepu64_ps() {
+    fn test_mm256_mask_cvtepu64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm_set_ps(5., 6., 7., 8.);
         let r = _mm256_mask_cvtepu64_ps(b, 0b0110, a);
@@ -9003,7 +9003,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepu64_ps() {
+    fn test_mm256_maskz_cvtepu64_ps() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepu64_ps(0b0110, a);
         let e = _mm_set_ps(0., 2., 3., 0.);
@@ -9011,7 +9011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtepu64_ps() {
+    fn test_mm512_cvtepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepu64_ps(a);
         let e = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
@@ -9019,7 +9019,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtepu64_ps() {
+    fn test_mm512_mask_cvtepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_ps(9., 10., 11., 12., 13., 14., 15., 16.);
         let r = _mm512_mask_cvtepu64_ps(b, 0b01101001, a);
@@ -9028,7 +9028,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtepu64_ps() {
+    fn test_mm512_maskz_cvtepu64_ps() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepu64_ps(0b01101001, a);
         let e = _mm256_set_ps(0., 2., 3., 0., 5., 0., 0., 8.);
@@ -9036,7 +9036,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundpd_epi64() {
+    fn test_mm512_cvt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvt_roundpd_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9044,7 +9044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundpd_epi64() {
+    fn test_mm512_mask_cvt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvt_roundpd_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -9055,7 +9055,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_epi64() {
+    fn test_mm512_maskz_cvt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvt_roundpd_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -9065,7 +9065,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtpd_epi64() {
+    fn test_mm_cvtpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_cvtpd_epi64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -9073,7 +9073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_epi64() {
+    fn test_mm_mask_cvtpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_mask_cvtpd_epi64(b, 0b01, a);
@@ -9082,7 +9082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_epi64() {
+    fn test_mm_maskz_cvtpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_maskz_cvtpd_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -9090,7 +9090,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtpd_epi64() {
+    fn test_mm256_cvtpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_cvtpd_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9098,7 +9098,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_epi64() {
+    fn test_mm256_mask_cvtpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvtpd_epi64(b, 0b0110, a);
@@ -9107,7 +9107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_epi64() {
+    fn test_mm256_maskz_cvtpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_cvtpd_epi64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9115,7 +9115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtpd_epi64() {
+    fn test_mm512_cvtpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtpd_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9123,7 +9123,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtpd_epi64() {
+    fn test_mm512_mask_cvtpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtpd_epi64(b, 0b01101001, a);
@@ -9132,7 +9132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtpd_epi64() {
+    fn test_mm512_maskz_cvtpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtpd_epi64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9140,7 +9140,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundps_epi64() {
+    fn test_mm512_cvt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvt_roundps_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9148,7 +9148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundps_epi64() {
+    fn test_mm512_mask_cvt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvt_roundps_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -9159,7 +9159,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundps_epi64() {
+    fn test_mm512_maskz_cvt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvt_roundps_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -9169,7 +9169,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtps_epi64() {
+    fn test_mm_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_cvtps_epi64(a);
         let e = _mm_set_epi64x(3, 4);
@@ -9177,7 +9177,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtps_epi64() {
+    fn test_mm_mask_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm_mask_cvtps_epi64(b, 0b01, a);
@@ -9186,7 +9186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtps_epi64() {
+    fn test_mm_maskz_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_cvtps_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 4);
@@ -9194,7 +9194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtps_epi64() {
+    fn test_mm256_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_cvtps_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9202,7 +9202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtps_epi64() {
+    fn test_mm256_mask_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvtps_epi64(b, 0b0110, a);
@@ -9211,7 +9211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtps_epi64() {
+    fn test_mm256_maskz_cvtps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_maskz_cvtps_epi64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9219,7 +9219,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtps_epi64() {
+    fn test_mm512_cvtps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtps_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9227,7 +9227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtps_epi64() {
+    fn test_mm512_mask_cvtps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtps_epi64(b, 0b01101001, a);
@@ -9236,7 +9236,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtps_epi64() {
+    fn test_mm512_maskz_cvtps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtps_epi64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9244,7 +9244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundpd_epu64() {
+    fn test_mm512_cvt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvt_roundpd_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9252,7 +9252,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundpd_epu64() {
+    fn test_mm512_mask_cvt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvt_roundpd_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -9263,7 +9263,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_epu64() {
+    fn test_mm512_maskz_cvt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvt_roundpd_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -9273,7 +9273,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtpd_epu64() {
+    fn test_mm_cvtpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_cvtpd_epu64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -9281,7 +9281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_epu64() {
+    fn test_mm_mask_cvtpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_mask_cvtpd_epu64(b, 0b01, a);
@@ -9290,7 +9290,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_epu64() {
+    fn test_mm_maskz_cvtpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_maskz_cvtpd_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -9298,7 +9298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtpd_epu64() {
+    fn test_mm256_cvtpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_cvtpd_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9306,7 +9306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_epu64() {
+    fn test_mm256_mask_cvtpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvtpd_epu64(b, 0b0110, a);
@@ -9315,7 +9315,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_epu64() {
+    fn test_mm256_maskz_cvtpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_cvtpd_epu64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9323,7 +9323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtpd_epu64() {
+    fn test_mm512_cvtpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtpd_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9331,7 +9331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtpd_epu64() {
+    fn test_mm512_mask_cvtpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtpd_epu64(b, 0b01101001, a);
@@ -9340,7 +9340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtpd_epu64() {
+    fn test_mm512_maskz_cvtpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtpd_epu64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9348,7 +9348,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvt_roundps_epu64() {
+    fn test_mm512_cvt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvt_roundps_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9356,7 +9356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvt_roundps_epu64() {
+    fn test_mm512_mask_cvt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvt_roundps_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -9367,7 +9367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvt_roundps_epu64() {
+    fn test_mm512_maskz_cvt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvt_roundps_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01101001, a,
@@ -9377,7 +9377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvtps_epu64() {
+    fn test_mm_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_cvtps_epu64(a);
         let e = _mm_set_epi64x(3, 4);
@@ -9385,7 +9385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvtps_epu64() {
+    fn test_mm_mask_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm_mask_cvtps_epu64(b, 0b01, a);
@@ -9394,7 +9394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvtps_epu64() {
+    fn test_mm_maskz_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_cvtps_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 4);
@@ -9402,7 +9402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvtps_epu64() {
+    fn test_mm256_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_cvtps_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9410,7 +9410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvtps_epu64() {
+    fn test_mm256_mask_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvtps_epu64(b, 0b0110, a);
@@ -9419,7 +9419,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtps_epu64() {
+    fn test_mm256_maskz_cvtps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_maskz_cvtps_epu64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9427,7 +9427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtps_epu64() {
+    fn test_mm512_cvtps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtps_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9435,7 +9435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtps_epu64() {
+    fn test_mm512_mask_cvtps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtps_epu64(b, 0b01101001, a);
@@ -9444,7 +9444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtps_epu64() {
+    fn test_mm512_maskz_cvtps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtps_epu64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9452,7 +9452,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtt_roundpd_epi64() {
+    fn test_mm512_cvtt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtt_roundpd_epi64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9460,7 +9460,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtt_roundpd_epi64() {
+    fn test_mm512_mask_cvtt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtt_roundpd_epi64::<_MM_FROUND_NO_EXC>(b, 0b01101001, a);
@@ -9469,7 +9469,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtt_roundpd_epi64() {
+    fn test_mm512_maskz_cvtt_roundpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtt_roundpd_epi64::<_MM_FROUND_NO_EXC>(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9477,7 +9477,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvttpd_epi64() {
+    fn test_mm_cvttpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_cvttpd_epi64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -9485,7 +9485,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvttpd_epi64() {
+    fn test_mm_mask_cvttpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_mask_cvttpd_epi64(b, 0b01, a);
@@ -9494,7 +9494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvttpd_epi64() {
+    fn test_mm_maskz_cvttpd_epi64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_maskz_cvttpd_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -9502,7 +9502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvttpd_epi64() {
+    fn test_mm256_cvttpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_cvttpd_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9510,7 +9510,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvttpd_epi64() {
+    fn test_mm256_mask_cvttpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvttpd_epi64(b, 0b0110, a);
@@ -9519,7 +9519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttpd_epi64() {
+    fn test_mm256_maskz_cvttpd_epi64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_cvttpd_epi64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9527,7 +9527,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvttpd_epi64() {
+    fn test_mm512_cvttpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvttpd_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9535,7 +9535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvttpd_epi64() {
+    fn test_mm512_mask_cvttpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvttpd_epi64(b, 0b01101001, a);
@@ -9544,7 +9544,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvttpd_epi64() {
+    fn test_mm512_maskz_cvttpd_epi64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvttpd_epi64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9552,7 +9552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtt_roundps_epi64() {
+    fn test_mm512_cvtt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtt_roundps_epi64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9560,7 +9560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtt_roundps_epi64() {
+    fn test_mm512_mask_cvtt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtt_roundps_epi64::<_MM_FROUND_NO_EXC>(b, 0b01101001, a);
@@ -9569,7 +9569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtt_roundps_epi64() {
+    fn test_mm512_maskz_cvtt_roundps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtt_roundps_epi64::<_MM_FROUND_NO_EXC>(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9577,7 +9577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvttps_epi64() {
+    fn test_mm_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_cvttps_epi64(a);
         let e = _mm_set_epi64x(3, 4);
@@ -9585,7 +9585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvttps_epi64() {
+    fn test_mm_mask_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm_mask_cvttps_epi64(b, 0b01, a);
@@ -9594,7 +9594,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvttps_epi64() {
+    fn test_mm_maskz_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_cvttps_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 4);
@@ -9602,7 +9602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvttps_epi64() {
+    fn test_mm256_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_cvttps_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9610,7 +9610,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvttps_epi64() {
+    fn test_mm256_mask_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvttps_epi64(b, 0b0110, a);
@@ -9619,7 +9619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttps_epi64() {
+    fn test_mm256_maskz_cvttps_epi64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_maskz_cvttps_epi64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9627,7 +9627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvttps_epi64() {
+    fn test_mm512_cvttps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvttps_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9635,7 +9635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvttps_epi64() {
+    fn test_mm512_mask_cvttps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvttps_epi64(b, 0b01101001, a);
@@ -9644,7 +9644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvttps_epi64() {
+    fn test_mm512_maskz_cvttps_epi64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvttps_epi64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9652,7 +9652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtt_roundpd_epu64() {
+    fn test_mm512_cvtt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtt_roundpd_epu64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9660,7 +9660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtt_roundpd_epu64() {
+    fn test_mm512_mask_cvtt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtt_roundpd_epu64::<_MM_FROUND_NO_EXC>(b, 0b01101001, a);
@@ -9669,7 +9669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtt_roundpd_epu64() {
+    fn test_mm512_maskz_cvtt_roundpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtt_roundpd_epu64::<_MM_FROUND_NO_EXC>(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9677,7 +9677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvttpd_epu64() {
+    fn test_mm_cvttpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_cvttpd_epu64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -9685,7 +9685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvttpd_epu64() {
+    fn test_mm_mask_cvttpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_mask_cvttpd_epu64(b, 0b01, a);
@@ -9694,7 +9694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvttpd_epu64() {
+    fn test_mm_maskz_cvttpd_epu64() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_maskz_cvttpd_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -9702,7 +9702,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvttpd_epu64() {
+    fn test_mm256_cvttpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_cvttpd_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9710,7 +9710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvttpd_epu64() {
+    fn test_mm256_mask_cvttpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvttpd_epu64(b, 0b0110, a);
@@ -9719,7 +9719,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttpd_epu64() {
+    fn test_mm256_maskz_cvttpd_epu64() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_cvttpd_epu64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9727,7 +9727,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvttpd_epu64() {
+    fn test_mm512_cvttpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvttpd_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9735,7 +9735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvttpd_epu64() {
+    fn test_mm512_mask_cvttpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvttpd_epu64(b, 0b01101001, a);
@@ -9744,7 +9744,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvttpd_epu64() {
+    fn test_mm512_maskz_cvttpd_epu64() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvttpd_epu64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9752,7 +9752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvtt_roundps_epu64() {
+    fn test_mm512_cvtt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvtt_roundps_epu64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9760,7 +9760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvtt_roundps_epu64() {
+    fn test_mm512_mask_cvtt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvtt_roundps_epu64::<_MM_FROUND_NO_EXC>(b, 0b01101001, a);
@@ -9769,7 +9769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvtt_roundps_epu64() {
+    fn test_mm512_maskz_cvtt_roundps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvtt_roundps_epu64::<_MM_FROUND_NO_EXC>(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9777,7 +9777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_cvttps_epu64() {
+    fn test_mm_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_cvttps_epu64(a);
         let e = _mm_set_epi64x(3, 4);
@@ -9785,7 +9785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_cvttps_epu64() {
+    fn test_mm_mask_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_epi64x(5, 6);
         let r = _mm_mask_cvttps_epu64(b, 0b01, a);
@@ -9794,7 +9794,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_cvttps_epu64() {
+    fn test_mm_maskz_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_cvttps_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 4);
@@ -9802,7 +9802,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_cvttps_epu64() {
+    fn test_mm256_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_cvttps_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -9810,7 +9810,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_cvttps_epu64() {
+    fn test_mm256_mask_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mask_cvttps_epu64(b, 0b0110, a);
@@ -9819,7 +9819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttps_epu64() {
+    fn test_mm256_maskz_cvttps_epu64() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm256_maskz_cvttps_epu64(0b0110, a);
         let e = _mm256_set_epi64x(0, 2, 3, 0);
@@ -9827,7 +9827,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_cvttps_epu64() {
+    fn test_mm512_cvttps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_cvttps_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -9835,7 +9835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_cvttps_epu64() {
+    fn test_mm512_mask_cvttps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_cvttps_epu64(b, 0b01101001, a);
@@ -9844,7 +9844,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_cvttps_epu64() {
+    fn test_mm512_maskz_cvttps_epu64() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_cvttps_epu64(0b01101001, a);
         let e = _mm512_set_epi64(0, 2, 3, 0, 5, 0, 0, 8);
@@ -9852,7 +9852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mullo_epi64() {
+    const fn test_mm_mullo_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_mullo_epi64(a, b);
@@ -9861,7 +9861,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_mask_mullo_epi64() {
+    const fn test_mm_mask_mullo_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(3, 4);
         let c = _mm_set_epi64x(5, 6);
@@ -9871,7 +9871,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_maskz_mullo_epi64() {
+    const fn test_mm_maskz_mullo_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(3, 4);
         let r = _mm_maskz_mullo_epi64(0b01, a, b);
@@ -9880,7 +9880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mullo_epi64() {
+    const fn test_mm256_mullo_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_mullo_epi64(a, b);
@@ -9889,7 +9889,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_mask_mullo_epi64() {
+    const fn test_mm256_mask_mullo_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let c = _mm256_set_epi64x(9, 10, 11, 12);
@@ -9899,7 +9899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_maskz_mullo_epi64() {
+    const fn test_mm256_maskz_mullo_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(5, 6, 7, 8);
         let r = _mm256_maskz_mullo_epi64(0b0110, a, b);
@@ -9908,7 +9908,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mullo_epi64() {
+    const fn test_mm512_mullo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mullo_epi64(a, b);
@@ -9917,7 +9917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_mask_mullo_epi64() {
+    const fn test_mm512_mask_mullo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let c = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
@@ -9927,7 +9927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_maskz_mullo_epi64() {
+    const fn test_mm512_maskz_mullo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_mullo_epi64(0b01101001, a, b);
@@ -9936,7 +9936,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_cvtmask8_u32() {
+    const fn test_cvtmask8_u32() {
         let a: __mmask8 = 0b01101001;
         let r = _cvtmask8_u32(a);
         let e: u32 = 0b01101001;
@@ -9944,7 +9944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_cvtu32_mask8() {
+    const fn test_cvtu32_mask8() {
         let a: u32 = 0b01101001;
         let r = _cvtu32_mask8(a);
         let e: __mmask8 = 0b01101001;
@@ -9952,7 +9952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kadd_mask16() {
+    const fn test_kadd_mask16() {
         let a: __mmask16 = 27549;
         let b: __mmask16 = 23434;
         let r = _kadd_mask16(a, b);
@@ -9961,7 +9961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kadd_mask8() {
+    const fn test_kadd_mask8() {
         let a: __mmask8 = 98;
         let b: __mmask8 = 117;
         let r = _kadd_mask8(a, b);
@@ -9970,7 +9970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kand_mask8() {
+    const fn test_kand_mask8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110011;
         let r = _kand_mask8(a, b);
@@ -9979,7 +9979,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kandn_mask8() {
+    const fn test_kandn_mask8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110011;
         let r = _kandn_mask8(a, b);
@@ -9988,7 +9988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_knot_mask8() {
+    const fn test_knot_mask8() {
         let a: __mmask8 = 0b01101001;
         let r = _knot_mask8(a);
         let e: __mmask8 = 0b10010110;
@@ -9996,7 +9996,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kor_mask8() {
+    const fn test_kor_mask8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110011;
         let r = _kor_mask8(a, b);
@@ -10005,7 +10005,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kxnor_mask8() {
+    const fn test_kxnor_mask8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110011;
         let r = _kxnor_mask8(a, b);
@@ -10014,7 +10014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kxor_mask8() {
+    const fn test_kxor_mask8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110011;
         let r = _kxor_mask8(a, b);
@@ -10033,7 +10033,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kortestc_mask8_u8() {
+    const fn test_kortestc_mask8_u8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110110;
         let r = _kortestc_mask8_u8(a, b);
@@ -10041,7 +10041,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kortestz_mask8_u8() {
+    const fn test_kortestz_mask8_u8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10110110;
         let r = _kortestz_mask8_u8(a, b);
@@ -10069,7 +10069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_kshiftri_mask8() {
+    const fn test_kshiftri_mask8() {
         let a: __mmask8 = 0b10101001;
         let r = _kshiftri_mask8::<3>(a);
         let e: __mmask8 = 0b00010101;
@@ -10099,7 +10099,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_ktestc_mask8_u8() {
+    const fn test_ktestc_mask8_u8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10010110;
         let r = _ktestc_mask8_u8(a, b);
@@ -10107,7 +10107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_ktestz_mask8_u8() {
+    const fn test_ktestz_mask8_u8() {
         let a: __mmask8 = 0b01101001;
         let b: __mmask8 = 0b10010110;
         let r = _ktestz_mask8_u8(a, b);
@@ -10125,7 +10125,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_ktestc_mask16_u8() {
+    const fn test_ktestc_mask16_u8() {
         let a: __mmask16 = 0b0110100100111100;
         let b: __mmask16 = 0b1001011011000011;
         let r = _ktestc_mask16_u8(a, b);
@@ -10133,7 +10133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_ktestz_mask16_u8() {
+    const fn test_ktestz_mask16_u8() {
         let a: __mmask16 = 0b0110100100111100;
         let b: __mmask16 = 0b1001011011000011;
         let r = _ktestz_mask16_u8(a, b);
@@ -10158,7 +10158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_movepi32_mask() {
+    const fn test_mm_movepi32_mask() {
         let a = _mm_set_epi32(0, -2, -3, 4);
         let r = _mm_movepi32_mask(a);
         let e = 0b0110;
@@ -10166,7 +10166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_movepi32_mask() {
+    const fn test_mm256_movepi32_mask() {
         let a = _mm256_set_epi32(0, -2, -3, 4, -5, 6, 7, -8);
         let r = _mm256_movepi32_mask(a);
         let e = 0b01101001;
@@ -10174,7 +10174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_movepi32_mask() {
+    const fn test_mm512_movepi32_mask() {
         let a = _mm512_set_epi32(
             0, -2, -3, 4, -5, 6, 7, -8, 9, 10, -11, -12, -13, -14, 15, 16,
         );
@@ -10184,7 +10184,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_movepi64_mask() {
+    const fn test_mm_movepi64_mask() {
         let a = _mm_set_epi64x(0, -2);
         let r = _mm_movepi64_mask(a);
         let e = 0b01;
@@ -10192,7 +10192,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_movepi64_mask() {
+    const fn test_mm256_movepi64_mask() {
         let a = _mm256_set_epi64x(0, -2, -3, 4);
         let r = _mm256_movepi64_mask(a);
         let e = 0b0110;
@@ -10200,7 +10200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_movepi64_mask() {
+    const fn test_mm512_movepi64_mask() {
         let a = _mm512_set_epi64(0, -2, -3, 4, -5, 6, 7, -8);
         let r = _mm512_movepi64_mask(a);
         let e = 0b01101001;
@@ -10208,7 +10208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_movm_epi32() {
+    const fn test_mm_movm_epi32() {
         let a = 0b0110;
         let r = _mm_movm_epi32(a);
         let e = _mm_set_epi32(0, -1, -1, 0);
@@ -10216,7 +10216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_movm_epi32() {
+    const fn test_mm256_movm_epi32() {
         let a = 0b01101001;
         let r = _mm256_movm_epi32(a);
         let e = _mm256_set_epi32(0, -1, -1, 0, -1, 0, 0, -1);
@@ -10224,7 +10224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_movm_epi32() {
+    const fn test_mm512_movm_epi32() {
         let a = 0b0110100100111100;
         let r = _mm512_movm_epi32(a);
         let e = _mm512_set_epi32(0, -1, -1, 0, -1, 0, 0, -1, 0, 0, -1, -1, -1, -1, 0, 0);
@@ -10232,7 +10232,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm_movm_epi64() {
+    const fn test_mm_movm_epi64() {
         let a = 0b01;
         let r = _mm_movm_epi64(a);
         let e = _mm_set_epi64x(0, -1);
@@ -10240,7 +10240,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    const unsafe fn test_mm256_movm_epi64() {
+    const fn test_mm256_movm_epi64() {
         let a = 0b0110;
         let r = _mm256_movm_epi64(a);
         let e = _mm256_set_epi64x(0, -1, -1, 0);
@@ -10248,7 +10248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    const unsafe fn test_mm512_movm_epi64() {
+    const fn test_mm512_movm_epi64() {
         let a = 0b01101001;
         let r = _mm512_movm_epi64(a);
         let e = _mm512_set_epi64(0, -1, -1, 0, -1, 0, 0, -1);
@@ -10256,7 +10256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_range_round_pd() {
+    fn test_mm512_range_round_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm512_range_round_pd::<0b0101, _MM_FROUND_NO_EXC>(a, b);
@@ -10265,7 +10265,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_range_round_pd() {
+    fn test_mm512_mask_range_round_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let c = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
@@ -10275,7 +10275,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_range_round_pd() {
+    fn test_mm512_maskz_range_round_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm512_maskz_range_round_pd::<0b0101, _MM_FROUND_NO_EXC>(0b01101001, a, b);
@@ -10284,7 +10284,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_range_pd() {
+    fn test_mm_range_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(2., 1.);
         let r = _mm_range_pd::<0b0101>(a, b);
@@ -10293,7 +10293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_range_pd() {
+    fn test_mm_mask_range_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(2., 1.);
         let c = _mm_set_pd(3., 4.);
@@ -10303,7 +10303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_range_pd() {
+    fn test_mm_maskz_range_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(2., 1.);
         let r = _mm_maskz_range_pd::<0b0101>(0b01, a, b);
@@ -10312,7 +10312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_range_pd() {
+    fn test_mm256_range_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(2., 1., 4., 3.);
         let r = _mm256_range_pd::<0b0101>(a, b);
@@ -10321,7 +10321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_range_pd() {
+    fn test_mm256_mask_range_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(2., 1., 4., 3.);
         let c = _mm256_set_pd(5., 6., 7., 8.);
@@ -10331,7 +10331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_range_pd() {
+    fn test_mm256_maskz_range_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(2., 1., 4., 3.);
         let r = _mm256_maskz_range_pd::<0b0101>(0b0110, a, b);
@@ -10340,7 +10340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_range_pd() {
+    fn test_mm512_range_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm512_range_pd::<0b0101>(a, b);
@@ -10349,7 +10349,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_range_pd() {
+    fn test_mm512_mask_range_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let c = _mm512_set_pd(9., 10., 11., 12., 13., 14., 15., 16.);
@@ -10359,7 +10359,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_range_pd() {
+    fn test_mm512_maskz_range_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm512_maskz_range_pd::<0b0101>(0b01101001, a, b);
@@ -10368,7 +10368,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_range_round_ps() {
+    fn test_mm512_range_round_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10383,7 +10383,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_range_round_ps() {
+    fn test_mm512_mask_range_round_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10402,7 +10402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_range_round_ps() {
+    fn test_mm512_maskz_range_round_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10417,7 +10417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_range_ps() {
+    fn test_mm_range_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(2., 1., 4., 3.);
         let r = _mm_range_ps::<0b0101>(a, b);
@@ -10426,7 +10426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_range_ps() {
+    fn test_mm_mask_range_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(2., 1., 4., 3.);
         let c = _mm_set_ps(5., 6., 7., 8.);
@@ -10436,7 +10436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_range_ps() {
+    fn test_mm_maskz_range_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(2., 1., 4., 3.);
         let r = _mm_maskz_range_ps::<0b0101>(0b0110, a, b);
@@ -10445,7 +10445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_range_ps() {
+    fn test_mm256_range_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm256_range_ps::<0b0101>(a, b);
@@ -10454,7 +10454,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_range_ps() {
+    fn test_mm256_mask_range_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(2., 1., 4., 3., 6., 5., 8., 7.);
         let c = _mm256_set_ps(9., 10., 11., 12., 13., 14., 15., 16.);
@@ -10464,7 +10464,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_range_ps() {
+    fn test_mm256_maskz_range_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(2., 1., 4., 3., 6., 5., 8., 7.);
         let r = _mm256_maskz_range_ps::<0b0101>(0b01101001, a, b);
@@ -10473,7 +10473,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_range_ps() {
+    fn test_mm512_range_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10488,7 +10488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_range_ps() {
+    fn test_mm512_mask_range_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10506,7 +10506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_range_ps() {
+    fn test_mm512_maskz_range_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -10521,7 +10521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_range_round_sd() {
+    fn test_mm_range_round_sd() {
         let a = _mm_set_sd(1.);
         let b = _mm_set_sd(2.);
         let r = _mm_range_round_sd::<0b0101, _MM_FROUND_NO_EXC>(a, b);
@@ -10530,7 +10530,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_range_round_sd() {
+    fn test_mm_mask_range_round_sd() {
         let a = _mm_set_sd(1.);
         let b = _mm_set_sd(2.);
         let c = _mm_set_sd(3.);
@@ -10540,7 +10540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_range_round_sd() {
+    fn test_mm_maskz_range_round_sd() {
         let a = _mm_set_sd(1.);
         let b = _mm_set_sd(2.);
         let r = _mm_maskz_range_round_sd::<0b0101, _MM_FROUND_NO_EXC>(0b0, a, b);
@@ -10549,7 +10549,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_range_sd() {
+    fn test_mm_mask_range_sd() {
         let a = _mm_set_sd(1.);
         let b = _mm_set_sd(2.);
         let c = _mm_set_sd(3.);
@@ -10559,7 +10559,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_range_sd() {
+    fn test_mm_maskz_range_sd() {
         let a = _mm_set_sd(1.);
         let b = _mm_set_sd(2.);
         let r = _mm_maskz_range_sd::<0b0101>(0b0, a, b);
@@ -10568,7 +10568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_range_round_ss() {
+    fn test_mm_range_round_ss() {
         let a = _mm_set_ss(1.);
         let b = _mm_set_ss(2.);
         let r = _mm_range_round_ss::<0b0101, _MM_FROUND_NO_EXC>(a, b);
@@ -10577,7 +10577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_range_round_ss() {
+    fn test_mm_mask_range_round_ss() {
         let a = _mm_set_ss(1.);
         let b = _mm_set_ss(2.);
         let c = _mm_set_ss(3.);
@@ -10587,7 +10587,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_range_round_ss() {
+    fn test_mm_maskz_range_round_ss() {
         let a = _mm_set_ss(1.);
         let b = _mm_set_ss(2.);
         let r = _mm_maskz_range_round_ss::<0b0101, _MM_FROUND_NO_EXC>(0b0, a, b);
@@ -10596,7 +10596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_range_ss() {
+    fn test_mm_mask_range_ss() {
         let a = _mm_set_ss(1.);
         let b = _mm_set_ss(2.);
         let c = _mm_set_ss(3.);
@@ -10606,7 +10606,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_range_ss() {
+    fn test_mm_maskz_range_ss() {
         let a = _mm_set_ss(1.);
         let b = _mm_set_ss(2.);
         let r = _mm_maskz_range_ss::<0b0101>(0b0, a, b);
@@ -10615,7 +10615,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_reduce_round_pd() {
+    fn test_mm512_reduce_round_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm512_reduce_round_pd::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_pd(0.25, 0., 0.25, 0., 0.25, 0., 0.25, 0.);
@@ -10623,7 +10623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_reduce_round_pd() {
+    fn test_mm512_mask_reduce_round_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let src = _mm512_set_pd(3., 4., 5., 6., 7., 8., 9., 10.);
         let r = _mm512_mask_reduce_round_pd::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(
@@ -10634,7 +10634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_reduce_round_pd() {
+    fn test_mm512_maskz_reduce_round_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm512_maskz_reduce_round_pd::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(
             0b01101001, a,
@@ -10644,7 +10644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_reduce_pd() {
+    fn test_mm_reduce_pd() {
         let a = _mm_set_pd(0.25, 0.50);
         let r = _mm_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm_set_pd(0.25, 0.);
@@ -10652,7 +10652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_reduce_pd() {
+    fn test_mm_mask_reduce_pd() {
         let a = _mm_set_pd(0.25, 0.50);
         let src = _mm_set_pd(3., 4.);
         let r = _mm_mask_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b01, a);
@@ -10661,7 +10661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_reduce_pd() {
+    fn test_mm_maskz_reduce_pd() {
         let a = _mm_set_pd(0.25, 0.50);
         let r = _mm_maskz_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(0b01, a);
         let e = _mm_set_pd(0., 0.);
@@ -10669,7 +10669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_reduce_pd() {
+    fn test_mm256_reduce_pd() {
         let a = _mm256_set_pd(0.25, 0.50, 0.75, 1.0);
         let r = _mm256_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm256_set_pd(0.25, 0., 0.25, 0.);
@@ -10677,7 +10677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_reduce_pd() {
+    fn test_mm256_mask_reduce_pd() {
         let a = _mm256_set_pd(0.25, 0.50, 0.75, 1.0);
         let src = _mm256_set_pd(3., 4., 5., 6.);
         let r = _mm256_mask_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b0110, a);
@@ -10686,7 +10686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_reduce_pd() {
+    fn test_mm256_maskz_reduce_pd() {
         let a = _mm256_set_pd(0.25, 0.50, 0.75, 1.0);
         let r = _mm256_maskz_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(0b0110, a);
         let e = _mm256_set_pd(0., 0., 0.25, 0.);
@@ -10694,7 +10694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_reduce_pd() {
+    fn test_mm512_reduce_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm512_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm512_set_pd(0.25, 0., 0.25, 0., 0.25, 0., 0.25, 0.);
@@ -10702,7 +10702,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_reduce_pd() {
+    fn test_mm512_mask_reduce_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let src = _mm512_set_pd(3., 4., 5., 6., 7., 8., 9., 10.);
         let r = _mm512_mask_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b01101001, a);
@@ -10711,7 +10711,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_reduce_pd() {
+    fn test_mm512_maskz_reduce_pd() {
         let a = _mm512_set_pd(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm512_maskz_reduce_pd::<{ 16 | _MM_FROUND_TO_ZERO }>(0b01101001, a);
         let e = _mm512_set_pd(0., 0., 0.25, 0., 0.25, 0., 0., 0.);
@@ -10719,7 +10719,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_reduce_round_ps() {
+    fn test_mm512_reduce_round_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10732,7 +10732,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_reduce_round_ps() {
+    fn test_mm512_mask_reduce_round_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10752,7 +10752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_reduce_round_ps() {
+    fn test_mm512_maskz_reduce_round_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10768,7 +10768,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_reduce_ps() {
+    fn test_mm_reduce_ps() {
         let a = _mm_set_ps(0.25, 0.50, 0.75, 1.0);
         let r = _mm_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm_set_ps(0.25, 0., 0.25, 0.);
@@ -10776,7 +10776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_reduce_ps() {
+    fn test_mm_mask_reduce_ps() {
         let a = _mm_set_ps(0.25, 0.50, 0.75, 1.0);
         let src = _mm_set_ps(2., 3., 4., 5.);
         let r = _mm_mask_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b0110, a);
@@ -10785,7 +10785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_maskz_reduce_ps() {
+    fn test_mm_maskz_reduce_ps() {
         let a = _mm_set_ps(0.25, 0.50, 0.75, 1.0);
         let r = _mm_maskz_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(0b0110, a);
         let e = _mm_set_ps(0., 0., 0.25, 0.);
@@ -10793,7 +10793,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_reduce_ps() {
+    fn test_mm256_reduce_ps() {
         let a = _mm256_set_ps(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm256_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm256_set_ps(0.25, 0., 0.25, 0., 0.25, 0., 0.25, 0.);
@@ -10801,7 +10801,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_reduce_ps() {
+    fn test_mm256_mask_reduce_ps() {
         let a = _mm256_set_ps(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let src = _mm256_set_ps(3., 4., 5., 6., 7., 8., 9., 10.);
         let r = _mm256_mask_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b01101001, a);
@@ -10810,7 +10810,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_maskz_reduce_ps() {
+    fn test_mm256_maskz_reduce_ps() {
         let a = _mm256_set_ps(0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0);
         let r = _mm256_maskz_reduce_ps::<{ 16 | _MM_FROUND_TO_ZERO }>(0b01101001, a);
         let e = _mm256_set_ps(0., 0., 0.25, 0., 0.25, 0., 0., 0.);
@@ -10818,7 +10818,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_reduce_ps() {
+    fn test_mm512_reduce_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10831,7 +10831,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_reduce_ps() {
+    fn test_mm512_mask_reduce_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10847,7 +10847,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_maskz_reduce_ps() {
+    fn test_mm512_maskz_reduce_ps() {
         let a = _mm512_set_ps(
             0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 1.75, 2.0, 2.25, 2.50, 2.75, 3.0, 3.25, 3.50, 3.75,
             4.0,
@@ -10860,7 +10860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_reduce_round_sd() {
+    fn test_mm_reduce_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let r = _mm_reduce_round_sd::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(a, b);
@@ -10869,7 +10869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_reduce_round_sd() {
+    fn test_mm_mask_reduce_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let c = _mm_set_pd(3., 4.);
@@ -10881,7 +10881,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_reduce_round_sd() {
+    fn test_mm_maskz_reduce_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let r =
@@ -10891,7 +10891,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_reduce_sd() {
+    fn test_mm_reduce_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let r = _mm_reduce_sd::<{ 16 | _MM_FROUND_TO_ZERO }>(a, b);
@@ -10900,7 +10900,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_reduce_sd() {
+    fn test_mm_mask_reduce_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let c = _mm_set_pd(3., 4.);
@@ -10910,7 +10910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_reduce_sd() {
+    fn test_mm_maskz_reduce_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_sd(0.25);
         let r = _mm_maskz_reduce_sd::<{ 16 | _MM_FROUND_TO_ZERO }>(0b0, a, b);
@@ -10919,7 +10919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_reduce_round_ss() {
+    fn test_mm_reduce_round_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let r = _mm_reduce_round_ss::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(a, b);
@@ -10928,7 +10928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_reduce_round_ss() {
+    fn test_mm_mask_reduce_round_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let c = _mm_set_ps(5., 6., 7., 8.);
@@ -10940,7 +10940,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_reduce_round_ss() {
+    fn test_mm_maskz_reduce_round_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let r =
@@ -10950,7 +10950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_reduce_ss() {
+    fn test_mm_reduce_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let r = _mm_reduce_ss::<{ 16 | _MM_FROUND_TO_ZERO }>(a, b);
@@ -10959,7 +10959,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_reduce_ss() {
+    fn test_mm_mask_reduce_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let c = _mm_set_ps(5., 6., 7., 8.);
@@ -10969,7 +10969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_maskz_reduce_ss() {
+    fn test_mm_maskz_reduce_ss() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ss(0.25);
         let r = _mm_maskz_reduce_ss::<{ 16 | _MM_FROUND_TO_ZERO }>(0b0, a, b);
@@ -10978,7 +10978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_fpclass_pd_mask() {
+    fn test_mm_fpclass_pd_mask() {
         let a = _mm_set_pd(1., f64::INFINITY);
         let r = _mm_fpclass_pd_mask::<0x18>(a);
         let e = 0b01;
@@ -10986,7 +10986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_fpclass_pd_mask() {
+    fn test_mm_mask_fpclass_pd_mask() {
         let a = _mm_set_pd(1., f64::INFINITY);
         let r = _mm_mask_fpclass_pd_mask::<0x18>(0b10, a);
         let e = 0b00;
@@ -10994,7 +10994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_fpclass_pd_mask() {
+    fn test_mm256_fpclass_pd_mask() {
         let a = _mm256_set_pd(1., f64::INFINITY, f64::NEG_INFINITY, 0.0);
         let r = _mm256_fpclass_pd_mask::<0x18>(a);
         let e = 0b0110;
@@ -11002,7 +11002,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_fpclass_pd_mask() {
+    fn test_mm256_mask_fpclass_pd_mask() {
         let a = _mm256_set_pd(1., f64::INFINITY, f64::NEG_INFINITY, 0.0);
         let r = _mm256_mask_fpclass_pd_mask::<0x18>(0b1010, a);
         let e = 0b0010;
@@ -11010,7 +11010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_fpclass_pd_mask() {
+    fn test_mm512_fpclass_pd_mask() {
         let a = _mm512_set_pd(
             1.,
             f64::INFINITY,
@@ -11027,7 +11027,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_fpclass_pd_mask() {
+    fn test_mm512_mask_fpclass_pd_mask() {
         let a = _mm512_set_pd(
             1.,
             f64::INFINITY,
@@ -11044,7 +11044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_fpclass_ps_mask() {
+    fn test_mm_fpclass_ps_mask() {
         let a = _mm_set_ps(1., f32::INFINITY, f32::NEG_INFINITY, 0.0);
         let r = _mm_fpclass_ps_mask::<0x18>(a);
         let e = 0b0110;
@@ -11052,7 +11052,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm_mask_fpclass_ps_mask() {
+    fn test_mm_mask_fpclass_ps_mask() {
         let a = _mm_set_ps(1., f32::INFINITY, f32::NEG_INFINITY, 0.0);
         let r = _mm_mask_fpclass_ps_mask::<0x18>(0b1010, a);
         let e = 0b0010;
@@ -11060,7 +11060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_fpclass_ps_mask() {
+    fn test_mm256_fpclass_ps_mask() {
         let a = _mm256_set_ps(
             1.,
             f32::INFINITY,
@@ -11077,7 +11077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq,avx512vl")]
-    unsafe fn test_mm256_mask_fpclass_ps_mask() {
+    fn test_mm256_mask_fpclass_ps_mask() {
         let a = _mm256_set_ps(
             1.,
             f32::INFINITY,
@@ -11094,7 +11094,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_fpclass_ps_mask() {
+    fn test_mm512_fpclass_ps_mask() {
         let a = _mm512_set_ps(
             1.,
             f32::INFINITY,
@@ -11119,7 +11119,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm512_mask_fpclass_ps_mask() {
+    fn test_mm512_mask_fpclass_ps_mask() {
         let a = _mm512_set_ps(
             1.,
             f32::INFINITY,
@@ -11144,7 +11144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_fpclass_sd_mask() {
+    fn test_mm_fpclass_sd_mask() {
         let a = _mm_set_pd(1., f64::INFINITY);
         let r = _mm_fpclass_sd_mask::<0x18>(a);
         let e = 0b1;
@@ -11152,7 +11152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_fpclass_sd_mask() {
+    fn test_mm_mask_fpclass_sd_mask() {
         let a = _mm_set_sd(f64::INFINITY);
         let r = _mm_mask_fpclass_sd_mask::<0x18>(0b0, a);
         let e = 0b0;
@@ -11160,7 +11160,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_fpclass_ss_mask() {
+    fn test_mm_fpclass_ss_mask() {
         let a = _mm_set_ss(f32::INFINITY);
         let r = _mm_fpclass_ss_mask::<0x18>(a);
         let e = 0b1;
@@ -11168,7 +11168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512dq")]
-    unsafe fn test_mm_mask_fpclass_ss_mask() {
+    fn test_mm_mask_fpclass_ss_mask() {
         let a = _mm_set_ss(f32::INFINITY);
         let r = _mm_mask_fpclass_ss_mask::<0x18>(0b0, a);
         let e = 0b0;
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512f.rs b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
index f300bf48ef6d..76b753938383 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
@@ -27728,7 +27728,13 @@ pub const fn _mm_maskz_unpacklo_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m12
     }
 }
 
-/// Cast vector of type __m128 to type __m512; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m128 to type __m512; the upper 384 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps128_ps512&expand=621)
 #[inline]
@@ -27745,7 +27751,13 @@ pub const fn _mm512_castps128_ps512(a: __m128) -> __m512 {
     }
 }
 
-/// Cast vector of type __m256 to type __m512; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m256 to type __m512; the upper 256 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castps256_ps512&expand=623)
 #[inline]
@@ -27840,7 +27852,13 @@ pub const fn _mm512_castps_si512(a: __m512) -> __m512i {
     unsafe { transmute(a) }
 }
 
-/// Cast vector of type __m128d to type __m512d; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m128d to type __m512d; the upper 384 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd128_pd512&expand=609)
 #[inline]
@@ -27851,7 +27869,13 @@ pub const fn _mm512_castpd128_pd512(a: __m128d) -> __m512d {
     unsafe { simd_shuffle!(a, _mm_undefined_pd(), [0, 1, 2, 2, 2, 2, 2, 2]) }
 }
 
-/// Cast vector of type __m256d to type __m512d; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m256d to type __m512d; the upper 256 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castpd256_pd512&expand=611)
 #[inline]
@@ -27928,7 +27952,13 @@ pub const fn _mm512_castpd_si512(a: __m512d) -> __m512i {
     unsafe { transmute(a) }
 }
 
-/// Cast vector of type __m128i to type __m512i; the upper 384 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m128i to type __m512i; the upper 384 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi128_si512&expand=629)
 #[inline]
@@ -27939,7 +27969,13 @@ pub const fn _mm512_castsi128_si512(a: __m128i) -> __m512i {
     unsafe { simd_shuffle!(a, _mm_undefined_si128(), [0, 1, 2, 2, 2, 2, 2, 2]) }
 }
 
-/// Cast vector of type __m256i to type __m512i; the upper 256 bits of the result are undefined. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
+/// Cast vector of type __m256i to type __m512i; the upper 256 bits of the result are indeterminate.
+///
+/// In the Intel documentation, the upper bits are declared to be "undefined".
+/// This is not equivalent to [`mem::MaybeUninit`]; instead, these bits are non-deterministically
+/// set to some valid value. In practice, this is typically equivalent to [`mem::zeroed`].
+///
+/// This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.
 ///
 /// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_castsi256_si512&expand=633)
 #[inline]
@@ -45033,7 +45069,7 @@ mod tests {
     use crate::mem::{self};
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_abs_epi32() {
+    const fn test_mm512_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45053,7 +45089,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_abs_epi32() {
+    const fn test_mm512_mask_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45075,7 +45111,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_abs_epi32() {
+    const fn test_mm512_maskz_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45097,7 +45133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_abs_epi32() {
+    const fn test_mm256_mask_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45115,7 +45151,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_abs_epi32() {
+    const fn test_mm256_maskz_abs_epi32() {
         #[rustfmt::skip]
         let a = _mm256_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45133,7 +45169,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_abs_epi32() {
+    const fn test_mm_mask_abs_epi32() {
         let a = _mm_setr_epi32(i32::MIN, 100, -100, -32);
         let r = _mm_mask_abs_epi32(a, 0, a);
         assert_eq_m128i(r, a);
@@ -45143,7 +45179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_abs_epi32() {
+    const fn test_mm_maskz_abs_epi32() {
         let a = _mm_setr_epi32(i32::MIN, 100, -100, -32);
         let r = _mm_maskz_abs_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -45153,7 +45189,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_abs_ps() {
+    const fn test_mm512_abs_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45173,7 +45209,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_abs_ps() {
+    const fn test_mm512_mask_abs_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45195,7 +45231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mov_epi32() {
+    const fn test_mm512_mask_mov_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(2);
         let r = _mm512_mask_mov_epi32(src, 0, a);
@@ -45205,7 +45241,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mov_epi32() {
+    const fn test_mm512_maskz_mov_epi32() {
         let a = _mm512_set1_epi32(2);
         let r = _mm512_maskz_mov_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -45214,7 +45250,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_epi32() {
+    const fn test_mm256_mask_mov_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(2);
         let r = _mm256_mask_mov_epi32(src, 0, a);
@@ -45224,7 +45260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_epi32() {
+    const fn test_mm256_maskz_mov_epi32() {
         let a = _mm256_set1_epi32(2);
         let r = _mm256_maskz_mov_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -45233,7 +45269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mov_epi32() {
+    const fn test_mm_mask_mov_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(2);
         let r = _mm_mask_mov_epi32(src, 0, a);
@@ -45243,7 +45279,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_epi32() {
+    const fn test_mm_maskz_mov_epi32() {
         let a = _mm_set1_epi32(2);
         let r = _mm_maskz_mov_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -45252,7 +45288,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mov_ps() {
+    const fn test_mm512_mask_mov_ps() {
         let src = _mm512_set1_ps(1.);
         let a = _mm512_set1_ps(2.);
         let r = _mm512_mask_mov_ps(src, 0, a);
@@ -45262,7 +45298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mov_ps() {
+    const fn test_mm512_maskz_mov_ps() {
         let a = _mm512_set1_ps(2.);
         let r = _mm512_maskz_mov_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -45271,7 +45307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_ps() {
+    const fn test_mm256_mask_mov_ps() {
         let src = _mm256_set1_ps(1.);
         let a = _mm256_set1_ps(2.);
         let r = _mm256_mask_mov_ps(src, 0, a);
@@ -45281,7 +45317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_ps() {
+    const fn test_mm256_maskz_mov_ps() {
         let a = _mm256_set1_ps(2.);
         let r = _mm256_maskz_mov_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -45290,7 +45326,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mov_ps() {
+    const fn test_mm_mask_mov_ps() {
         let src = _mm_set1_ps(1.);
         let a = _mm_set1_ps(2.);
         let r = _mm_mask_mov_ps(src, 0, a);
@@ -45300,7 +45336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_ps() {
+    const fn test_mm_maskz_mov_ps() {
         let a = _mm_set1_ps(2.);
         let r = _mm_maskz_mov_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -45309,7 +45345,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_add_epi32() {
+    const fn test_mm512_add_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45330,7 +45366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_add_epi32() {
+    const fn test_mm512_mask_add_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45353,7 +45389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_add_epi32() {
+    const fn test_mm512_maskz_add_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45376,7 +45412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_add_epi32() {
+    const fn test_mm256_mask_add_epi32() {
         let a = _mm256_set_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_mask_add_epi32(a, 0, a, b);
@@ -45387,7 +45423,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_epi32() {
+    const fn test_mm256_maskz_add_epi32() {
         let a = _mm256_setr_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_add_epi32(0, a, b);
@@ -45398,7 +45434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_add_epi32() {
+    const fn test_mm_mask_add_epi32() {
         let a = _mm_set_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(1);
         let r = _mm_mask_add_epi32(a, 0, a, b);
@@ -45409,7 +45445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_add_epi32() {
+    const fn test_mm_maskz_add_epi32() {
         let a = _mm_setr_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_add_epi32(0, a, b);
@@ -45420,7 +45456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_add_ps() {
+    const fn test_mm512_add_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45441,7 +45477,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_add_ps() {
+    const fn test_mm512_mask_add_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45464,7 +45500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_add_ps() {
+    const fn test_mm512_maskz_add_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45487,7 +45523,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_add_ps() {
+    const fn test_mm256_mask_add_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(1.);
         let r = _mm256_mask_add_ps(a, 0, a, b);
@@ -45498,7 +45534,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_ps() {
+    const fn test_mm256_maskz_add_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(1.);
         let r = _mm256_maskz_add_ps(0, a, b);
@@ -45509,7 +45545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_add_ps() {
+    const fn test_mm_mask_add_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(1.);
         let r = _mm_mask_add_ps(a, 0, a, b);
@@ -45520,7 +45556,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_add_ps() {
+    const fn test_mm_maskz_add_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(1.);
         let r = _mm_maskz_add_ps(0, a, b);
@@ -45531,7 +45567,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sub_epi32() {
+    const fn test_mm512_sub_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45552,7 +45588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sub_epi32() {
+    const fn test_mm512_mask_sub_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45575,7 +45611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sub_epi32() {
+    const fn test_mm512_maskz_sub_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45598,7 +45634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_epi32() {
+    const fn test_mm256_mask_sub_epi32() {
         let a = _mm256_set_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_mask_sub_epi32(a, 0, a, b);
@@ -45609,7 +45645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_epi32() {
+    const fn test_mm256_maskz_sub_epi32() {
         let a = _mm256_set_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_sub_epi32(0, a, b);
@@ -45620,7 +45656,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sub_epi32() {
+    const fn test_mm_mask_sub_epi32() {
         let a = _mm_set_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(1);
         let r = _mm_mask_sub_epi32(a, 0, a, b);
@@ -45631,7 +45667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_epi32() {
+    const fn test_mm_maskz_sub_epi32() {
         let a = _mm_set_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_sub_epi32(0, a, b);
@@ -45642,7 +45678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sub_ps() {
+    const fn test_mm512_sub_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45663,7 +45699,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sub_ps() {
+    const fn test_mm512_mask_sub_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45686,7 +45722,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sub_ps() {
+    const fn test_mm512_maskz_sub_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45709,7 +45745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_ps() {
+    const fn test_mm256_mask_sub_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(1.);
         let r = _mm256_mask_sub_ps(a, 0, a, b);
@@ -45720,7 +45756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_ps() {
+    const fn test_mm256_maskz_sub_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(1.);
         let r = _mm256_maskz_sub_ps(0, a, b);
@@ -45731,7 +45767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sub_ps() {
+    const fn test_mm_mask_sub_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(1.);
         let r = _mm_mask_sub_ps(a, 0, a, b);
@@ -45742,7 +45778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_ps() {
+    const fn test_mm_maskz_sub_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(1.);
         let r = _mm_maskz_sub_ps(0, a, b);
@@ -45753,7 +45789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mullo_epi32() {
+    const fn test_mm512_mullo_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45770,7 +45806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mullo_epi32() {
+    const fn test_mm512_mask_mullo_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45793,7 +45829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mullo_epi32() {
+    const fn test_mm512_maskz_mullo_epi32() {
         #[rustfmt::skip]
         let a = _mm512_setr_epi32(
             0, 1, -1, i32::MAX,
@@ -45810,7 +45846,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mullo_epi32() {
+    const fn test_mm256_mask_mullo_epi32() {
         let a = _mm256_set_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(2);
         let r = _mm256_mask_mullo_epi32(a, 0, a, b);
@@ -45821,7 +45857,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mullo_epi32() {
+    const fn test_mm256_maskz_mullo_epi32() {
         let a = _mm256_set_epi32(0, 1, -1, i32::MAX, i32::MIN, 100, -100, -32);
         let b = _mm256_set1_epi32(2);
         let r = _mm256_maskz_mullo_epi32(0, a, b);
@@ -45832,7 +45868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mullo_epi32() {
+    const fn test_mm_mask_mullo_epi32() {
         let a = _mm_set_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(2);
         let r = _mm_mask_mullo_epi32(a, 0, a, b);
@@ -45843,7 +45879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mullo_epi32() {
+    const fn test_mm_maskz_mullo_epi32() {
         let a = _mm_set_epi32(1, -1, i32::MAX, i32::MIN);
         let b = _mm_set1_epi32(2);
         let r = _mm_maskz_mullo_epi32(0, a, b);
@@ -45854,7 +45890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mul_ps() {
+    const fn test_mm512_mul_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45876,7 +45912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mul_ps() {
+    const fn test_mm512_mask_mul_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45899,7 +45935,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mul_ps() {
+    const fn test_mm512_maskz_mul_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1., -1., f32::MAX,
@@ -45922,7 +45958,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mul_ps() {
+    const fn test_mm256_mask_mul_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(2.);
         let r = _mm256_mask_mul_ps(a, 0, a, b);
@@ -45937,7 +45973,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mul_ps() {
+    const fn test_mm256_maskz_mul_ps() {
         let a = _mm256_set_ps(0., 1., -1., f32::MAX, f32::MIN, 100., -100., -32.);
         let b = _mm256_set1_ps(2.);
         let r = _mm256_maskz_mul_ps(0, a, b);
@@ -45952,7 +45988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mul_ps() {
+    const fn test_mm_mask_mul_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(2.);
         let r = _mm_mask_mul_ps(a, 0, a, b);
@@ -45963,7 +45999,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_ps() {
+    const fn test_mm_maskz_mul_ps() {
         let a = _mm_set_ps(1., -1., f32::MAX, f32::MIN);
         let b = _mm_set1_ps(2.);
         let r = _mm_maskz_mul_ps(0, a, b);
@@ -45974,7 +46010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_div_ps() {
+    const fn test_mm512_div_ps() {
         let a = _mm512_setr_ps(
             0., 1., -1., -2., 100., 100., -100., -32., 0., 1., -1., 1000., -131., 100., -100., -32.,
         );
@@ -45993,7 +46029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_div_ps() {
+    const fn test_mm512_mask_div_ps() {
         let a = _mm512_setr_ps(
             0., 1., -1., -2., 100., 100., -100., -32., 0., 1., -1., 1000., -131., 100., -100., -32.,
         );
@@ -46014,7 +46050,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_div_ps() {
+    const fn test_mm512_maskz_div_ps() {
         let a = _mm512_setr_ps(
             0., 1., -1., -2., 100., 100., -100., -32., 0., 1., -1., 1000., -131., 100., -100., -32.,
         );
@@ -46035,7 +46071,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_div_ps() {
+    const fn test_mm256_mask_div_ps() {
         let a = _mm256_set_ps(0., 1., -1., -2., 100., 100., -100., -32.);
         let b = _mm256_set_ps(2., 2., 2., 2., 2., 0., 2., 2.);
         let r = _mm256_mask_div_ps(a, 0, a, b);
@@ -46046,7 +46082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_div_ps() {
+    const fn test_mm256_maskz_div_ps() {
         let a = _mm256_set_ps(0., 1., -1., -2., 100., 100., -100., -32.);
         let b = _mm256_set_ps(2., 2., 2., 2., 2., 0., 2., 2.);
         let r = _mm256_maskz_div_ps(0, a, b);
@@ -46057,7 +46093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_div_ps() {
+    const fn test_mm_mask_div_ps() {
         let a = _mm_set_ps(100., 100., -100., -32.);
         let b = _mm_set_ps(2., 0., 2., 2.);
         let r = _mm_mask_div_ps(a, 0, a, b);
@@ -46068,7 +46104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_div_ps() {
+    const fn test_mm_maskz_div_ps() {
         let a = _mm_set_ps(100., 100., -100., -32.);
         let b = _mm_set_ps(2., 0., 2., 2.);
         let r = _mm_maskz_div_ps(0, a, b);
@@ -46079,7 +46115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_max_epi32() {
+    const fn test_mm512_max_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_max_epi32(a, b);
@@ -46088,7 +46124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_max_epi32() {
+    const fn test_mm512_mask_max_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_max_epi32(a, 0, a, b);
@@ -46099,7 +46135,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_max_epi32() {
+    const fn test_mm512_maskz_max_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_max_epi32(0, a, b);
@@ -46110,7 +46146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epi32() {
+    const fn test_mm256_mask_max_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_max_epi32(a, 0, a, b);
@@ -46121,7 +46157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epi32() {
+    const fn test_mm256_maskz_max_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_max_epi32(0, a, b);
@@ -46132,7 +46168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_max_epi32() {
+    const fn test_mm_mask_max_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_mask_max_epi32(a, 0, a, b);
@@ -46143,7 +46179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epi32() {
+    const fn test_mm_maskz_max_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_maskz_max_epi32(0, a, b);
@@ -46154,7 +46190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_max_ps() {
+    fn test_mm512_max_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46169,7 +46205,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_max_ps() {
+    fn test_mm512_mask_max_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46186,7 +46222,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_max_ps() {
+    fn test_mm512_maskz_max_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46203,7 +46239,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_max_ps() {
+    fn test_mm256_mask_max_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set_ps(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm256_mask_max_ps(a, 0, a, b);
@@ -46214,7 +46250,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_max_ps() {
+    fn test_mm256_maskz_max_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set_ps(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm256_maskz_max_ps(0, a, b);
@@ -46225,7 +46261,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_max_ps() {
+    fn test_mm_mask_max_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(3., 2., 1., 0.);
         let r = _mm_mask_max_ps(a, 0, a, b);
@@ -46236,7 +46272,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_max_ps() {
+    fn test_mm_maskz_max_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(3., 2., 1., 0.);
         let r = _mm_maskz_max_ps(0, a, b);
@@ -46247,7 +46283,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_max_epu32() {
+    const fn test_mm512_max_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_max_epu32(a, b);
@@ -46256,7 +46292,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_max_epu32() {
+    const fn test_mm512_mask_max_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_max_epu32(a, 0, a, b);
@@ -46267,7 +46303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_max_epu32() {
+    const fn test_mm512_maskz_max_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_max_epu32(0, a, b);
@@ -46278,7 +46314,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epu32() {
+    const fn test_mm256_mask_max_epu32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_max_epu32(a, 0, a, b);
@@ -46289,7 +46325,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epu32() {
+    const fn test_mm256_maskz_max_epu32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_max_epu32(0, a, b);
@@ -46300,7 +46336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_max_epu32() {
+    const fn test_mm_mask_max_epu32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_mask_max_epu32(a, 0, a, b);
@@ -46311,7 +46347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epu32() {
+    const fn test_mm_maskz_max_epu32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_maskz_max_epu32(0, a, b);
@@ -46322,7 +46358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_min_epi32() {
+    const fn test_mm512_min_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_min_epi32(a, b);
@@ -46331,7 +46367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_min_epi32() {
+    const fn test_mm512_mask_min_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_min_epi32(a, 0, a, b);
@@ -46342,7 +46378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_min_epi32() {
+    const fn test_mm512_maskz_min_epi32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_min_epi32(0, a, b);
@@ -46353,7 +46389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epi32() {
+    const fn test_mm256_mask_min_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_min_epi32(a, 0, a, b);
@@ -46364,7 +46400,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epi32() {
+    const fn test_mm256_maskz_min_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_min_epi32(0, a, b);
@@ -46375,7 +46411,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_min_epi32() {
+    const fn test_mm_mask_min_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_mask_min_epi32(a, 0, a, b);
@@ -46386,7 +46422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epi32() {
+    const fn test_mm_maskz_min_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_maskz_min_epi32(0, a, b);
@@ -46397,7 +46433,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_min_ps() {
+    fn test_mm512_min_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46412,7 +46448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_min_ps() {
+    fn test_mm512_mask_min_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46429,7 +46465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_min_ps() {
+    fn test_mm512_maskz_min_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -46446,7 +46482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_min_ps() {
+    fn test_mm256_mask_min_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set_ps(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm256_mask_min_ps(a, 0, a, b);
@@ -46457,7 +46493,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_min_ps() {
+    fn test_mm256_maskz_min_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set_ps(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm256_maskz_min_ps(0, a, b);
@@ -46468,7 +46504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_min_ps() {
+    fn test_mm_mask_min_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(3., 2., 1., 0.);
         let r = _mm_mask_min_ps(a, 0, a, b);
@@ -46479,7 +46515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_min_ps() {
+    fn test_mm_maskz_min_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(3., 2., 1., 0.);
         let r = _mm_maskz_min_ps(0, a, b);
@@ -46490,7 +46526,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_min_epu32() {
+    const fn test_mm512_min_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_min_epu32(a, b);
@@ -46499,7 +46535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_min_epu32() {
+    const fn test_mm512_mask_min_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_min_epu32(a, 0, a, b);
@@ -46510,7 +46546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_min_epu32() {
+    const fn test_mm512_maskz_min_epu32() {
         let a = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm512_setr_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_min_epu32(0, a, b);
@@ -46521,7 +46557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epu32() {
+    const fn test_mm256_mask_min_epu32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_mask_min_epu32(a, 0, a, b);
@@ -46532,7 +46568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epu32() {
+    const fn test_mm256_maskz_min_epu32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm256_maskz_min_epu32(0, a, b);
@@ -46543,7 +46579,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_min_epu32() {
+    const fn test_mm_mask_min_epu32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_mask_min_epu32(a, 0, a, b);
@@ -46554,7 +46590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epu32() {
+    const fn test_mm_maskz_min_epu32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let b = _mm_set_epi32(3, 2, 1, 0);
         let r = _mm_maskz_min_epu32(0, a, b);
@@ -46565,7 +46601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sqrt_ps() {
+    fn test_mm512_sqrt_ps() {
         let a = _mm512_setr_ps(
             0., 1., 4., 9., 16., 25., 36., 49., 64., 81., 100., 121., 144., 169., 196., 225.,
         );
@@ -46577,7 +46613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sqrt_ps() {
+    fn test_mm512_mask_sqrt_ps() {
         let a = _mm512_setr_ps(
             0., 1., 4., 9., 16., 25., 36., 49., 64., 81., 100., 121., 144., 169., 196., 225.,
         );
@@ -46591,7 +46627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sqrt_ps() {
+    fn test_mm512_maskz_sqrt_ps() {
         let a = _mm512_setr_ps(
             0., 1., 4., 9., 16., 25., 36., 49., 64., 81., 100., 121., 144., 169., 196., 225.,
         );
@@ -46605,7 +46641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sqrt_ps() {
+    fn test_mm256_mask_sqrt_ps() {
         let a = _mm256_set_ps(0., 1., 4., 9., 16., 25., 36., 49.);
         let r = _mm256_mask_sqrt_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -46615,7 +46651,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sqrt_ps() {
+    fn test_mm256_maskz_sqrt_ps() {
         let a = _mm256_set_ps(0., 1., 4., 9., 16., 25., 36., 49.);
         let r = _mm256_maskz_sqrt_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -46625,7 +46661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sqrt_ps() {
+    fn test_mm_mask_sqrt_ps() {
         let a = _mm_set_ps(0., 1., 4., 9.);
         let r = _mm_mask_sqrt_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -46635,7 +46671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sqrt_ps() {
+    fn test_mm_maskz_sqrt_ps() {
         let a = _mm_set_ps(0., 1., 4., 9.);
         let r = _mm_maskz_sqrt_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -46645,7 +46681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmadd_ps() {
+    const fn test_mm512_fmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46659,7 +46695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmadd_ps() {
+    const fn test_mm512_mask_fmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46675,7 +46711,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmadd_ps() {
+    const fn test_mm512_maskz_fmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46691,7 +46727,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmadd_ps() {
+    const fn test_mm512_mask3_fmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46707,7 +46743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmadd_ps() {
+    const fn test_mm256_mask_fmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46719,7 +46755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmadd_ps() {
+    const fn test_mm256_maskz_fmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46731,7 +46767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmadd_ps() {
+    const fn test_mm256_mask3_fmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46743,7 +46779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmadd_ps() {
+    const fn test_mm_mask_fmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46755,7 +46791,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmadd_ps() {
+    const fn test_mm_maskz_fmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46767,7 +46803,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmadd_ps() {
+    const fn test_mm_mask3_fmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46779,7 +46815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmsub_ps() {
+    const fn test_mm512_fmsub_ps() {
         let a = _mm512_setr_ps(
             1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         );
@@ -46797,7 +46833,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmsub_ps() {
+    const fn test_mm512_mask_fmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46813,7 +46849,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmsub_ps() {
+    const fn test_mm512_maskz_fmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46829,7 +46865,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmsub_ps() {
+    const fn test_mm512_mask3_fmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46847,7 +46883,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsub_ps() {
+    const fn test_mm256_mask_fmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46859,7 +46895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsub_ps() {
+    const fn test_mm256_maskz_fmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46871,7 +46907,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsub_ps() {
+    const fn test_mm256_mask3_fmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46883,7 +46919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmsub_ps() {
+    const fn test_mm_mask_fmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46895,7 +46931,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsub_ps() {
+    const fn test_mm_maskz_fmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46907,7 +46943,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsub_ps() {
+    const fn test_mm_mask3_fmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -46919,7 +46955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmaddsub_ps() {
+    const fn test_mm512_fmaddsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46933,7 +46969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmaddsub_ps() {
+    const fn test_mm512_mask_fmaddsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46949,7 +46985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmaddsub_ps() {
+    const fn test_mm512_maskz_fmaddsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46965,7 +47001,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmaddsub_ps() {
+    const fn test_mm512_mask3_fmaddsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -46983,7 +47019,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmaddsub_ps() {
+    const fn test_mm256_mask_fmaddsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -46995,7 +47031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmaddsub_ps() {
+    const fn test_mm256_maskz_fmaddsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47007,7 +47043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmaddsub_ps() {
+    const fn test_mm256_mask3_fmaddsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47019,7 +47055,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmaddsub_ps() {
+    const fn test_mm_mask_fmaddsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47031,7 +47067,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmaddsub_ps() {
+    const fn test_mm_maskz_fmaddsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47043,7 +47079,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmaddsub_ps() {
+    const fn test_mm_mask3_fmaddsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47055,7 +47091,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmsubadd_ps() {
+    const fn test_mm512_fmsubadd_ps() {
         let a = _mm512_setr_ps(
             1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         );
@@ -47073,7 +47109,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmsubadd_ps() {
+    const fn test_mm512_mask_fmsubadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47089,7 +47125,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmsubadd_ps() {
+    const fn test_mm512_maskz_fmsubadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47105,7 +47141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmsubadd_ps() {
+    const fn test_mm512_mask3_fmsubadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47123,7 +47159,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsubadd_ps() {
+    const fn test_mm256_mask_fmsubadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47135,7 +47171,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsubadd_ps() {
+    const fn test_mm256_maskz_fmsubadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47147,7 +47183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsubadd_ps() {
+    const fn test_mm256_mask3_fmsubadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47159,7 +47195,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmsubadd_ps() {
+    const fn test_mm_mask_fmsubadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47171,7 +47207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsubadd_ps() {
+    const fn test_mm_maskz_fmsubadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47183,7 +47219,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsubadd_ps() {
+    const fn test_mm_mask3_fmsubadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47195,7 +47231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fnmadd_ps() {
+    const fn test_mm512_fnmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47209,7 +47245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fnmadd_ps() {
+    const fn test_mm512_mask_fnmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47225,7 +47261,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fnmadd_ps() {
+    const fn test_mm512_maskz_fnmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47241,7 +47277,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fnmadd_ps() {
+    const fn test_mm512_mask3_fnmadd_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47259,7 +47295,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmadd_ps() {
+    const fn test_mm256_mask_fnmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47271,7 +47307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmadd_ps() {
+    const fn test_mm256_maskz_fnmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47283,7 +47319,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmadd_ps() {
+    const fn test_mm256_mask3_fnmadd_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47295,7 +47331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fnmadd_ps() {
+    const fn test_mm_mask_fnmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47307,7 +47343,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmadd_ps() {
+    const fn test_mm_maskz_fnmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47319,7 +47355,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmadd_ps() {
+    const fn test_mm_mask3_fnmadd_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47331,7 +47367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fnmsub_ps() {
+    const fn test_mm512_fnmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47345,7 +47381,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fnmsub_ps() {
+    const fn test_mm512_mask_fnmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47361,7 +47397,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fnmsub_ps() {
+    const fn test_mm512_maskz_fnmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47377,7 +47413,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fnmsub_ps() {
+    const fn test_mm512_mask3_fnmsub_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -47395,7 +47431,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmsub_ps() {
+    const fn test_mm256_mask_fnmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47407,7 +47443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmsub_ps() {
+    const fn test_mm256_maskz_fnmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47419,7 +47455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmsub_ps() {
+    const fn test_mm256_mask3_fnmsub_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm256_set1_ps(1.);
@@ -47431,7 +47467,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fnmsub_ps() {
+    const fn test_mm_mask_fnmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47443,7 +47479,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmsub_ps() {
+    const fn test_mm_maskz_fnmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47455,7 +47491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmsub_ps() {
+    const fn test_mm_mask3_fnmsub_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set_ps(0., 1., 2., 3.);
         let c = _mm_set1_ps(1.);
@@ -47467,7 +47503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_rcp14_ps() {
+    fn test_mm512_rcp14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_rcp14_ps(a);
         let e = _mm512_set1_ps(0.33333206);
@@ -47475,7 +47511,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_rcp14_ps() {
+    fn test_mm512_mask_rcp14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_mask_rcp14_ps(a, 0, a);
         assert_eq_m512(r, a);
@@ -47488,7 +47524,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_rcp14_ps() {
+    fn test_mm512_maskz_rcp14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_maskz_rcp14_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -47501,7 +47537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_rcp14_ps() {
+    fn test_mm256_rcp14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_rcp14_ps(a);
         let e = _mm256_set1_ps(0.33333206);
@@ -47509,7 +47545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_rcp14_ps() {
+    fn test_mm256_mask_rcp14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_mask_rcp14_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -47519,7 +47555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_rcp14_ps() {
+    fn test_mm256_maskz_rcp14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_maskz_rcp14_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -47529,7 +47565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_rcp14_ps() {
+    fn test_mm_rcp14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_rcp14_ps(a);
         let e = _mm_set1_ps(0.33333206);
@@ -47537,7 +47573,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_rcp14_ps() {
+    fn test_mm_mask_rcp14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_mask_rcp14_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -47547,7 +47583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_rcp14_ps() {
+    fn test_mm_maskz_rcp14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_maskz_rcp14_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -47557,7 +47593,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_rsqrt14_ps() {
+    fn test_mm512_rsqrt14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_rsqrt14_ps(a);
         let e = _mm512_set1_ps(0.5773392);
@@ -47565,7 +47601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_rsqrt14_ps() {
+    fn test_mm512_mask_rsqrt14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_mask_rsqrt14_ps(a, 0, a);
         assert_eq_m512(r, a);
@@ -47578,7 +47614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_rsqrt14_ps() {
+    fn test_mm512_maskz_rsqrt14_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_maskz_rsqrt14_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -47591,7 +47627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_rsqrt14_ps() {
+    fn test_mm256_rsqrt14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_rsqrt14_ps(a);
         let e = _mm256_set1_ps(0.5773392);
@@ -47599,7 +47635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_rsqrt14_ps() {
+    fn test_mm256_mask_rsqrt14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_mask_rsqrt14_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -47609,7 +47645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_rsqrt14_ps() {
+    fn test_mm256_maskz_rsqrt14_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_maskz_rsqrt14_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -47619,7 +47655,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_rsqrt14_ps() {
+    fn test_mm_rsqrt14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_rsqrt14_ps(a);
         let e = _mm_set1_ps(0.5773392);
@@ -47627,7 +47663,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_rsqrt14_ps() {
+    fn test_mm_mask_rsqrt14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_mask_rsqrt14_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -47637,7 +47673,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_rsqrt14_ps() {
+    fn test_mm_maskz_rsqrt14_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_maskz_rsqrt14_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -47647,7 +47683,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getexp_ps() {
+    fn test_mm512_getexp_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_getexp_ps(a);
         let e = _mm512_set1_ps(1.);
@@ -47655,7 +47691,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getexp_ps() {
+    fn test_mm512_mask_getexp_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_mask_getexp_ps(a, 0, a);
         assert_eq_m512(r, a);
@@ -47667,7 +47703,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getexp_ps() {
+    fn test_mm512_maskz_getexp_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_maskz_getexp_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -47679,7 +47715,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_getexp_ps() {
+    fn test_mm256_getexp_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_getexp_ps(a);
         let e = _mm256_set1_ps(1.);
@@ -47687,7 +47723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_getexp_ps() {
+    fn test_mm256_mask_getexp_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_mask_getexp_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -47697,7 +47733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_getexp_ps() {
+    fn test_mm256_maskz_getexp_ps() {
         let a = _mm256_set1_ps(3.);
         let r = _mm256_maskz_getexp_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -47707,7 +47743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_getexp_ps() {
+    fn test_mm_getexp_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_getexp_ps(a);
         let e = _mm_set1_ps(1.);
@@ -47715,7 +47751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_getexp_ps() {
+    fn test_mm_mask_getexp_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_mask_getexp_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -47725,7 +47761,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_getexp_ps() {
+    fn test_mm_maskz_getexp_ps() {
         let a = _mm_set1_ps(3.);
         let r = _mm_maskz_getexp_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -47735,7 +47771,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_roundscale_ps() {
+    fn test_mm512_roundscale_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_roundscale_ps::<0b00_00_00_00>(a);
         let e = _mm512_set1_ps(1.0);
@@ -47743,7 +47779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_roundscale_ps() {
+    fn test_mm512_mask_roundscale_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_mask_roundscale_ps::<0b00_00_00_00>(a, 0, a);
         let e = _mm512_set1_ps(1.1);
@@ -47754,7 +47790,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_roundscale_ps() {
+    fn test_mm512_maskz_roundscale_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_maskz_roundscale_ps::<0b00_00_00_00>(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -47764,7 +47800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_roundscale_ps() {
+    fn test_mm256_roundscale_ps() {
         let a = _mm256_set1_ps(1.1);
         let r = _mm256_roundscale_ps::<0b00_00_00_00>(a);
         let e = _mm256_set1_ps(1.0);
@@ -47772,7 +47808,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_roundscale_ps() {
+    fn test_mm256_mask_roundscale_ps() {
         let a = _mm256_set1_ps(1.1);
         let r = _mm256_mask_roundscale_ps::<0b00_00_00_00>(a, 0, a);
         let e = _mm256_set1_ps(1.1);
@@ -47783,7 +47819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_roundscale_ps() {
+    fn test_mm256_maskz_roundscale_ps() {
         let a = _mm256_set1_ps(1.1);
         let r = _mm256_maskz_roundscale_ps::<0b00_00_00_00>(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -47793,7 +47829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_roundscale_ps() {
+    fn test_mm_roundscale_ps() {
         let a = _mm_set1_ps(1.1);
         let r = _mm_roundscale_ps::<0b00_00_00_00>(a);
         let e = _mm_set1_ps(1.0);
@@ -47801,7 +47837,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_roundscale_ps() {
+    fn test_mm_mask_roundscale_ps() {
         let a = _mm_set1_ps(1.1);
         let r = _mm_mask_roundscale_ps::<0b00_00_00_00>(a, 0, a);
         let e = _mm_set1_ps(1.1);
@@ -47812,7 +47848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_roundscale_ps() {
+    fn test_mm_maskz_roundscale_ps() {
         let a = _mm_set1_ps(1.1);
         let r = _mm_maskz_roundscale_ps::<0b00_00_00_00>(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -47822,7 +47858,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_scalef_ps() {
+    fn test_mm512_scalef_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_scalef_ps(a, b);
@@ -47831,7 +47867,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_scalef_ps() {
+    fn test_mm512_mask_scalef_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_mask_scalef_ps(a, 0, a, b);
@@ -47844,7 +47880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_scalef_ps() {
+    fn test_mm512_maskz_scalef_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_maskz_scalef_ps(0, a, b);
@@ -47857,7 +47893,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_scalef_ps() {
+    fn test_mm256_scalef_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(3.);
         let r = _mm256_scalef_ps(a, b);
@@ -47866,7 +47902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_scalef_ps() {
+    fn test_mm256_mask_scalef_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(3.);
         let r = _mm256_mask_scalef_ps(a, 0, a, b);
@@ -47877,7 +47913,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_scalef_ps() {
+    fn test_mm256_maskz_scalef_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(3.);
         let r = _mm256_maskz_scalef_ps(0, a, b);
@@ -47888,7 +47924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_scalef_ps() {
+    fn test_mm_scalef_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_scalef_ps(a, b);
@@ -47897,7 +47933,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_scalef_ps() {
+    fn test_mm_mask_scalef_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_mask_scalef_ps(a, 0, a, b);
@@ -47908,7 +47944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_scalef_ps() {
+    fn test_mm_maskz_scalef_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_maskz_scalef_ps(0, a, b);
@@ -47919,7 +47955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fixupimm_ps() {
+    fn test_mm512_fixupimm_ps() {
         let a = _mm512_set1_ps(f32::NAN);
         let b = _mm512_set1_ps(f32::MAX);
         let c = _mm512_set1_epi32(i32::MAX);
@@ -47930,7 +47966,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fixupimm_ps() {
+    fn test_mm512_mask_fixupimm_ps() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(
             f32::NAN, f32::NAN, f32::NAN, f32::NAN,
@@ -47948,7 +47984,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fixupimm_ps() {
+    fn test_mm512_maskz_fixupimm_ps() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(
             f32::NAN, f32::NAN, f32::NAN, f32::NAN,
@@ -47966,7 +48002,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_fixupimm_ps() {
+    fn test_mm256_fixupimm_ps() {
         let a = _mm256_set1_ps(f32::NAN);
         let b = _mm256_set1_ps(f32::MAX);
         let c = _mm256_set1_epi32(i32::MAX);
@@ -47976,7 +48012,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_fixupimm_ps() {
+    fn test_mm256_mask_fixupimm_ps() {
         let a = _mm256_set1_ps(f32::NAN);
         let b = _mm256_set1_ps(f32::MAX);
         let c = _mm256_set1_epi32(i32::MAX);
@@ -47986,7 +48022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_fixupimm_ps() {
+    fn test_mm256_maskz_fixupimm_ps() {
         let a = _mm256_set1_ps(f32::NAN);
         let b = _mm256_set1_ps(f32::MAX);
         let c = _mm256_set1_epi32(i32::MAX);
@@ -47996,7 +48032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_fixupimm_ps() {
+    fn test_mm_fixupimm_ps() {
         let a = _mm_set1_ps(f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -48006,7 +48042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_fixupimm_ps() {
+    fn test_mm_mask_fixupimm_ps() {
         let a = _mm_set1_ps(f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -48016,7 +48052,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_fixupimm_ps() {
+    fn test_mm_maskz_fixupimm_ps() {
         let a = _mm_set1_ps(f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -48050,7 +48086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_ternarylogic_epi32() {
+    fn test_mm512_mask_ternarylogic_epi32() {
         let src = _mm512_set1_epi32(1 << 2);
         let a = _mm512_set1_epi32(1 << 1);
         let b = _mm512_set1_epi32(1 << 0);
@@ -48062,7 +48098,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_ternarylogic_epi32() {
+    fn test_mm512_maskz_ternarylogic_epi32() {
         let a = _mm512_set1_epi32(1 << 2);
         let b = _mm512_set1_epi32(1 << 1);
         let c = _mm512_set1_epi32(1 << 0);
@@ -48100,7 +48136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_ternarylogic_epi32() {
+    fn test_mm256_mask_ternarylogic_epi32() {
         let src = _mm256_set1_epi32(1 << 2);
         let a = _mm256_set1_epi32(1 << 1);
         let b = _mm256_set1_epi32(1 << 0);
@@ -48112,7 +48148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_ternarylogic_epi32() {
+    fn test_mm256_maskz_ternarylogic_epi32() {
         let a = _mm256_set1_epi32(1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let c = _mm256_set1_epi32(1 << 0);
@@ -48148,7 +48184,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_ternarylogic_epi32() {
+    fn test_mm_mask_ternarylogic_epi32() {
         let src = _mm_set1_epi32(1 << 2);
         let a = _mm_set1_epi32(1 << 1);
         let b = _mm_set1_epi32(1 << 0);
@@ -48160,7 +48196,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_ternarylogic_epi32() {
+    fn test_mm_maskz_ternarylogic_epi32() {
         let a = _mm_set1_epi32(1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let c = _mm_set1_epi32(1 << 0);
@@ -48172,7 +48208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getmant_ps() {
+    fn test_mm512_getmant_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_getmant_ps::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm512_set1_ps(1.25);
@@ -48180,7 +48216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getmant_ps() {
+    fn test_mm512_mask_getmant_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_mask_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m512(r, a);
@@ -48196,7 +48232,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getmant_ps() {
+    fn test_mm512_maskz_getmant_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_maskz_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -48209,7 +48245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_getmant_ps() {
+    fn test_mm256_getmant_ps() {
         let a = _mm256_set1_ps(10.);
         let r = _mm256_getmant_ps::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm256_set1_ps(1.25);
@@ -48217,7 +48253,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_getmant_ps() {
+    fn test_mm256_mask_getmant_ps() {
         let a = _mm256_set1_ps(10.);
         let r = _mm256_mask_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m256(r, a);
@@ -48227,7 +48263,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_getmant_ps() {
+    fn test_mm256_maskz_getmant_ps() {
         let a = _mm256_set1_ps(10.);
         let r = _mm256_maskz_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -48237,7 +48273,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_getmant_ps() {
+    fn test_mm_getmant_ps() {
         let a = _mm_set1_ps(10.);
         let r = _mm_getmant_ps::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm_set1_ps(1.25);
@@ -48245,7 +48281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_getmant_ps() {
+    fn test_mm_mask_getmant_ps() {
         let a = _mm_set1_ps(10.);
         let r = _mm_mask_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m128(r, a);
@@ -48255,7 +48291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_getmant_ps() {
+    fn test_mm_maskz_getmant_ps() {
         let a = _mm_set1_ps(10.);
         let r = _mm_maskz_getmant_ps::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -48265,7 +48301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_add_round_ps() {
+    fn test_mm512_add_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48287,7 +48323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_add_round_ps() {
+    fn test_mm512_mask_add_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48311,7 +48347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_add_round_ps() {
+    fn test_mm512_maskz_add_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48334,7 +48370,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sub_round_ps() {
+    fn test_mm512_sub_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48356,7 +48392,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sub_round_ps() {
+    fn test_mm512_mask_sub_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48382,7 +48418,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sub_round_ps() {
+    fn test_mm512_maskz_sub_round_ps() {
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 0.00000007,
         );
@@ -48406,7 +48442,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mul_round_ps() {
+    fn test_mm512_mul_round_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5,
@@ -48436,7 +48472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_mul_round_ps() {
+    fn test_mm512_mask_mul_round_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5,
@@ -48466,7 +48502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_mul_round_ps() {
+    fn test_mm512_maskz_mul_round_ps() {
         #[rustfmt::skip]
         let a = _mm512_setr_ps(
             0., 1.5, 2., 3.5,
@@ -48494,7 +48530,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_div_round_ps() {
+    fn test_mm512_div_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_div_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -48506,7 +48542,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_div_round_ps() {
+    fn test_mm512_mask_div_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_mask_div_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -48527,7 +48563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_div_round_ps() {
+    fn test_mm512_maskz_div_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r =
@@ -48546,7 +48582,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sqrt_round_ps() {
+    fn test_mm512_sqrt_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_sqrt_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set1_ps(1.7320508);
@@ -48557,7 +48593,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sqrt_round_ps() {
+    fn test_mm512_mask_sqrt_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r =
             _mm512_mask_sqrt_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 0, a);
@@ -48575,7 +48611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sqrt_round_ps() {
+    fn test_mm512_maskz_sqrt_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r =
             _mm512_maskz_sqrt_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(0, a);
@@ -48592,7 +48628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmadd_round_ps() {
+    fn test_mm512_fmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48605,7 +48641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmadd_round_ps() {
+    fn test_mm512_mask_fmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48630,7 +48666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmadd_round_ps() {
+    fn test_mm512_maskz_fmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48656,7 +48692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmadd_round_ps() {
+    fn test_mm512_mask3_fmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48681,7 +48717,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmsub_round_ps() {
+    fn test_mm512_fmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -48694,7 +48730,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmsub_round_ps() {
+    fn test_mm512_mask_fmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -48719,7 +48755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmsub_round_ps() {
+    fn test_mm512_maskz_fmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -48744,7 +48780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmsub_round_ps() {
+    fn test_mm512_mask3_fmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -48769,7 +48805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmaddsub_round_ps() {
+    fn test_mm512_fmaddsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48792,7 +48828,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmaddsub_round_ps() {
+    fn test_mm512_mask_fmaddsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48817,7 +48853,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmaddsub_round_ps() {
+    fn test_mm512_maskz_fmaddsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48842,7 +48878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmaddsub_round_ps() {
+    fn test_mm512_mask3_fmaddsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48867,7 +48903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmsubadd_round_ps() {
+    fn test_mm512_fmsubadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48890,7 +48926,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmsubadd_round_ps() {
+    fn test_mm512_mask_fmsubadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48915,7 +48951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmsubadd_round_ps() {
+    fn test_mm512_maskz_fmsubadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48940,7 +48976,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmsubadd_round_ps() {
+    fn test_mm512_mask3_fmsubadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -48965,7 +49001,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fnmadd_round_ps() {
+    fn test_mm512_fnmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -48979,7 +49015,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fnmadd_round_ps() {
+    fn test_mm512_mask_fnmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -49002,7 +49038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fnmadd_round_ps() {
+    fn test_mm512_maskz_fnmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -49024,7 +49060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fnmadd_round_ps() {
+    fn test_mm512_mask3_fnmadd_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(1.);
@@ -49046,7 +49082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fnmsub_round_ps() {
+    fn test_mm512_fnmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -49060,7 +49096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fnmsub_round_ps() {
+    fn test_mm512_mask_fnmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -49083,7 +49119,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fnmsub_round_ps() {
+    fn test_mm512_maskz_fnmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -49105,7 +49141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fnmsub_round_ps() {
+    fn test_mm512_mask3_fnmsub_round_ps() {
         let a = _mm512_set1_ps(0.00000007);
         let b = _mm512_set1_ps(1.);
         let c = _mm512_set1_ps(-1.);
@@ -49127,7 +49163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_max_round_ps() {
+    fn test_mm512_max_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49142,7 +49178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_max_round_ps() {
+    fn test_mm512_mask_max_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49159,7 +49195,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_max_round_ps() {
+    fn test_mm512_maskz_max_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49176,7 +49212,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_min_round_ps() {
+    fn test_mm512_min_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49191,7 +49227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_min_round_ps() {
+    fn test_mm512_mask_min_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49208,7 +49244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_min_round_ps() {
+    fn test_mm512_maskz_min_round_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -49225,7 +49261,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getexp_round_ps() {
+    fn test_mm512_getexp_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_getexp_round_ps::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm512_set1_ps(1.);
@@ -49233,7 +49269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getexp_round_ps() {
+    fn test_mm512_mask_getexp_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_mask_getexp_round_ps::<_MM_FROUND_CUR_DIRECTION>(a, 0, a);
         assert_eq_m512(r, a);
@@ -49245,7 +49281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getexp_round_ps() {
+    fn test_mm512_maskz_getexp_round_ps() {
         let a = _mm512_set1_ps(3.);
         let r = _mm512_maskz_getexp_round_ps::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -49257,7 +49293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_roundscale_round_ps() {
+    fn test_mm512_roundscale_round_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_roundscale_round_ps::<0, _MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm512_set1_ps(1.0);
@@ -49265,7 +49301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_roundscale_round_ps() {
+    fn test_mm512_mask_roundscale_round_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_mask_roundscale_round_ps::<0, _MM_FROUND_CUR_DIRECTION>(a, 0, a);
         let e = _mm512_set1_ps(1.1);
@@ -49280,7 +49316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_roundscale_round_ps() {
+    fn test_mm512_maskz_roundscale_round_ps() {
         let a = _mm512_set1_ps(1.1);
         let r = _mm512_maskz_roundscale_round_ps::<0, _MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -49291,7 +49327,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_scalef_round_ps() {
+    fn test_mm512_scalef_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_scalef_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -49300,7 +49336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_scalef_round_ps() {
+    fn test_mm512_mask_scalef_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_mask_scalef_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -49320,7 +49356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_scalef_round_ps() {
+    fn test_mm512_maskz_scalef_round_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(3.);
         let r = _mm512_maskz_scalef_round_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -49339,7 +49375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fixupimm_round_ps() {
+    fn test_mm512_fixupimm_round_ps() {
         let a = _mm512_set1_ps(f32::NAN);
         let b = _mm512_set1_ps(f32::MAX);
         let c = _mm512_set1_epi32(i32::MAX);
@@ -49349,7 +49385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fixupimm_round_ps() {
+    fn test_mm512_mask_fixupimm_round_ps() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(
             f32::NAN, f32::NAN, f32::NAN, f32::NAN,
@@ -49372,7 +49408,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fixupimm_round_ps() {
+    fn test_mm512_maskz_fixupimm_round_ps() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(
             f32::NAN, f32::NAN, f32::NAN, f32::NAN,
@@ -49395,7 +49431,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getmant_round_ps() {
+    fn test_mm512_getmant_round_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_getmant_round_ps::<
             _MM_MANT_NORM_1_2,
@@ -49407,7 +49443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getmant_round_ps() {
+    fn test_mm512_mask_getmant_round_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_mask_getmant_round_ps::<
             _MM_MANT_NORM_1_2,
@@ -49427,7 +49463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getmant_round_ps() {
+    fn test_mm512_maskz_getmant_round_ps() {
         let a = _mm512_set1_ps(10.);
         let r = _mm512_maskz_getmant_round_ps::<
             _MM_MANT_NORM_1_2,
@@ -49447,7 +49483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtps_epi32() {
+    fn test_mm512_cvtps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49457,7 +49493,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtps_epi32() {
+    fn test_mm512_mask_cvtps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49470,7 +49506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtps_epi32() {
+    fn test_mm512_maskz_cvtps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49482,7 +49518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtps_epi32() {
+    fn test_mm256_mask_cvtps_epi32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm256_mask_cvtps_epi32(src, 0, a);
@@ -49493,7 +49529,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtps_epi32() {
+    fn test_mm256_maskz_cvtps_epi32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_maskz_cvtps_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49503,7 +49539,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtps_epi32() {
+    fn test_mm_mask_cvtps_epi32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtps_epi32(src, 0, a);
@@ -49514,7 +49550,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtps_epi32() {
+    fn test_mm_maskz_cvtps_epi32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_maskz_cvtps_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49524,7 +49560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtps_epu32() {
+    fn test_mm512_cvtps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49534,7 +49570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtps_epu32() {
+    fn test_mm512_mask_cvtps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49547,7 +49583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtps_epu32() {
+    fn test_mm512_maskz_cvtps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.4, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -49559,7 +49595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtps_epu32() {
+    fn test_mm256_cvtps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_cvtps_epu32(a);
         let e = _mm256_set_epi32(8, 10, 10, 12, 12, 14, 14, 16);
@@ -49567,7 +49603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtps_epu32() {
+    fn test_mm256_mask_cvtps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm256_mask_cvtps_epu32(src, 0, a);
@@ -49578,7 +49614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtps_epu32() {
+    fn test_mm256_maskz_cvtps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_maskz_cvtps_epu32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49588,7 +49624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtps_epu32() {
+    fn test_mm_cvtps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_cvtps_epu32(a);
         let e = _mm_set_epi32(12, 14, 14, 16);
@@ -49596,7 +49632,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtps_epu32() {
+    fn test_mm_mask_cvtps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtps_epu32(src, 0, a);
@@ -49607,7 +49643,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtps_epu32() {
+    fn test_mm_maskz_cvtps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_maskz_cvtps_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49617,7 +49653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi8_epi32() {
+    const fn test_mm512_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi8_epi32(a);
         let e = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -49625,7 +49661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi8_epi32() {
+    const fn test_mm512_mask_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi32(-1);
         let r = _mm512_mask_cvtepi8_epi32(src, 0, a);
@@ -49636,7 +49672,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi8_epi32() {
+    const fn test_mm512_maskz_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi8_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -49646,7 +49682,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi8_epi32() {
+    const fn test_mm256_mask_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi32(-1);
         let r = _mm256_mask_cvtepi8_epi32(src, 0, a);
@@ -49657,7 +49693,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi8_epi32() {
+    const fn test_mm256_maskz_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi8_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49667,7 +49703,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi8_epi32() {
+    const fn test_mm_mask_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi32(-1);
         let r = _mm_mask_cvtepi8_epi32(src, 0, a);
@@ -49678,7 +49714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi8_epi32() {
+    const fn test_mm_maskz_cvtepi8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepi8_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49688,7 +49724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu8_epi32() {
+    const fn test_mm512_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu8_epi32(a);
         let e = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -49696,7 +49732,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu8_epi32() {
+    const fn test_mm512_mask_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi32(-1);
         let r = _mm512_mask_cvtepu8_epi32(src, 0, a);
@@ -49707,7 +49743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu8_epi32() {
+    const fn test_mm512_maskz_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu8_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -49717,7 +49753,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu8_epi32() {
+    const fn test_mm256_mask_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi32(-1);
         let r = _mm256_mask_cvtepu8_epi32(src, 0, a);
@@ -49728,7 +49764,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu8_epi32() {
+    const fn test_mm256_maskz_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu8_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49738,7 +49774,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu8_epi32() {
+    const fn test_mm_mask_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi32(-1);
         let r = _mm_mask_cvtepu8_epi32(src, 0, a);
@@ -49749,7 +49785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu8_epi32() {
+    const fn test_mm_maskz_cvtepu8_epi32() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepu8_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49759,7 +49795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi16_epi32() {
+    const fn test_mm512_cvtepi16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi16_epi32(a);
         let e = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -49767,7 +49803,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi16_epi32() {
+    const fn test_mm512_mask_cvtepi16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi32(-1);
         let r = _mm512_mask_cvtepi16_epi32(src, 0, a);
@@ -49778,7 +49814,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi16_epi32() {
+    const fn test_mm512_maskz_cvtepi16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi16_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -49788,7 +49824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi16_epi32() {
+    const fn test_mm256_mask_cvtepi16_epi32() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let src = _mm256_set1_epi32(-1);
         let r = _mm256_mask_cvtepi16_epi32(src, 0, a);
@@ -49799,7 +49835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi16_epi32() {
+    const fn test_mm256_maskz_cvtepi16_epi32() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_cvtepi16_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49809,7 +49845,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi16_epi32() {
+    const fn test_mm_mask_cvtepi16_epi32() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let src = _mm_set1_epi32(-1);
         let r = _mm_mask_cvtepi16_epi32(src, 0, a);
@@ -49820,7 +49856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi16_epi32() {
+    const fn test_mm_maskz_cvtepi16_epi32() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_cvtepi16_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49830,7 +49866,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu16_epi32() {
+    const fn test_mm512_cvtepu16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu16_epi32(a);
         let e = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -49838,7 +49874,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu16_epi32() {
+    const fn test_mm512_mask_cvtepu16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi32(-1);
         let r = _mm512_mask_cvtepu16_epi32(src, 0, a);
@@ -49849,7 +49885,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu16_epi32() {
+    const fn test_mm512_maskz_cvtepu16_epi32() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu16_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -49859,7 +49895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu16_epi32() {
+    const fn test_mm256_mask_cvtepu16_epi32() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi32(-1);
         let r = _mm256_mask_cvtepu16_epi32(src, 0, a);
@@ -49870,7 +49906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu16_epi32() {
+    const fn test_mm256_maskz_cvtepu16_epi32() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu16_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -49880,7 +49916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu16_epi32() {
+    const fn test_mm_mask_cvtepu16_epi32() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi32(-1);
         let r = _mm_mask_cvtepu16_epi32(src, 0, a);
@@ -49891,7 +49927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu16_epi32() {
+    const fn test_mm_maskz_cvtepu16_epi32() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepu16_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -49901,7 +49937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32_ps() {
+    const fn test_mm512_cvtepi32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32_ps(a);
         let e = _mm512_set_ps(
@@ -49911,7 +49947,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32_ps() {
+    const fn test_mm512_mask_cvtepi32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_ps(-1.);
         let r = _mm512_mask_cvtepi32_ps(src, 0, a);
@@ -49924,7 +49960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi32_ps() {
+    const fn test_mm512_maskz_cvtepi32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi32_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -49936,7 +49972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi32_ps() {
+    const fn test_mm256_mask_cvtepi32_ps() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm256_set1_ps(-1.);
         let r = _mm256_mask_cvtepi32_ps(src, 0, a);
@@ -49947,7 +49983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi32_ps() {
+    const fn test_mm256_maskz_cvtepi32_ps() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_cvtepi32_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -49957,7 +49993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi32_ps() {
+    const fn test_mm_mask_cvtepi32_ps() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let src = _mm_set1_ps(-1.);
         let r = _mm_mask_cvtepi32_ps(src, 0, a);
@@ -49968,7 +50004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi32_ps() {
+    const fn test_mm_maskz_cvtepi32_ps() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_cvtepi32_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -49978,7 +50014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu32_ps() {
+    const fn test_mm512_cvtepu32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu32_ps(a);
         let e = _mm512_set_ps(
@@ -49988,7 +50024,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu32_ps() {
+    const fn test_mm512_mask_cvtepu32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_ps(-1.);
         let r = _mm512_mask_cvtepu32_ps(src, 0, a);
@@ -50001,7 +50037,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu32_ps() {
+    const fn test_mm512_maskz_cvtepu32_ps() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu32_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -50013,7 +50049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32_epi16() {
+    const fn test_mm512_cvtepi32_epi16() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32_epi16(a);
         let e = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -50021,7 +50057,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32_epi16() {
+    const fn test_mm512_mask_cvtepi32_epi16() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi16(-1);
         let r = _mm512_mask_cvtepi32_epi16(src, 0, a);
@@ -50032,7 +50068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi32_epi16() {
+    const fn test_mm512_maskz_cvtepi32_epi16() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi32_epi16(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -50042,7 +50078,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cvtepi32_epi16() {
+    const fn test_mm256_cvtepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_cvtepi32_epi16(a);
         let e = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
@@ -50050,7 +50086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi32_epi16() {
+    const fn test_mm256_mask_cvtepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let src = _mm_set1_epi16(-1);
         let r = _mm256_mask_cvtepi32_epi16(src, 0, a);
@@ -50061,7 +50097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi32_epi16() {
+    const fn test_mm256_maskz_cvtepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_cvtepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50071,7 +50107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtepi32_epi16() {
+    fn test_mm_cvtepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_cvtepi32_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 4, 5, 6, 7);
@@ -50079,7 +50115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi32_epi16() {
+    fn test_mm_mask_cvtepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtepi32_epi16(src, 0, a);
@@ -50090,7 +50126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi32_epi16() {
+    fn test_mm_maskz_cvtepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_maskz_cvtepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50100,7 +50136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32_epi8() {
+    const fn test_mm512_cvtepi32_epi8() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32_epi8(a);
         let e = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -50108,7 +50144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32_epi8() {
+    const fn test_mm512_mask_cvtepi32_epi8() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi8(-1);
         let r = _mm512_mask_cvtepi32_epi8(src, 0, a);
@@ -50119,7 +50155,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi32_epi8() {
+    const fn test_mm512_maskz_cvtepi32_epi8() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50129,7 +50165,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtepi32_epi8() {
+    fn test_mm256_cvtepi32_epi8() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_cvtepi32_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7);
@@ -50137,7 +50173,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi32_epi8() {
+    fn test_mm256_mask_cvtepi32_epi8() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtepi32_epi8(src, 0, a);
@@ -50148,7 +50184,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi32_epi8() {
+    fn test_mm256_maskz_cvtepi32_epi8() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_cvtepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50158,7 +50194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtepi32_epi8() {
+    fn test_mm_cvtepi32_epi8() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_cvtepi32_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7);
@@ -50166,7 +50202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi32_epi8() {
+    fn test_mm_mask_cvtepi32_epi8() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtepi32_epi8(src, 0, a);
@@ -50177,7 +50213,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi32_epi8() {
+    fn test_mm_maskz_cvtepi32_epi8() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_maskz_cvtepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50187,7 +50223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtsepi32_epi16() {
+    fn test_mm512_cvtsepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50207,7 +50243,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtsepi32_epi16() {
+    fn test_mm512_mask_cvtsepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50230,7 +50266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtsepi32_epi16() {
+    fn test_mm512_maskz_cvtsepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50252,7 +50288,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtsepi32_epi16() {
+    fn test_mm256_cvtsepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_cvtsepi32_epi16(a);
         let e = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
@@ -50260,7 +50296,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi32_epi16() {
+    fn test_mm256_mask_cvtsepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let src = _mm_set1_epi16(-1);
         let r = _mm256_mask_cvtsepi32_epi16(src, 0, a);
@@ -50271,7 +50307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi32_epi16() {
+    fn test_mm256_maskz_cvtsepi32_epi16() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_cvtsepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50281,7 +50317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtsepi32_epi16() {
+    fn test_mm_cvtsepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_cvtsepi32_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 4, 5, 6, 7);
@@ -50289,7 +50325,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi32_epi16() {
+    fn test_mm_mask_cvtsepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtsepi32_epi16(src, 0, a);
@@ -50300,7 +50336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi32_epi16() {
+    fn test_mm_maskz_cvtsepi32_epi16() {
         let a = _mm_set_epi32(4, 5, 6, 7);
         let r = _mm_maskz_cvtsepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50310,7 +50346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtsepi32_epi8() {
+    fn test_mm512_cvtsepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50330,7 +50366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtsepi32_epi8() {
+    fn test_mm512_mask_cvtsepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50353,7 +50389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtsepi32_epi8() {
+    fn test_mm512_maskz_cvtsepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50375,7 +50411,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtsepi32_epi8() {
+    fn test_mm256_cvtsepi32_epi8() {
         let a = _mm256_set_epi32(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_cvtsepi32_epi8(a);
         #[rustfmt::skip]
@@ -50389,7 +50425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi32_epi8() {
+    fn test_mm256_mask_cvtsepi32_epi8() {
         let a = _mm256_set_epi32(9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtsepi32_epi8(src, 0, a);
@@ -50406,7 +50442,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi32_epi8() {
+    fn test_mm256_maskz_cvtsepi32_epi8() {
         let a = _mm256_set_epi32(9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_maskz_cvtsepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50422,7 +50458,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtsepi32_epi8() {
+    fn test_mm_cvtsepi32_epi8() {
         let a = _mm_set_epi32(13, 14, 15, 16);
         let r = _mm_cvtsepi32_epi8(a);
         #[rustfmt::skip]
@@ -50436,7 +50472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi32_epi8() {
+    fn test_mm_mask_cvtsepi32_epi8() {
         let a = _mm_set_epi32(13, 14, 15, 16);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtsepi32_epi8(src, 0, a);
@@ -50453,7 +50489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi32_epi8() {
+    fn test_mm_maskz_cvtsepi32_epi8() {
         let a = _mm_set_epi32(13, 14, 15, 16);
         let r = _mm_maskz_cvtsepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50469,7 +50505,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtusepi32_epi16() {
+    fn test_mm512_cvtusepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50483,7 +50519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtusepi32_epi16() {
+    fn test_mm512_mask_cvtusepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50500,7 +50536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtusepi32_epi16() {
+    fn test_mm512_maskz_cvtusepi32_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50516,7 +50552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtusepi32_epi16() {
+    fn test_mm256_cvtusepi32_epi16() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_cvtusepi32_epi16(a);
         let e = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
@@ -50524,7 +50560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi32_epi16() {
+    fn test_mm256_mask_cvtusepi32_epi16() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvtusepi32_epi16(src, 0, a);
@@ -50535,7 +50571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi32_epi16() {
+    fn test_mm256_maskz_cvtusepi32_epi16() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_cvtusepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50545,7 +50581,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtusepi32_epi16() {
+    fn test_mm_cvtusepi32_epi16() {
         let a = _mm_set_epi32(5, 6, 7, 8);
         let r = _mm_cvtusepi32_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 5, 6, 7, 8);
@@ -50553,7 +50589,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi32_epi16() {
+    fn test_mm_mask_cvtusepi32_epi16() {
         let a = _mm_set_epi32(5, 6, 7, 8);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtusepi32_epi16(src, 0, a);
@@ -50564,7 +50600,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi32_epi16() {
+    fn test_mm_maskz_cvtusepi32_epi16() {
         let a = _mm_set_epi32(5, 6, 7, 8);
         let r = _mm_maskz_cvtusepi32_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50574,7 +50610,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtusepi32_epi8() {
+    fn test_mm512_cvtusepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50588,7 +50624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtusepi32_epi8() {
+    fn test_mm512_mask_cvtusepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50605,7 +50641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtusepi32_epi8() {
+    fn test_mm512_maskz_cvtusepi32_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             0, 1, 2, 3,
@@ -50621,7 +50657,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtusepi32_epi8() {
+    fn test_mm256_cvtusepi32_epi8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, i32::MAX);
         let r = _mm256_cvtusepi32_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, u8::MAX as i8);
@@ -50629,7 +50665,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi32_epi8() {
+    fn test_mm256_mask_cvtusepi32_epi8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, i32::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtusepi32_epi8(src, 0, a);
@@ -50640,7 +50676,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi32_epi8() {
+    fn test_mm256_maskz_cvtusepi32_epi8() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, i32::MAX);
         let r = _mm256_maskz_cvtusepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50650,7 +50686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtusepi32_epi8() {
+    fn test_mm_cvtusepi32_epi8() {
         let a = _mm_set_epi32(5, 6, 7, i32::MAX);
         let r = _mm_cvtusepi32_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, u8::MAX as i8);
@@ -50658,7 +50694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi32_epi8() {
+    fn test_mm_mask_cvtusepi32_epi8() {
         let a = _mm_set_epi32(5, 6, 7, i32::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtusepi32_epi8(src, 0, a);
@@ -50669,7 +50705,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi32_epi8() {
+    fn test_mm_maskz_cvtusepi32_epi8() {
         let a = _mm_set_epi32(5, 6, 7, i32::MAX);
         let r = _mm_maskz_cvtusepi32_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50679,7 +50715,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundps_epi32() {
+    fn test_mm512_cvt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50692,7 +50728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundps_epi32() {
+    fn test_mm512_mask_cvt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50711,7 +50747,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundps_epi32() {
+    fn test_mm512_maskz_cvt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50728,7 +50764,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundps_epu32() {
+    fn test_mm512_cvt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50741,7 +50777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundps_epu32() {
+    fn test_mm512_mask_cvt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50760,7 +50796,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundps_epu32() {
+    fn test_mm512_maskz_cvt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -50777,7 +50813,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundepi32_ps() {
+    fn test_mm512_cvt_roundepi32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let r = _mm512_cvt_roundepi32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_setr_ps(
@@ -50787,7 +50823,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundepi32_ps() {
+    fn test_mm512_mask_cvt_roundepi32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let src = _mm512_set1_ps(0.);
         let r = _mm512_mask_cvt_roundepi32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -50806,7 +50842,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundepi32_ps() {
+    fn test_mm512_maskz_cvt_roundepi32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let r = _mm512_maskz_cvt_roundepi32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0, a,
@@ -50823,7 +50859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundepu32_ps() {
+    fn test_mm512_cvt_roundepu32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let r = _mm512_cvt_roundepu32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         #[rustfmt::skip]
@@ -50837,7 +50873,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundepu32_ps() {
+    fn test_mm512_mask_cvt_roundepu32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let src = _mm512_set1_ps(0.);
         let r = _mm512_mask_cvt_roundepu32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -50860,7 +50896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundepu32_ps() {
+    fn test_mm512_maskz_cvt_roundepu32_ps() {
         let a = _mm512_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8, 8, 10, 10, 12, 12, 14, 14, 16);
         let r = _mm512_maskz_cvt_roundepu32_ps::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0, a,
@@ -50881,7 +50917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundps_ph() {
+    fn test_mm512_cvt_roundps_ph() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(a);
         let e = _mm256_setr_epi64x(
@@ -50894,7 +50930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundps_ph() {
+    fn test_mm512_mask_cvt_roundps_ph() {
         let a = _mm512_set1_ps(1.);
         let src = _mm256_set1_epi16(0);
         let r = _mm512_mask_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -50905,7 +50941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundps_ph() {
+    fn test_mm512_maskz_cvt_roundps_ph() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_maskz_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -50915,7 +50951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvt_roundps_ph() {
+    fn test_mm256_mask_cvt_roundps_ph() {
         let a = _mm256_set1_ps(1.);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -50926,7 +50962,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvt_roundps_ph() {
+    fn test_mm256_maskz_cvt_roundps_ph() {
         let a = _mm256_set1_ps(1.);
         let r = _mm256_maskz_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50936,7 +50972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvt_roundps_ph() {
+    fn test_mm_mask_cvt_roundps_ph() {
         let a = _mm_set1_ps(1.);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -50947,7 +50983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvt_roundps_ph() {
+    fn test_mm_maskz_cvt_roundps_ph() {
         let a = _mm_set1_ps(1.);
         let r = _mm_maskz_cvt_roundps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -50957,7 +50993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtps_ph() {
+    fn test_mm512_cvtps_ph() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_cvtps_ph::<_MM_FROUND_NO_EXC>(a);
         let e = _mm256_setr_epi64x(
@@ -50970,7 +51006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtps_ph() {
+    fn test_mm512_mask_cvtps_ph() {
         let a = _mm512_set1_ps(1.);
         let src = _mm256_set1_epi16(0);
         let r = _mm512_mask_cvtps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -50981,7 +51017,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtps_ph() {
+    fn test_mm512_maskz_cvtps_ph() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_maskz_cvtps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -50991,7 +51027,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtps_ph() {
+    fn test_mm256_mask_cvtps_ph() {
         let a = _mm256_set1_ps(1.);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvtps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -51002,7 +51038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtps_ph() {
+    fn test_mm256_maskz_cvtps_ph() {
         let a = _mm256_set1_ps(1.);
         let r = _mm256_maskz_cvtps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -51012,7 +51048,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtps_ph() {
+    fn test_mm_mask_cvtps_ph() {
         let a = _mm_set1_ps(1.);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtps_ph::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -51023,7 +51059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtps_ph() {
+    fn test_mm_maskz_cvtps_ph() {
         let a = _mm_set1_ps(1.);
         let r = _mm_maskz_cvtps_ph::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -51033,7 +51069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundph_ps() {
+    fn test_mm512_cvt_roundph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51046,7 +51082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundph_ps() {
+    fn test_mm512_mask_cvt_roundph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51064,7 +51100,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundph_ps() {
+    fn test_mm512_maskz_cvt_roundph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51081,7 +51117,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtph_ps() {
+    fn test_mm512_cvtph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51094,7 +51130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtph_ps() {
+    fn test_mm512_mask_cvtph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51112,7 +51148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtph_ps() {
+    fn test_mm512_maskz_cvtph_ps() {
         let a = _mm256_setr_epi64x(
             4323521613979991040,
             4323521613979991040,
@@ -51129,7 +51165,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_ps() {
+    fn test_mm256_mask_cvtph_ps() {
         let a = _mm_setr_epi64x(4323521613979991040, 4323521613979991040);
         let src = _mm256_set1_ps(0.);
         let r = _mm256_mask_cvtph_ps(src, 0, a);
@@ -51140,7 +51176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_ps() {
+    fn test_mm256_maskz_cvtph_ps() {
         let a = _mm_setr_epi64x(4323521613979991040, 4323521613979991040);
         let r = _mm256_maskz_cvtph_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -51150,7 +51186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_ps() {
+    fn test_mm_mask_cvtph_ps() {
         let a = _mm_setr_epi64x(4323521613979991040, 4323521613979991040);
         let src = _mm_set1_ps(0.);
         let r = _mm_mask_cvtph_ps(src, 0, a);
@@ -51161,7 +51197,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_ps() {
+    fn test_mm_maskz_cvtph_ps() {
         let a = _mm_setr_epi64x(4323521613979991040, 4323521613979991040);
         let r = _mm_maskz_cvtph_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -51171,7 +51207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtt_roundps_epi32() {
+    fn test_mm512_cvtt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51181,7 +51217,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtt_roundps_epi32() {
+    fn test_mm512_mask_cvtt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51194,7 +51230,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtt_roundps_epi32() {
+    fn test_mm512_maskz_cvtt_roundps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51206,7 +51242,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtt_roundps_epu32() {
+    fn test_mm512_cvtt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51216,7 +51252,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtt_roundps_epu32() {
+    fn test_mm512_mask_cvtt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51229,7 +51265,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtt_roundps_epu32() {
+    fn test_mm512_maskz_cvtt_roundps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51241,7 +51277,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvttps_epi32() {
+    fn test_mm512_cvttps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51251,7 +51287,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvttps_epi32() {
+    fn test_mm512_mask_cvttps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51264,7 +51300,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvttps_epi32() {
+    fn test_mm512_maskz_cvttps_epi32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51276,7 +51312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvttps_epi32() {
+    fn test_mm256_mask_cvttps_epi32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm256_mask_cvttps_epi32(src, 0, a);
@@ -51287,7 +51323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttps_epi32() {
+    fn test_mm256_maskz_cvttps_epi32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_maskz_cvttps_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -51297,7 +51333,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvttps_epi32() {
+    fn test_mm_mask_cvttps_epi32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvttps_epi32(src, 0, a);
@@ -51308,7 +51344,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvttps_epi32() {
+    fn test_mm_maskz_cvttps_epi32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_maskz_cvttps_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -51318,7 +51354,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvttps_epu32() {
+    fn test_mm512_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51328,7 +51364,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvttps_epu32() {
+    fn test_mm512_mask_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51341,7 +51377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvttps_epu32() {
+    fn test_mm512_maskz_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
         );
@@ -51353,7 +51389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvttps_epu32() {
+    fn test_mm256_cvttps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_cvttps_epu32(a);
         let e = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
@@ -51361,7 +51397,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvttps_epu32() {
+    fn test_mm256_mask_cvttps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm256_mask_cvttps_epu32(src, 0, a);
@@ -51372,7 +51408,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttps_epu32() {
+    fn test_mm256_maskz_cvttps_epu32() {
         let a = _mm256_set_ps(8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5);
         let r = _mm256_maskz_cvttps_epu32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -51382,7 +51418,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvttps_epu32() {
+    fn test_mm_cvttps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_cvttps_epu32(a);
         let e = _mm_set_epi32(12, 13, 14, 15);
@@ -51390,7 +51426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvttps_epu32() {
+    fn test_mm_mask_cvttps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvttps_epu32(src, 0, a);
@@ -51401,7 +51437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvttps_epu32() {
+    fn test_mm_maskz_cvttps_epu32() {
         let a = _mm_set_ps(12., 13.5, 14., 15.5);
         let r = _mm_maskz_cvttps_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -51539,7 +51575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmplt_ps_mask() {
+    fn test_mm512_cmplt_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51549,7 +51585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmplt_ps_mask() {
+    fn test_mm512_mask_cmplt_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51560,7 +51596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpnlt_ps_mask() {
+    fn test_mm512_cmpnlt_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51569,7 +51605,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpnlt_ps_mask() {
+    fn test_mm512_mask_cmpnlt_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51579,7 +51615,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpnle_ps_mask() {
+    fn test_mm512_cmpnle_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51589,7 +51625,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpnle_ps_mask() {
+    fn test_mm512_mask_cmpnle_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51600,7 +51636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmple_ps_mask() {
+    fn test_mm512_cmple_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51609,7 +51645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmple_ps_mask() {
+    fn test_mm512_mask_cmple_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.,
                               0., 1., -1., f32::MAX, f32::NAN, f32::MIN, 100., -100.);
@@ -51619,7 +51655,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpeq_ps_mask() {
+    fn test_mm512_cmpeq_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.);
@@ -51631,7 +51667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpeq_ps_mask() {
+    fn test_mm512_mask_cmpeq_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.);
@@ -51644,7 +51680,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpneq_ps_mask() {
+    fn test_mm512_cmpneq_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.);
@@ -51656,7 +51692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpneq_ps_mask() {
+    fn test_mm512_mask_cmpneq_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, f32::NAN, -100.);
@@ -51669,7 +51705,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmp_ps_mask() {
+    fn test_mm512_cmp_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
@@ -51679,7 +51715,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmp_ps_mask() {
+    fn test_mm512_mask_cmp_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
@@ -51690,7 +51726,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cmp_ps_mask() {
+    fn test_mm256_cmp_ps_mask() {
         let a = _mm256_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
         let b = _mm256_set1_ps(-1.);
         let m = _mm256_cmp_ps_mask::<_CMP_LT_OQ>(a, b);
@@ -51698,7 +51734,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cmp_ps_mask() {
+    fn test_mm256_mask_cmp_ps_mask() {
         let a = _mm256_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
         let b = _mm256_set1_ps(-1.);
         let mask = 0b01100110;
@@ -51707,7 +51743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cmp_ps_mask() {
+    fn test_mm_cmp_ps_mask() {
         let a = _mm_set_ps(0., 1., -1., 13.);
         let b = _mm_set1_ps(1.);
         let m = _mm_cmp_ps_mask::<_CMP_LT_OQ>(a, b);
@@ -51715,7 +51751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cmp_ps_mask() {
+    fn test_mm_mask_cmp_ps_mask() {
         let a = _mm_set_ps(0., 1., -1., 13.);
         let b = _mm_set1_ps(1.);
         let mask = 0b11111111;
@@ -51724,7 +51760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmp_round_ps_mask() {
+    fn test_mm512_cmp_round_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
@@ -51734,7 +51770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmp_round_ps_mask() {
+    fn test_mm512_mask_cmp_round_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.,
                               0., 1., -1., 13., f32::MAX, f32::MIN, 100., -100.);
@@ -51745,7 +51781,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpord_ps_mask() {
+    fn test_mm512_cmpord_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, -1., f32::NAN, 0.,
                               f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, 1., f32::NAN, 2.);
@@ -51757,7 +51793,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpord_ps_mask() {
+    fn test_mm512_mask_cmpord_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, -1., f32::NAN, 0.,
                               f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, 1., f32::NAN, 2.);
@@ -51770,7 +51806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpunord_ps_mask() {
+    fn test_mm512_cmpunord_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, -1., f32::NAN, 0.,
                               f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, 1., f32::NAN, 2.);
@@ -51783,7 +51819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpunord_ps_mask() {
+    fn test_mm512_mask_cmpunord_ps_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_ps(f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, -1., f32::NAN, 0.,
                               f32::NAN, f32::MAX, f32::NAN, f32::MIN, f32::NAN, 1., f32::NAN, 2.);
@@ -51796,7 +51832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cmp_ss_mask() {
+    fn test_mm_cmp_ss_mask() {
         let a = _mm_setr_ps(2., 1., 1., 1.);
         let b = _mm_setr_ps(1., 2., 2., 2.);
         let m = _mm_cmp_ss_mask::<_CMP_GE_OS>(a, b);
@@ -51804,7 +51840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cmp_ss_mask() {
+    fn test_mm_mask_cmp_ss_mask() {
         let a = _mm_setr_ps(2., 1., 1., 1.);
         let b = _mm_setr_ps(1., 2., 2., 2.);
         let m = _mm_mask_cmp_ss_mask::<_CMP_GE_OS>(0b10, a, b);
@@ -51814,7 +51850,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cmp_round_ss_mask() {
+    fn test_mm_cmp_round_ss_mask() {
         let a = _mm_setr_ps(2., 1., 1., 1.);
         let b = _mm_setr_ps(1., 2., 2., 2.);
         let m = _mm_cmp_round_ss_mask::<_CMP_GE_OS, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -51822,7 +51858,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cmp_round_ss_mask() {
+    fn test_mm_mask_cmp_round_ss_mask() {
         let a = _mm_setr_ps(2., 1., 1., 1.);
         let b = _mm_setr_ps(1., 2., 2., 2.);
         let m = _mm_mask_cmp_round_ss_mask::<_CMP_GE_OS, _MM_FROUND_CUR_DIRECTION>(0b10, a, b);
@@ -51832,7 +51868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cmp_sd_mask() {
+    fn test_mm_cmp_sd_mask() {
         let a = _mm_setr_pd(2., 1.);
         let b = _mm_setr_pd(1., 2.);
         let m = _mm_cmp_sd_mask::<_CMP_GE_OS>(a, b);
@@ -51840,7 +51876,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cmp_sd_mask() {
+    fn test_mm_mask_cmp_sd_mask() {
         let a = _mm_setr_pd(2., 1.);
         let b = _mm_setr_pd(1., 2.);
         let m = _mm_mask_cmp_sd_mask::<_CMP_GE_OS>(0b10, a, b);
@@ -51850,7 +51886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cmp_round_sd_mask() {
+    fn test_mm_cmp_round_sd_mask() {
         let a = _mm_setr_pd(2., 1.);
         let b = _mm_setr_pd(1., 2.);
         let m = _mm_cmp_round_sd_mask::<_CMP_GE_OS, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -51858,7 +51894,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cmp_round_sd_mask() {
+    fn test_mm_mask_cmp_round_sd_mask() {
         let a = _mm_setr_pd(2., 1.);
         let b = _mm_setr_pd(1., 2.);
         let m = _mm_mask_cmp_round_sd_mask::<_CMP_GE_OS, _MM_FROUND_CUR_DIRECTION>(0b10, a, b);
@@ -51868,7 +51904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmplt_epu32_mask() {
+    const fn test_mm512_cmplt_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -51878,7 +51914,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmplt_epu32_mask() {
+    const fn test_mm512_mask_cmplt_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -51889,7 +51925,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epu32_mask() {
+    const fn test_mm256_cmplt_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 101, 100, 99);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_cmplt_epu32_mask(a, b);
@@ -51897,7 +51933,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epu32_mask() {
+    const fn test_mm256_mask_cmplt_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 101, 100, 99);
         let b = _mm256_set1_epi32(1);
         let mask = 0b11111111;
@@ -51906,7 +51942,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmplt_epu32_mask() {
+    const fn test_mm_cmplt_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let r = _mm_cmplt_epu32_mask(a, b);
@@ -51914,7 +51950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epu32_mask() {
+    const fn test_mm_mask_cmplt_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -51923,7 +51959,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpgt_epu32_mask() {
+    const fn test_mm512_cmpgt_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -51933,7 +51969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpgt_epu32_mask() {
+    const fn test_mm512_mask_cmpgt_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -51944,7 +51980,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epu32_mask() {
+    const fn test_mm256_cmpgt_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 99, 100, 101);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_cmpgt_epu32_mask(a, b);
@@ -51952,7 +51988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epu32_mask() {
+    const fn test_mm256_mask_cmpgt_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 99, 100, 101);
         let b = _mm256_set1_epi32(1);
         let mask = 0b11111111;
@@ -51961,7 +51997,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epu32_mask() {
+    const fn test_mm_cmpgt_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let r = _mm_cmpgt_epu32_mask(a, b);
@@ -51969,7 +52005,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epu32_mask() {
+    const fn test_mm_mask_cmpgt_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -51978,7 +52014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmple_epu32_mask() {
+    const fn test_mm512_cmple_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -51990,7 +52026,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmple_epu32_mask() {
+    const fn test_mm512_mask_cmple_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52003,7 +52039,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmple_epu32_mask() {
+    const fn test_mm256_cmple_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 200, 100, 101);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_cmple_epu32_mask(a, b);
@@ -52011,7 +52047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epu32_mask() {
+    const fn test_mm256_mask_cmple_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 200, 100, 101);
         let b = _mm256_set1_epi32(1);
         let mask = 0b11111111;
@@ -52020,7 +52056,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmple_epu32_mask() {
+    const fn test_mm_cmple_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let r = _mm_cmple_epu32_mask(a, b);
@@ -52028,7 +52064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epu32_mask() {
+    const fn test_mm_mask_cmple_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -52037,7 +52073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpge_epu32_mask() {
+    const fn test_mm512_cmpge_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52049,7 +52085,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpge_epu32_mask() {
+    const fn test_mm512_mask_cmpge_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52059,7 +52095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epu32_mask() {
+    const fn test_mm256_cmpge_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 300, 100, 200);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_cmpge_epu32_mask(a, b);
@@ -52067,7 +52103,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epu32_mask() {
+    const fn test_mm256_mask_cmpge_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, 2, u32::MAX as i32, i32::MAX, 300, 100, 200);
         let b = _mm256_set1_epi32(1);
         let mask = 0b11111111;
@@ -52076,7 +52112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpge_epu32_mask() {
+    const fn test_mm_cmpge_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let r = _mm_cmpge_epu32_mask(a, b);
@@ -52084,7 +52120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epu32_mask() {
+    const fn test_mm_mask_cmpge_epu32_mask() {
         let a = _mm_set_epi32(0, 1, 2, u32::MAX as i32);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -52093,7 +52129,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpeq_epu32_mask() {
+    const fn test_mm512_cmpeq_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52105,7 +52141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpeq_epu32_mask() {
+    const fn test_mm512_mask_cmpeq_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52118,7 +52154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epu32_mask() {
+    const fn test_mm256_cmpeq_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let m = _mm256_cmpeq_epu32_mask(b, a);
@@ -52126,7 +52162,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epu32_mask() {
+    const fn test_mm256_mask_cmpeq_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let mask = 0b01111010;
@@ -52135,7 +52171,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epu32_mask() {
+    const fn test_mm_cmpeq_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let m = _mm_cmpeq_epu32_mask(b, a);
@@ -52143,7 +52179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epu32_mask() {
+    const fn test_mm_mask_cmpeq_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -52152,7 +52188,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpneq_epu32_mask() {
+    const fn test_mm512_cmpneq_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52164,7 +52200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpneq_epu32_mask() {
+    const fn test_mm512_mask_cmpneq_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, -100, 100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, -100, 100);
@@ -52177,7 +52213,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epu32_mask() {
+    const fn test_mm256_cmpneq_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, -100, 100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, -100, 100);
         let r = _mm256_cmpneq_epu32_mask(b, a);
@@ -52185,7 +52221,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epu32_mask() {
+    const fn test_mm256_mask_cmpneq_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, -100, 100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, -100, 100);
         let mask = 0b11111111;
@@ -52194,7 +52230,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epu32_mask() {
+    const fn test_mm_cmpneq_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let r = _mm_cmpneq_epu32_mask(b, a);
@@ -52202,7 +52238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epu32_mask() {
+    const fn test_mm_mask_cmpneq_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -52211,7 +52247,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmp_epu32_mask() {
+    const fn test_mm512_cmp_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52221,7 +52257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmp_epu32_mask() {
+    const fn test_mm512_mask_cmp_epu32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52232,7 +52268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmp_epu32_mask() {
+    const fn test_mm256_cmp_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let m = _mm256_cmp_epu32_mask::<_MM_CMPINT_LT>(a, b);
@@ -52240,7 +52276,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epu32_mask() {
+    const fn test_mm256_mask_cmp_epu32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52249,7 +52285,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmp_epu32_mask() {
+    const fn test_mm_cmp_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, i32::MAX);
         let b = _mm_set1_epi32(1);
         let m = _mm_cmp_epu32_mask::<_MM_CMPINT_LT>(a, b);
@@ -52257,7 +52293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epu32_mask() {
+    const fn test_mm_mask_cmp_epu32_mask() {
         let a = _mm_set_epi32(0, 1, -1, i32::MAX);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -52266,7 +52302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmplt_epi32_mask() {
+    const fn test_mm512_cmplt_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52276,7 +52312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmplt_epi32_mask() {
+    const fn test_mm512_mask_cmplt_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52287,7 +52323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epi32_mask() {
+    const fn test_mm256_cmplt_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 101, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let r = _mm256_cmplt_epi32_mask(a, b);
@@ -52295,7 +52331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epi32_mask() {
+    const fn test_mm256_mask_cmplt_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 101, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52304,7 +52340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmplt_epi32_mask() {
+    const fn test_mm_cmplt_epi32_mask() {
         let a = _mm_set_epi32(i32::MAX, i32::MIN, 100, -100);
         let b = _mm_set1_epi32(-1);
         let r = _mm_cmplt_epi32_mask(a, b);
@@ -52312,7 +52348,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epi32_mask() {
+    const fn test_mm_mask_cmplt_epi32_mask() {
         let a = _mm_set_epi32(i32::MAX, i32::MIN, 100, -100);
         let b = _mm_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52321,7 +52357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpgt_epi32_mask() {
+    const fn test_mm512_cmpgt_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52331,7 +52367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpgt_epi32_mask() {
+    const fn test_mm512_mask_cmpgt_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52342,7 +52378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epi32_mask() {
+    const fn test_mm256_cmpgt_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let r = _mm256_cmpgt_epi32_mask(a, b);
@@ -52350,7 +52386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epi32_mask() {
+    const fn test_mm256_mask_cmpgt_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52359,7 +52395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epi32_mask() {
+    const fn test_mm_cmpgt_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set1_epi32(-1);
         let r = _mm_cmpgt_epi32_mask(a, b);
@@ -52367,7 +52403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epi32_mask() {
+    const fn test_mm_mask_cmpgt_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52376,7 +52412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmple_epi32_mask() {
+    const fn test_mm512_cmple_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52388,7 +52424,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmple_epi32_mask() {
+    const fn test_mm512_mask_cmple_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52398,7 +52434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmple_epi32_mask() {
+    const fn test_mm256_cmple_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 200, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let r = _mm256_cmple_epi32_mask(a, b);
@@ -52406,7 +52442,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epi32_mask() {
+    const fn test_mm256_mask_cmple_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 200, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52415,7 +52451,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmple_epi32_mask() {
+    const fn test_mm_cmple_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 200);
         let b = _mm_set1_epi32(-1);
         let r = _mm_cmple_epi32_mask(a, b);
@@ -52423,7 +52459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epi32_mask() {
+    const fn test_mm_mask_cmple_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 200);
         let b = _mm_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52432,7 +52468,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpge_epi32_mask() {
+    const fn test_mm512_cmpge_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52444,7 +52480,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpge_epi32_mask() {
+    const fn test_mm512_mask_cmpge_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
@@ -52457,7 +52493,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epi32_mask() {
+    const fn test_mm256_cmpge_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let r = _mm256_cmpge_epi32_mask(a, b);
@@ -52465,7 +52501,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epi32_mask() {
+    const fn test_mm256_mask_cmpge_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, u32::MAX as i32, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52474,7 +52510,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpge_epi32_mask() {
+    const fn test_mm_cmpge_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set1_epi32(-1);
         let r = _mm_cmpge_epi32_mask(a, b);
@@ -52482,7 +52518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epi32_mask() {
+    const fn test_mm_mask_cmpge_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, u32::MAX as i32);
         let b = _mm_set1_epi32(-1);
         let mask = 0b11111111;
@@ -52491,7 +52527,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpeq_epi32_mask() {
+    const fn test_mm512_cmpeq_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52503,7 +52539,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpeq_epi32_mask() {
+    const fn test_mm512_mask_cmpeq_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52516,7 +52552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epi32_mask() {
+    const fn test_mm256_cmpeq_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let m = _mm256_cmpeq_epi32_mask(b, a);
@@ -52524,7 +52560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epi32_mask() {
+    const fn test_mm256_mask_cmpeq_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let mask = 0b01111010;
@@ -52533,7 +52569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epi32_mask() {
+    const fn test_mm_cmpeq_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let m = _mm_cmpeq_epi32_mask(b, a);
@@ -52541,7 +52577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epi32_mask() {
+    const fn test_mm_mask_cmpeq_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -52550,7 +52586,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpneq_epi32_mask() {
+    const fn test_mm512_cmpneq_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52562,7 +52598,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpneq_epi32_mask() {
+    const fn test_mm512_mask_cmpneq_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, -100, 100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, -100, 100);
@@ -52575,7 +52611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epi32_mask() {
+    const fn test_mm256_cmpneq_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let m = _mm256_cmpneq_epi32_mask(b, a);
@@ -52583,7 +52619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epi32_mask() {
+    const fn test_mm256_mask_cmpneq_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, -100, 100);
         let b = _mm256_set_epi32(0, 1, 13, 42, i32::MAX, i32::MIN, 100, -100);
         let mask = 0b11111111;
@@ -52592,7 +52628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epi32_mask() {
+    const fn test_mm_cmpneq_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let r = _mm_cmpneq_epi32_mask(b, a);
@@ -52600,7 +52636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epi32_mask() {
+    const fn test_mm_mask_cmpneq_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set_epi32(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -52609,7 +52645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmp_epi32_mask() {
+    const fn test_mm512_cmp_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52619,7 +52655,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmp_epi32_mask() {
+    const fn test_mm512_mask_cmp_epi32_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100,
                                  0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
@@ -52630,7 +52666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmp_epi32_mask() {
+    const fn test_mm256_cmp_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let m = _mm256_cmp_epi32_mask::<_MM_CMPINT_LT>(a, b);
@@ -52638,7 +52674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epi32_mask() {
+    const fn test_mm256_mask_cmp_epi32_mask() {
         let a = _mm256_set_epi32(0, 1, -1, 13, i32::MAX, i32::MIN, 100, -100);
         let b = _mm256_set1_epi32(-1);
         let mask = 0b01100110;
@@ -52647,7 +52683,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmp_epi32_mask() {
+    const fn test_mm_cmp_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set1_epi32(1);
         let m = _mm_cmp_epi32_mask::<_MM_CMPINT_LT>(a, b);
@@ -52655,7 +52691,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epi32_mask() {
+    const fn test_mm_mask_cmp_epi32_mask() {
         let a = _mm_set_epi32(0, 1, -1, 13);
         let b = _mm_set1_epi32(1);
         let mask = 0b11111111;
@@ -52664,7 +52700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_epi8() {
+    const fn test_mm512_set_epi8() {
         let r = _mm512_set1_epi8(2);
         assert_eq_m512i(
             r,
@@ -52677,7 +52713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_epi16() {
+    const fn test_mm512_set_epi16() {
         let r = _mm512_set1_epi16(2);
         assert_eq_m512i(
             r,
@@ -52689,7 +52725,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_epi32() {
+    const fn test_mm512_set_epi32() {
         let r = _mm512_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         assert_eq_m512i(
             r,
@@ -52698,7 +52734,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr_epi32() {
+    const fn test_mm512_setr_epi32() {
         let r = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         assert_eq_m512i(
             r,
@@ -52707,7 +52743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_epi8() {
+    const fn test_mm512_set1_epi8() {
         let r = _mm512_set_epi8(
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -52717,7 +52753,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_epi16() {
+    const fn test_mm512_set1_epi16() {
         let r = _mm512_set_epi16(
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2,
@@ -52726,23 +52762,23 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_epi32() {
+    const fn test_mm512_set1_epi32() {
         let r = _mm512_set_epi32(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         assert_eq_m512i(r, _mm512_set1_epi32(2));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setzero_si512() {
+    const fn test_mm512_setzero_si512() {
         assert_eq_m512i(_mm512_set1_epi32(0), _mm512_setzero_si512());
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setzero_epi32() {
+    const fn test_mm512_setzero_epi32() {
         assert_eq_m512i(_mm512_set1_epi32(0), _mm512_setzero_epi32());
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_ps() {
+    const fn test_mm512_set_ps() {
         let r = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -52755,7 +52791,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr_ps() {
+    const fn test_mm512_setr_ps() {
         let r = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -52768,7 +52804,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_ps() {
+    const fn test_mm512_set1_ps() {
         #[rustfmt::skip]
         let expected = _mm512_set_ps(2., 2., 2., 2., 2., 2., 2., 2.,
                                      2., 2., 2., 2., 2., 2., 2., 2.);
@@ -52776,13 +52812,13 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set4_epi32() {
+    const fn test_mm512_set4_epi32() {
         let r = _mm512_set_epi32(4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1);
         assert_eq_m512i(r, _mm512_set4_epi32(4, 3, 2, 1));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set4_ps() {
+    const fn test_mm512_set4_ps() {
         let r = _mm512_set_ps(
             4., 3., 2., 1., 4., 3., 2., 1., 4., 3., 2., 1., 4., 3., 2., 1.,
         );
@@ -52790,13 +52826,13 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr4_epi32() {
+    const fn test_mm512_setr4_epi32() {
         let r = _mm512_set_epi32(4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1);
         assert_eq_m512i(r, _mm512_setr4_epi32(1, 2, 3, 4));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr4_ps() {
+    const fn test_mm512_setr4_ps() {
         let r = _mm512_set_ps(
             4., 3., 2., 1., 4., 3., 2., 1., 4., 3., 2., 1., 4., 3., 2., 1.,
         );
@@ -52804,12 +52840,12 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setzero_ps() {
+    const fn test_mm512_setzero_ps() {
         assert_eq_m512(_mm512_setzero_ps(), _mm512_set1_ps(0.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setzero() {
+    const fn test_mm512_setzero() {
         assert_eq_m512(_mm512_setzero(), _mm512_set1_ps(0.));
     }
 
@@ -53899,19 +53935,19 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr_pd() {
+    const fn test_mm512_setr_pd() {
         let r = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         assert_eq_m512d(r, _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_pd() {
+    const fn test_mm512_set_pd() {
         let r = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         assert_eq_m512d(r, _mm512_set_pd(7., 6., 5., 4., 3., 2., 1., 0.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rol_epi32() {
+    const fn test_mm512_rol_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_rol_epi32::<1>(a);
         let e = _mm512_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
@@ -53919,7 +53955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rol_epi32() {
+    const fn test_mm512_mask_rol_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_mask_rol_epi32::<1>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -53929,7 +53965,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rol_epi32() {
+    const fn test_mm512_maskz_rol_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 << 31);
         let r = _mm512_maskz_rol_epi32::<1>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -53939,7 +53975,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rol_epi32() {
+    const fn test_mm256_rol_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm256_rol_epi32::<1>(a);
         let e = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
@@ -53947,7 +53983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rol_epi32() {
+    const fn test_mm256_mask_rol_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm256_mask_rol_epi32::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -53957,7 +53993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rol_epi32() {
+    const fn test_mm256_maskz_rol_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm256_maskz_rol_epi32::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -53967,7 +54003,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rol_epi32() {
+    const fn test_mm_rol_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let r = _mm_rol_epi32::<1>(a);
         let e = _mm_set_epi32(1 << 0, 2, 2, 2);
@@ -53975,7 +54011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rol_epi32() {
+    const fn test_mm_mask_rol_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let r = _mm_mask_rol_epi32::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -53985,7 +54021,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rol_epi32() {
+    const fn test_mm_maskz_rol_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let r = _mm_maskz_rol_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -53995,7 +54031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_ror_epi32() {
+    const fn test_mm512_ror_epi32() {
         let a = _mm512_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm512_ror_epi32::<1>(a);
         let e = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
@@ -54003,7 +54039,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_ror_epi32() {
+    const fn test_mm512_mask_ror_epi32() {
         let a = _mm512_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm512_mask_ror_epi32::<1>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -54013,7 +54049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_ror_epi32() {
+    const fn test_mm512_maskz_ror_epi32() {
         let a = _mm512_set_epi32(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 << 0);
         let r = _mm512_maskz_ror_epi32::<1>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -54023,7 +54059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_ror_epi32() {
+    const fn test_mm256_ror_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm256_ror_epi32::<1>(a);
         let e = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
@@ -54031,7 +54067,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_ror_epi32() {
+    const fn test_mm256_mask_ror_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm256_mask_ror_epi32::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -54041,7 +54077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_ror_epi32() {
+    const fn test_mm256_maskz_ror_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm256_maskz_ror_epi32::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -54051,7 +54087,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_ror_epi32() {
+    const fn test_mm_ror_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let r = _mm_ror_epi32::<1>(a);
         let e = _mm_set_epi32(1 << 31, 1, 1, 1);
@@ -54059,7 +54095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_ror_epi32() {
+    const fn test_mm_mask_ror_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let r = _mm_mask_ror_epi32::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -54069,7 +54105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_ror_epi32() {
+    const fn test_mm_maskz_ror_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let r = _mm_maskz_ror_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -54079,7 +54115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_slli_epi32() {
+    const fn test_mm512_slli_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_slli_epi32::<1>(a);
         let e = _mm512_set_epi32(0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
@@ -54087,7 +54123,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_slli_epi32() {
+    const fn test_mm512_mask_slli_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_mask_slli_epi32::<1>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -54097,7 +54133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_slli_epi32() {
+    const fn test_mm512_maskz_slli_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 << 31);
         let r = _mm512_maskz_slli_epi32::<1>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -54107,7 +54143,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_slli_epi32() {
+    const fn test_mm256_mask_slli_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm256_mask_slli_epi32::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -54117,7 +54153,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_slli_epi32() {
+    const fn test_mm256_maskz_slli_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm256_maskz_slli_epi32::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -54127,7 +54163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_slli_epi32() {
+    const fn test_mm_mask_slli_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let r = _mm_mask_slli_epi32::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -54137,7 +54173,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_slli_epi32() {
+    const fn test_mm_maskz_slli_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let r = _mm_maskz_slli_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -54147,7 +54183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srli_epi32() {
+    const fn test_mm512_srli_epi32() {
         let a = _mm512_set_epi32(0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm512_srli_epi32::<1>(a);
         let e = _mm512_set_epi32(0 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
@@ -54155,7 +54191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srli_epi32() {
+    const fn test_mm512_mask_srli_epi32() {
         let a = _mm512_set_epi32(0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let r = _mm512_mask_srli_epi32::<1>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -54165,7 +54201,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srli_epi32() {
+    const fn test_mm512_maskz_srli_epi32() {
         let a = _mm512_set_epi32(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0);
         let r = _mm512_maskz_srli_epi32::<1>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -54175,7 +54211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srli_epi32() {
+    const fn test_mm256_mask_srli_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm256_mask_srli_epi32::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -54185,7 +54221,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srli_epi32() {
+    const fn test_mm256_maskz_srli_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm256_maskz_srli_epi32::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -54195,7 +54231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srli_epi32() {
+    const fn test_mm_mask_srli_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let r = _mm_mask_srli_epi32::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -54205,7 +54241,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srli_epi32() {
+    const fn test_mm_maskz_srli_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let r = _mm_maskz_srli_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -54215,7 +54251,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rolv_epi32() {
+    const fn test_mm512_rolv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_rolv_epi32(a, b);
@@ -54224,7 +54260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rolv_epi32() {
+    const fn test_mm512_mask_rolv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_mask_rolv_epi32(a, 0, a, b);
@@ -54235,7 +54271,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rolv_epi32() {
+    const fn test_mm512_maskz_rolv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 << 31);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_maskz_rolv_epi32(0, a, b);
@@ -54246,7 +54282,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rolv_epi32() {
+    const fn test_mm256_rolv_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_rolv_epi32(a, b);
@@ -54255,7 +54291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rolv_epi32() {
+    const fn test_mm256_mask_rolv_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_mask_rolv_epi32(a, 0, a, b);
@@ -54266,7 +54302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rolv_epi32() {
+    const fn test_mm256_maskz_rolv_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_rolv_epi32(0, a, b);
@@ -54277,7 +54313,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rolv_epi32() {
+    const fn test_mm_rolv_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let b = _mm_set1_epi32(1);
         let r = _mm_rolv_epi32(a, b);
@@ -54286,7 +54322,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rolv_epi32() {
+    const fn test_mm_mask_rolv_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let b = _mm_set1_epi32(1);
         let r = _mm_mask_rolv_epi32(a, 0, a, b);
@@ -54297,7 +54333,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rolv_epi32() {
+    const fn test_mm_maskz_rolv_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_rolv_epi32(0, a, b);
@@ -54308,7 +54344,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rorv_epi32() {
+    const fn test_mm512_rorv_epi32() {
         let a = _mm512_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_rorv_epi32(a, b);
@@ -54317,7 +54353,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rorv_epi32() {
+    const fn test_mm512_mask_rorv_epi32() {
         let a = _mm512_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_mask_rorv_epi32(a, 0, a, b);
@@ -54328,7 +54364,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rorv_epi32() {
+    const fn test_mm512_maskz_rorv_epi32() {
         let a = _mm512_set_epi32(3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 << 0);
         let b = _mm512_set1_epi32(1);
         let r = _mm512_maskz_rorv_epi32(0, a, b);
@@ -54339,7 +54375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rorv_epi32() {
+    const fn test_mm256_rorv_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_rorv_epi32(a, b);
@@ -54348,7 +54384,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rorv_epi32() {
+    const fn test_mm256_mask_rorv_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_mask_rorv_epi32(a, 0, a, b);
@@ -54359,7 +54395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rorv_epi32() {
+    const fn test_mm256_maskz_rorv_epi32() {
         let a = _mm256_set_epi32(1 << 0, 2, 2, 2, 2, 2, 2, 2);
         let b = _mm256_set1_epi32(1);
         let r = _mm256_maskz_rorv_epi32(0, a, b);
@@ -54370,7 +54406,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rorv_epi32() {
+    const fn test_mm_rorv_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let b = _mm_set1_epi32(1);
         let r = _mm_rorv_epi32(a, b);
@@ -54379,7 +54415,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rorv_epi32() {
+    const fn test_mm_mask_rorv_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let b = _mm_set1_epi32(1);
         let r = _mm_mask_rorv_epi32(a, 0, a, b);
@@ -54390,7 +54426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rorv_epi32() {
+    const fn test_mm_maskz_rorv_epi32() {
         let a = _mm_set_epi32(1 << 0, 2, 2, 2);
         let b = _mm_set1_epi32(1);
         let r = _mm_maskz_rorv_epi32(0, a, b);
@@ -54401,7 +54437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sllv_epi32() {
+    const fn test_mm512_sllv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let count = _mm512_set1_epi32(1);
         let r = _mm512_sllv_epi32(a, count);
@@ -54410,7 +54446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sllv_epi32() {
+    const fn test_mm512_mask_sllv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let count = _mm512_set1_epi32(1);
         let r = _mm512_mask_sllv_epi32(a, 0, a, count);
@@ -54421,7 +54457,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sllv_epi32() {
+    const fn test_mm512_maskz_sllv_epi32() {
         let a = _mm512_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 << 31);
         let count = _mm512_set_epi32(0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_maskz_sllv_epi32(0, a, count);
@@ -54432,7 +54468,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sllv_epi32() {
+    const fn test_mm256_mask_sllv_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_mask_sllv_epi32(a, 0, a, count);
@@ -54443,7 +54479,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sllv_epi32() {
+    const fn test_mm256_maskz_sllv_epi32() {
         let a = _mm256_set_epi32(1 << 31, 1, 1, 1, 1, 1, 1, 1);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_maskz_sllv_epi32(0, a, count);
@@ -54454,7 +54490,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sllv_epi32() {
+    const fn test_mm_mask_sllv_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let count = _mm_set1_epi32(1);
         let r = _mm_mask_sllv_epi32(a, 0, a, count);
@@ -54465,7 +54501,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sllv_epi32() {
+    const fn test_mm_maskz_sllv_epi32() {
         let a = _mm_set_epi32(1 << 31, 1, 1, 1);
         let count = _mm_set1_epi32(1);
         let r = _mm_maskz_sllv_epi32(0, a, count);
@@ -54476,7 +54512,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srlv_epi32() {
+    const fn test_mm512_srlv_epi32() {
         let a = _mm512_set_epi32(0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let count = _mm512_set1_epi32(1);
         let r = _mm512_srlv_epi32(a, count);
@@ -54485,7 +54521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srlv_epi32() {
+    const fn test_mm512_mask_srlv_epi32() {
         let a = _mm512_set_epi32(0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
         let count = _mm512_set1_epi32(1);
         let r = _mm512_mask_srlv_epi32(a, 0, a, count);
@@ -54496,7 +54532,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srlv_epi32() {
+    const fn test_mm512_maskz_srlv_epi32() {
         let a = _mm512_set_epi32(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0);
         let count = _mm512_set_epi32(0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
         let r = _mm512_maskz_srlv_epi32(0, a, count);
@@ -54507,7 +54543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srlv_epi32() {
+    const fn test_mm256_mask_srlv_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_mask_srlv_epi32(a, 0, a, count);
@@ -54518,7 +54554,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srlv_epi32() {
+    const fn test_mm256_maskz_srlv_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_maskz_srlv_epi32(0, a, count);
@@ -54529,7 +54565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srlv_epi32() {
+    const fn test_mm_mask_srlv_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set1_epi32(1);
         let r = _mm_mask_srlv_epi32(a, 0, a, count);
@@ -54540,7 +54576,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srlv_epi32() {
+    const fn test_mm_maskz_srlv_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set1_epi32(1);
         let r = _mm_maskz_srlv_epi32(0, a, count);
@@ -54551,7 +54587,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sll_epi32() {
+    fn test_mm512_sll_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54572,7 +54608,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sll_epi32() {
+    fn test_mm512_mask_sll_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54595,7 +54631,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sll_epi32() {
+    fn test_mm512_maskz_sll_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54612,7 +54648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sll_epi32() {
+    fn test_mm256_mask_sll_epi32() {
         let a = _mm256_set_epi32(1 << 13, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_mask_sll_epi32(a, 0, a, count);
@@ -54623,7 +54659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sll_epi32() {
+    fn test_mm256_maskz_sll_epi32() {
         let a = _mm256_set_epi32(1 << 13, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_maskz_sll_epi32(0, a, count);
@@ -54634,7 +54670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sll_epi32() {
+    fn test_mm_mask_sll_epi32() {
         let a = _mm_set_epi32(1 << 13, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_mask_sll_epi32(a, 0, a, count);
@@ -54645,7 +54681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sll_epi32() {
+    fn test_mm_maskz_sll_epi32() {
         let a = _mm_set_epi32(1 << 13, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_maskz_sll_epi32(0, a, count);
@@ -54656,7 +54692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_srl_epi32() {
+    fn test_mm512_srl_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54671,7 +54707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_srl_epi32() {
+    fn test_mm512_mask_srl_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54688,7 +54724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_srl_epi32() {
+    fn test_mm512_maskz_srl_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 31, 1 << 0, 1 << 1, 1 << 2,
@@ -54705,7 +54741,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_srl_epi32() {
+    fn test_mm256_mask_srl_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_mask_srl_epi32(a, 0, a, count);
@@ -54716,7 +54752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_srl_epi32() {
+    fn test_mm256_maskz_srl_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_maskz_srl_epi32(0, a, count);
@@ -54727,7 +54763,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_srl_epi32() {
+    fn test_mm_mask_srl_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_mask_srl_epi32(a, 0, a, count);
@@ -54738,7 +54774,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_srl_epi32() {
+    fn test_mm_maskz_srl_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_maskz_srl_epi32(0, a, count);
@@ -54749,7 +54785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sra_epi32() {
+    fn test_mm512_sra_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
         let count = _mm_set_epi32(1, 0, 0, 2);
         let r = _mm512_sra_epi32(a, count);
@@ -54758,7 +54794,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sra_epi32() {
+    fn test_mm512_mask_sra_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16);
         let count = _mm_set_epi32(0, 0, 0, 2);
         let r = _mm512_mask_sra_epi32(a, 0, a, count);
@@ -54769,7 +54805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sra_epi32() {
+    fn test_mm512_maskz_sra_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, -14);
         let count = _mm_set_epi32(2, 0, 0, 2);
         let r = _mm512_maskz_sra_epi32(0, a, count);
@@ -54780,7 +54816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sra_epi32() {
+    fn test_mm256_mask_sra_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_mask_sra_epi32(a, 0, a, count);
@@ -54791,7 +54827,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sra_epi32() {
+    fn test_mm256_maskz_sra_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm256_maskz_sra_epi32(0, a, count);
@@ -54802,7 +54838,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sra_epi32() {
+    fn test_mm_mask_sra_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_mask_sra_epi32(a, 0, a, count);
@@ -54813,7 +54849,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sra_epi32() {
+    fn test_mm_maskz_sra_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set_epi32(0, 0, 0, 1);
         let r = _mm_maskz_sra_epi32(0, a, count);
@@ -54824,7 +54860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srav_epi32() {
+    const fn test_mm512_srav_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
         let count = _mm512_set_epi32(2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm512_srav_epi32(a, count);
@@ -54833,7 +54869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srav_epi32() {
+    const fn test_mm512_mask_srav_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16);
         let count = _mm512_set_epi32(2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
         let r = _mm512_mask_srav_epi32(a, 0, a, count);
@@ -54844,7 +54880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srav_epi32() {
+    const fn test_mm512_maskz_srav_epi32() {
         let a = _mm512_set_epi32(8, -8, 16, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, -14);
         let count = _mm512_set_epi32(2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2);
         let r = _mm512_maskz_srav_epi32(0, a, count);
@@ -54855,7 +54891,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srav_epi32() {
+    const fn test_mm256_mask_srav_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_mask_srav_epi32(a, 0, a, count);
@@ -54866,7 +54902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srav_epi32() {
+    const fn test_mm256_maskz_srav_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let count = _mm256_set1_epi32(1);
         let r = _mm256_maskz_srav_epi32(0, a, count);
@@ -54877,7 +54913,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srav_epi32() {
+    const fn test_mm_mask_srav_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set1_epi32(1);
         let r = _mm_mask_srav_epi32(a, 0, a, count);
@@ -54888,7 +54924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srav_epi32() {
+    const fn test_mm_maskz_srav_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let count = _mm_set1_epi32(1);
         let r = _mm_maskz_srav_epi32(0, a, count);
@@ -54899,7 +54935,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srai_epi32() {
+    const fn test_mm512_srai_epi32() {
         let a = _mm512_set_epi32(8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, -15);
         let r = _mm512_srai_epi32::<2>(a);
         let e = _mm512_set_epi32(2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, -4);
@@ -54907,7 +54943,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srai_epi32() {
+    const fn test_mm512_mask_srai_epi32() {
         let a = _mm512_set_epi32(8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, -15);
         let r = _mm512_mask_srai_epi32::<2>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -54917,7 +54953,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srai_epi32() {
+    const fn test_mm512_maskz_srai_epi32() {
         let a = _mm512_set_epi32(8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, -15);
         let r = _mm512_maskz_srai_epi32::<2>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -54927,7 +54963,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srai_epi32() {
+    const fn test_mm256_mask_srai_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm256_mask_srai_epi32::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -54937,7 +54973,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srai_epi32() {
+    const fn test_mm256_maskz_srai_epi32() {
         let a = _mm256_set_epi32(1 << 5, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm256_maskz_srai_epi32::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -54947,7 +54983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srai_epi32() {
+    const fn test_mm_mask_srai_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let r = _mm_mask_srai_epi32::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -54957,7 +54993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srai_epi32() {
+    const fn test_mm_maskz_srai_epi32() {
         let a = _mm_set_epi32(1 << 5, 0, 0, 0);
         let r = _mm_maskz_srai_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -54967,7 +55003,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_permute_ps() {
+    const fn test_mm512_permute_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -54979,7 +55015,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_permute_ps() {
+    const fn test_mm512_mask_permute_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -54993,7 +55029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_permute_ps() {
+    const fn test_mm512_maskz_permute_ps() {
         let a = _mm512_setr_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55007,7 +55043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_permute_ps() {
+    const fn test_mm256_mask_permute_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_mask_permute_ps::<0b11_11_11_11>(a, 0, a);
         assert_eq_m256(r, a);
@@ -55017,7 +55053,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_permute_ps() {
+    const fn test_mm256_maskz_permute_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_maskz_permute_ps::<0b11_11_11_11>(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -55027,7 +55063,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_permute_ps() {
+    const fn test_mm_mask_permute_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_mask_permute_ps::<0b11_11_11_11>(a, 0, a);
         assert_eq_m128(r, a);
@@ -55037,7 +55073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_permute_ps() {
+    const fn test_mm_maskz_permute_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_maskz_permute_ps::<0b11_11_11_11>(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -55047,7 +55083,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutevar_epi32() {
+    fn test_mm512_permutevar_epi32() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_permutevar_epi32(idx, a);
@@ -55056,7 +55092,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutevar_epi32() {
+    fn test_mm512_mask_permutevar_epi32() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_mask_permutevar_epi32(a, 0, idx, a);
@@ -55067,7 +55103,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutevar_ps() {
+    fn test_mm512_permutevar_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55080,7 +55116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutevar_ps() {
+    fn test_mm512_mask_permutevar_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55095,7 +55131,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutevar_ps() {
+    fn test_mm512_maskz_permutevar_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55110,7 +55146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutevar_ps() {
+    fn test_mm256_mask_permutevar_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set1_epi32(0b01);
         let r = _mm256_mask_permutevar_ps(a, 0, a, b);
@@ -55121,7 +55157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutevar_ps() {
+    fn test_mm256_maskz_permutevar_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm256_set1_epi32(0b01);
         let r = _mm256_maskz_permutevar_ps(0, a, b);
@@ -55132,7 +55168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutevar_ps() {
+    fn test_mm_mask_permutevar_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set1_epi32(0b01);
         let r = _mm_mask_permutevar_ps(a, 0, a, b);
@@ -55143,7 +55179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutevar_ps() {
+    fn test_mm_maskz_permutevar_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set1_epi32(0b01);
         let r = _mm_maskz_permutevar_ps(0, a, b);
@@ -55154,7 +55190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutexvar_epi32() {
+    fn test_mm512_permutexvar_epi32() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_permutexvar_epi32(idx, a);
@@ -55163,7 +55199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutexvar_epi32() {
+    fn test_mm512_mask_permutexvar_epi32() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_mask_permutexvar_epi32(a, 0, idx, a);
@@ -55174,7 +55210,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutexvar_epi32() {
+    fn test_mm512_maskz_permutexvar_epi32() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_permutexvar_epi32(0, idx, a);
@@ -55185,7 +55221,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutexvar_epi32() {
+    fn test_mm256_permutexvar_epi32() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_permutexvar_epi32(idx, a);
@@ -55194,7 +55230,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_epi32() {
+    fn test_mm256_mask_permutexvar_epi32() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_mask_permutexvar_epi32(a, 0, idx, a);
@@ -55205,7 +55241,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_epi32() {
+    fn test_mm256_maskz_permutexvar_epi32() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_permutexvar_epi32(0, idx, a);
@@ -55216,7 +55252,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutexvar_ps() {
+    fn test_mm512_permutexvar_ps() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -55227,7 +55263,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutexvar_ps() {
+    fn test_mm512_mask_permutexvar_ps() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -55240,7 +55276,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutexvar_ps() {
+    fn test_mm512_maskz_permutexvar_ps() {
         let idx = _mm512_set1_epi32(1);
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -55255,7 +55291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutexvar_ps() {
+    fn test_mm256_permutexvar_ps() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_permutexvar_ps(idx, a);
@@ -55264,7 +55300,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_ps() {
+    fn test_mm256_mask_permutexvar_ps() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_mask_permutexvar_ps(a, 0, idx, a);
@@ -55275,7 +55311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_ps() {
+    fn test_mm256_maskz_permutexvar_ps() {
         let idx = _mm256_set1_epi32(1);
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_maskz_permutexvar_ps(0, idx, a);
@@ -55286,7 +55322,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutex2var_epi32() {
+    fn test_mm512_permutex2var_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm512_set_epi32(
@@ -55304,7 +55340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutex2var_epi32() {
+    fn test_mm512_mask_permutex2var_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm512_set_epi32(
@@ -55324,7 +55360,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutex2var_epi32() {
+    fn test_mm512_maskz_permutex2var_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm512_set_epi32(
@@ -55342,7 +55378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask2_permutex2var_epi32() {
+    fn test_mm512_mask2_permutex2var_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm512_set_epi32(
@@ -55366,7 +55402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutex2var_epi32() {
+    fn test_mm256_permutex2var_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_epi32(100);
@@ -55376,7 +55412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_epi32() {
+    fn test_mm256_mask_permutex2var_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_epi32(100);
@@ -55388,7 +55424,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_epi32() {
+    fn test_mm256_maskz_permutex2var_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_epi32(100);
@@ -55400,7 +55436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_epi32() {
+    fn test_mm256_mask2_permutex2var_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_epi32(100);
@@ -55412,7 +55448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_permutex2var_epi32() {
+    fn test_mm_permutex2var_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_epi32(100);
@@ -55422,7 +55458,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_epi32() {
+    fn test_mm_mask_permutex2var_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_epi32(100);
@@ -55434,7 +55470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_epi32() {
+    fn test_mm_maskz_permutex2var_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_epi32(100);
@@ -55446,7 +55482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_epi32() {
+    fn test_mm_mask2_permutex2var_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_epi32(100);
@@ -55458,7 +55494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutex2var_ps() {
+    fn test_mm512_permutex2var_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55478,7 +55514,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutex2var_ps() {
+    fn test_mm512_mask_permutex2var_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55500,7 +55536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutex2var_ps() {
+    fn test_mm512_maskz_permutex2var_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55522,7 +55558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask2_permutex2var_ps() {
+    fn test_mm512_mask2_permutex2var_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -55544,7 +55580,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutex2var_ps() {
+    fn test_mm256_permutex2var_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_ps(100.);
@@ -55554,7 +55590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_ps() {
+    fn test_mm256_mask_permutex2var_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_ps(100.);
@@ -55566,7 +55602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_ps() {
+    fn test_mm256_maskz_permutex2var_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_ps(100.);
@@ -55578,7 +55614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_ps() {
+    fn test_mm256_mask2_permutex2var_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm256_set_epi32(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm256_set1_ps(100.);
@@ -55590,7 +55626,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_permutex2var_ps() {
+    fn test_mm_permutex2var_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_ps(100.);
@@ -55600,7 +55636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_ps() {
+    fn test_mm_mask_permutex2var_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_ps(100.);
@@ -55612,7 +55648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_ps() {
+    fn test_mm_maskz_permutex2var_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_ps(100.);
@@ -55624,7 +55660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_ps() {
+    fn test_mm_mask2_permutex2var_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let idx = _mm_set_epi32(1, 1 << 2, 2, 1 << 2);
         let b = _mm_set1_ps(100.);
@@ -55636,7 +55672,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_epi32() {
+    const fn test_mm512_shuffle_epi32() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let r = _mm512_shuffle_epi32::<_MM_PERM_AADD>(a);
         let e = _mm512_setr_epi32(8, 8, 1, 1, 16, 16, 9, 9, 8, 8, 1, 1, 16, 16, 9, 9);
@@ -55644,7 +55680,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_epi32() {
+    const fn test_mm512_mask_shuffle_epi32() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let r = _mm512_mask_shuffle_epi32::<_MM_PERM_AADD>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -55654,7 +55690,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_epi32() {
+    const fn test_mm512_maskz_shuffle_epi32() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let r = _mm512_maskz_shuffle_epi32::<_MM_PERM_AADD>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -55664,7 +55700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_epi32() {
+    const fn test_mm256_mask_shuffle_epi32() {
         let a = _mm256_set_epi32(1, 4, 5, 8, 9, 12, 13, 16);
         let r = _mm256_mask_shuffle_epi32::<_MM_PERM_AADD>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -55674,7 +55710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_epi32() {
+    const fn test_mm256_maskz_shuffle_epi32() {
         let a = _mm256_set_epi32(1, 4, 5, 8, 9, 12, 13, 16);
         let r = _mm256_maskz_shuffle_epi32::<_MM_PERM_AADD>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -55684,7 +55720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_shuffle_epi32() {
+    const fn test_mm_mask_shuffle_epi32() {
         let a = _mm_set_epi32(1, 4, 5, 8);
         let r = _mm_mask_shuffle_epi32::<_MM_PERM_AADD>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -55694,7 +55730,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_shuffle_epi32() {
+    const fn test_mm_maskz_shuffle_epi32() {
         let a = _mm_set_epi32(1, 4, 5, 8);
         let r = _mm_maskz_shuffle_epi32::<_MM_PERM_AADD>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -55704,7 +55740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_ps() {
+    const fn test_mm512_shuffle_ps() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55719,7 +55755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_ps() {
+    const fn test_mm512_mask_shuffle_ps() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55736,7 +55772,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_ps() {
+    const fn test_mm512_maskz_shuffle_ps() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55753,7 +55789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_ps() {
+    const fn test_mm256_mask_shuffle_ps() {
         let a = _mm256_set_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_set_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_mask_shuffle_ps::<0b11_11_11_11>(a, 0, a, b);
@@ -55764,7 +55800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_ps() {
+    const fn test_mm256_maskz_shuffle_ps() {
         let a = _mm256_set_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_set_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_maskz_shuffle_ps::<0b11_11_11_11>(0, a, b);
@@ -55775,7 +55811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_shuffle_ps() {
+    const fn test_mm_mask_shuffle_ps() {
         let a = _mm_set_ps(1., 4., 5., 8.);
         let b = _mm_set_ps(2., 3., 6., 7.);
         let r = _mm_mask_shuffle_ps::<0b11_11_11_11>(a, 0, a, b);
@@ -55786,7 +55822,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_shuffle_ps() {
+    const fn test_mm_maskz_shuffle_ps() {
         let a = _mm_set_ps(1., 4., 5., 8.);
         let b = _mm_set_ps(2., 3., 6., 7.);
         let r = _mm_maskz_shuffle_ps::<0b11_11_11_11>(0, a, b);
@@ -55797,7 +55833,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_i32x4() {
+    const fn test_mm512_shuffle_i32x4() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi32(2, 3, 6, 7, 10, 11, 14, 15, 2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_shuffle_i32x4::<0b00_00_00_00>(a, b);
@@ -55806,7 +55842,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_i32x4() {
+    const fn test_mm512_mask_shuffle_i32x4() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi32(2, 3, 6, 7, 10, 11, 14, 15, 2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_mask_shuffle_i32x4::<0b00_00_00_00>(a, 0, a, b);
@@ -55817,7 +55853,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_i32x4() {
+    const fn test_mm512_maskz_shuffle_i32x4() {
         let a = _mm512_setr_epi32(1, 4, 5, 8, 9, 12, 13, 16, 1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi32(2, 3, 6, 7, 10, 11, 14, 15, 2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_maskz_shuffle_i32x4::<0b00_00_00_00>(0, a, b);
@@ -55828,7 +55864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_shuffle_i32x4() {
+    const fn test_mm256_shuffle_i32x4() {
         let a = _mm256_set_epi32(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm256_set_epi32(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm256_shuffle_i32x4::<0b00>(a, b);
@@ -55837,7 +55873,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_i32x4() {
+    const fn test_mm256_mask_shuffle_i32x4() {
         let a = _mm256_set_epi32(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm256_set_epi32(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm256_mask_shuffle_i32x4::<0b00>(a, 0, a, b);
@@ -55848,7 +55884,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_i32x4() {
+    const fn test_mm256_maskz_shuffle_i32x4() {
         let a = _mm256_set_epi32(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm256_set_epi32(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm256_maskz_shuffle_i32x4::<0b00>(0, a, b);
@@ -55859,7 +55895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_f32x4() {
+    const fn test_mm512_shuffle_f32x4() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55874,7 +55910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_f32x4() {
+    const fn test_mm512_mask_shuffle_f32x4() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55891,7 +55927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_f32x4() {
+    const fn test_mm512_maskz_shuffle_f32x4() {
         let a = _mm512_setr_ps(
             1., 4., 5., 8., 9., 12., 13., 16., 1., 4., 5., 8., 9., 12., 13., 16.,
         );
@@ -55908,7 +55944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_shuffle_f32x4() {
+    const fn test_mm256_shuffle_f32x4() {
         let a = _mm256_set_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_set_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_shuffle_f32x4::<0b00>(a, b);
@@ -55917,7 +55953,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_f32x4() {
+    const fn test_mm256_mask_shuffle_f32x4() {
         let a = _mm256_set_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_set_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_mask_shuffle_f32x4::<0b00>(a, 0, a, b);
@@ -55928,7 +55964,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_f32x4() {
+    const fn test_mm256_maskz_shuffle_f32x4() {
         let a = _mm256_set_ps(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm256_set_ps(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm256_maskz_shuffle_f32x4::<0b00>(0, a, b);
@@ -55939,7 +55975,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_extractf32x4_ps() {
+    const fn test_mm512_extractf32x4_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -55949,7 +55985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_extractf32x4_ps() {
+    const fn test_mm512_mask_extractf32x4_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -55962,7 +55998,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_extractf32x4_ps() {
+    const fn test_mm512_maskz_extractf32x4_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -55974,7 +56010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_extractf32x4_ps() {
+    const fn test_mm256_extractf32x4_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_extractf32x4_ps::<1>(a);
         let e = _mm_set_ps(1., 2., 3., 4.);
@@ -55982,7 +56018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_extractf32x4_ps() {
+    const fn test_mm256_mask_extractf32x4_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let src = _mm_set1_ps(100.);
         let r = _mm256_mask_extractf32x4_ps::<1>(src, 0, a);
@@ -55993,7 +56029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_extractf32x4_ps() {
+    const fn test_mm256_maskz_extractf32x4_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_maskz_extractf32x4_ps::<1>(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -56003,7 +56039,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_extracti32x4_epi32() {
+    const fn test_mm512_extracti32x4_epi32() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_extracti32x4_epi32::<1>(a);
         let e = _mm_setr_epi32(5, 6, 7, 8);
@@ -56011,7 +56047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_extracti32x4_epi32() {
+    const fn test_mm512_mask_extracti32x4_epi32() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm_set1_epi32(100);
         let r = _mm512_mask_extracti32x4_epi32::<1>(src, 0, a);
@@ -56022,7 +56058,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm512_maskz_extracti32x4_epi32() {
+    const fn test_mm512_maskz_extracti32x4_epi32() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_extracti32x4_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -56032,7 +56068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_extracti32x4_epi32() {
+    const fn test_mm256_extracti32x4_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_extracti32x4_epi32::<1>(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -56040,7 +56076,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_extracti32x4_epi32() {
+    const fn test_mm256_mask_extracti32x4_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set1_epi32(100);
         let r = _mm256_mask_extracti32x4_epi32::<1>(src, 0, a);
@@ -56051,7 +56087,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_extracti32x4_epi32() {
+    const fn test_mm256_maskz_extracti32x4_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_extracti32x4_epi32::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -56061,7 +56097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_moveldup_ps() {
+    const fn test_mm512_moveldup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56073,7 +56109,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_moveldup_ps() {
+    const fn test_mm512_mask_moveldup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56087,7 +56123,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_moveldup_ps() {
+    const fn test_mm512_maskz_moveldup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56101,7 +56137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_moveldup_ps() {
+    const fn test_mm256_mask_moveldup_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_mask_moveldup_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -56111,7 +56147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_moveldup_ps() {
+    const fn test_mm256_maskz_moveldup_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_maskz_moveldup_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -56121,7 +56157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_moveldup_ps() {
+    const fn test_mm_mask_moveldup_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_mask_moveldup_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -56131,7 +56167,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_moveldup_ps() {
+    const fn test_mm_maskz_moveldup_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_moveldup_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -56141,7 +56177,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_movehdup_ps() {
+    const fn test_mm512_movehdup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56153,7 +56189,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_movehdup_ps() {
+    const fn test_mm512_mask_movehdup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56167,7 +56203,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_movehdup_ps() {
+    const fn test_mm512_maskz_movehdup_ps() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56181,7 +56217,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_movehdup_ps() {
+    const fn test_mm256_mask_movehdup_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_mask_movehdup_ps(a, 0, a);
         assert_eq_m256(r, a);
@@ -56191,7 +56227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_movehdup_ps() {
+    const fn test_mm256_maskz_movehdup_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_maskz_movehdup_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -56201,7 +56237,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_movehdup_ps() {
+    const fn test_mm_mask_movehdup_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_mask_movehdup_ps(a, 0, a);
         assert_eq_m128(r, a);
@@ -56211,7 +56247,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_movehdup_ps() {
+    const fn test_mm_maskz_movehdup_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let r = _mm_maskz_movehdup_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -56221,7 +56257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_inserti32x4() {
+    const fn test_mm512_inserti32x4() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_setr_epi32(17, 18, 19, 20);
         let r = _mm512_inserti32x4::<0>(a, b);
@@ -56230,7 +56266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_inserti32x4() {
+    const fn test_mm512_mask_inserti32x4() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_setr_epi32(17, 18, 19, 20);
         let r = _mm512_mask_inserti32x4::<0>(a, 0, a, b);
@@ -56241,7 +56277,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_inserti32x4() {
+    const fn test_mm512_maskz_inserti32x4() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm_setr_epi32(17, 18, 19, 20);
         let r = _mm512_maskz_inserti32x4::<0>(0, a, b);
@@ -56252,7 +56288,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_inserti32x4() {
+    const fn test_mm256_inserti32x4() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_inserti32x4::<1>(a, b);
@@ -56261,7 +56297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_inserti32x4() {
+    const fn test_mm256_mask_inserti32x4() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_mask_inserti32x4::<0>(a, 0, a, b);
@@ -56272,7 +56308,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_inserti32x4() {
+    const fn test_mm256_maskz_inserti32x4() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_maskz_inserti32x4::<0>(0, a, b);
@@ -56283,7 +56319,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_insertf32x4() {
+    const fn test_mm512_insertf32x4() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56296,7 +56332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_insertf32x4() {
+    const fn test_mm512_mask_insertf32x4() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56311,7 +56347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_insertf32x4() {
+    const fn test_mm512_maskz_insertf32x4() {
         let a = _mm512_setr_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56326,7 +56362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_insertf32x4() {
+    const fn test_mm256_insertf32x4() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_insertf32x4::<1>(a, b);
@@ -56335,7 +56371,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_insertf32x4() {
+    const fn test_mm256_mask_insertf32x4() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_mask_insertf32x4::<0>(a, 0, a, b);
@@ -56346,7 +56382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_insertf32x4() {
+    const fn test_mm256_maskz_insertf32x4() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_maskz_insertf32x4::<0>(0, a, b);
@@ -56357,21 +56393,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps128_ps512() {
+    const fn test_mm512_castps128_ps512() {
         let a = _mm_setr_ps(17., 18., 19., 20.);
         let r = _mm512_castps128_ps512(a);
         assert_eq_m128(_mm512_castps512_ps128(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps256_ps512() {
+    const fn test_mm512_castps256_ps512() {
         let a = _mm256_setr_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_castps256_ps512(a);
         assert_eq_m256(_mm512_castps512_ps256(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextps128_ps512() {
+    const fn test_mm512_zextps128_ps512() {
         let a = _mm_setr_ps(17., 18., 19., 20.);
         let r = _mm512_zextps128_ps512(a);
         let e = _mm512_setr_ps(
@@ -56381,7 +56417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextps256_ps512() {
+    const fn test_mm512_zextps256_ps512() {
         let a = _mm256_setr_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_zextps256_ps512(a);
         let e = _mm512_setr_ps(
@@ -56391,7 +56427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps512_ps128() {
+    const fn test_mm512_castps512_ps128() {
         let a = _mm512_setr_ps(
             17., 18., 19., 20., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1.,
         );
@@ -56401,7 +56437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps512_ps256() {
+    const fn test_mm512_castps512_ps256() {
         let a = _mm512_setr_ps(
             17., 18., 19., 20., 21., 22., 23., 24., -1., -1., -1., -1., -1., -1., -1., -1.,
         );
@@ -56411,7 +56447,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps_pd() {
+    const fn test_mm512_castps_pd() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_castps_pd(a);
         let e = _mm512_set1_pd(0.007812501848093234);
@@ -56419,7 +56455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castps_si512() {
+    const fn test_mm512_castps_si512() {
         let a = _mm512_set1_ps(1.);
         let r = _mm512_castps_si512(a);
         let e = _mm512_set1_epi32(1065353216);
@@ -56427,7 +56463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcastd_epi32() {
+    const fn test_mm512_broadcastd_epi32() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_broadcastd_epi32(a);
         let e = _mm512_set1_epi32(20);
@@ -56435,7 +56471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcastd_epi32() {
+    const fn test_mm512_mask_broadcastd_epi32() {
         let src = _mm512_set1_epi32(20);
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_mask_broadcastd_epi32(src, 0, a);
@@ -56446,7 +56482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcastd_epi32() {
+    const fn test_mm512_maskz_broadcastd_epi32() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_maskz_broadcastd_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -56456,7 +56492,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastd_epi32() {
+    const fn test_mm256_mask_broadcastd_epi32() {
         let src = _mm256_set1_epi32(20);
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_mask_broadcastd_epi32(src, 0, a);
@@ -56467,7 +56503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastd_epi32() {
+    const fn test_mm256_maskz_broadcastd_epi32() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_maskz_broadcastd_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -56477,7 +56513,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_broadcastd_epi32() {
+    const fn test_mm_mask_broadcastd_epi32() {
         let src = _mm_set1_epi32(20);
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_mask_broadcastd_epi32(src, 0, a);
@@ -56488,7 +56524,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcastd_epi32() {
+    const fn test_mm_maskz_broadcastd_epi32() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_maskz_broadcastd_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -56498,7 +56534,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcastss_ps() {
+    const fn test_mm512_broadcastss_ps() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_broadcastss_ps(a);
         let e = _mm512_set1_ps(20.);
@@ -56506,7 +56542,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcastss_ps() {
+    const fn test_mm512_mask_broadcastss_ps() {
         let src = _mm512_set1_ps(20.);
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_mask_broadcastss_ps(src, 0, a);
@@ -56517,7 +56553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcastss_ps() {
+    const fn test_mm512_maskz_broadcastss_ps() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_maskz_broadcastss_ps(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -56529,7 +56565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastss_ps() {
+    const fn test_mm256_mask_broadcastss_ps() {
         let src = _mm256_set1_ps(20.);
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_mask_broadcastss_ps(src, 0, a);
@@ -56540,7 +56576,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastss_ps() {
+    const fn test_mm256_maskz_broadcastss_ps() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_maskz_broadcastss_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -56550,7 +56586,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_broadcastss_ps() {
+    const fn test_mm_mask_broadcastss_ps() {
         let src = _mm_set1_ps(20.);
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_mask_broadcastss_ps(src, 0, a);
@@ -56561,7 +56597,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcastss_ps() {
+    const fn test_mm_maskz_broadcastss_ps() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_maskz_broadcastss_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -56571,7 +56607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcast_i32x4() {
+    const fn test_mm512_broadcast_i32x4() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_broadcast_i32x4(a);
         let e = _mm512_set_epi32(
@@ -56581,7 +56617,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcast_i32x4() {
+    const fn test_mm512_mask_broadcast_i32x4() {
         let src = _mm512_set1_epi32(20);
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_mask_broadcast_i32x4(src, 0, a);
@@ -56594,7 +56630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcast_i32x4() {
+    const fn test_mm512_maskz_broadcast_i32x4() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm512_maskz_broadcast_i32x4(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -56604,7 +56640,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_broadcast_i32x4() {
+    const fn test_mm256_broadcast_i32x4() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_broadcast_i32x4(a);
         let e = _mm256_set_epi32(17, 18, 19, 20, 17, 18, 19, 20);
@@ -56612,7 +56648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_i32x4() {
+    const fn test_mm256_mask_broadcast_i32x4() {
         let src = _mm256_set1_epi32(20);
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_mask_broadcast_i32x4(src, 0, a);
@@ -56623,7 +56659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_i32x4() {
+    const fn test_mm256_maskz_broadcast_i32x4() {
         let a = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm256_maskz_broadcast_i32x4(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -56633,7 +56669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcast_f32x4() {
+    const fn test_mm512_broadcast_f32x4() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_broadcast_f32x4(a);
         let e = _mm512_set_ps(
@@ -56643,7 +56679,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcast_f32x4() {
+    const fn test_mm512_mask_broadcast_f32x4() {
         let src = _mm512_set1_ps(20.);
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_mask_broadcast_f32x4(src, 0, a);
@@ -56656,7 +56692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcast_f32x4() {
+    const fn test_mm512_maskz_broadcast_f32x4() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm512_maskz_broadcast_f32x4(0, a);
         assert_eq_m512(r, _mm512_setzero_ps());
@@ -56668,7 +56704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_broadcast_f32x4() {
+    const fn test_mm256_broadcast_f32x4() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_broadcast_f32x4(a);
         let e = _mm256_set_ps(17., 18., 19., 20., 17., 18., 19., 20.);
@@ -56676,7 +56712,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcast_f32x4() {
+    const fn test_mm256_mask_broadcast_f32x4() {
         let src = _mm256_set1_ps(20.);
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_mask_broadcast_f32x4(src, 0, a);
@@ -56687,7 +56723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcast_f32x4() {
+    const fn test_mm256_maskz_broadcast_f32x4() {
         let a = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm256_maskz_broadcast_f32x4(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -56697,7 +56733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_blend_epi32() {
+    const fn test_mm512_mask_blend_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(2);
         let r = _mm512_mask_blend_epi32(0b11111111_00000000, a, b);
@@ -56706,7 +56742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_epi32() {
+    const fn test_mm256_mask_blend_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(2);
         let r = _mm256_mask_blend_epi32(0b11111111, a, b);
@@ -56715,7 +56751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_blend_epi32() {
+    const fn test_mm_mask_blend_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(2);
         let r = _mm_mask_blend_epi32(0b00001111, a, b);
@@ -56724,7 +56760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_blend_ps() {
+    const fn test_mm512_mask_blend_ps() {
         let a = _mm512_set1_ps(1.);
         let b = _mm512_set1_ps(2.);
         let r = _mm512_mask_blend_ps(0b11111111_00000000, a, b);
@@ -56735,7 +56771,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_ps() {
+    const fn test_mm256_mask_blend_ps() {
         let a = _mm256_set1_ps(1.);
         let b = _mm256_set1_ps(2.);
         let r = _mm256_mask_blend_ps(0b11111111, a, b);
@@ -56744,7 +56780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_blend_ps() {
+    const fn test_mm_mask_blend_ps() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let r = _mm_mask_blend_ps(0b00001111, a, b);
@@ -56753,7 +56789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpackhi_epi32() {
+    const fn test_mm512_unpackhi_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56764,7 +56800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpackhi_epi32() {
+    const fn test_mm512_mask_unpackhi_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56777,7 +56813,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpackhi_epi32() {
+    const fn test_mm512_maskz_unpackhi_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56790,7 +56826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_epi32() {
+    const fn test_mm256_mask_unpackhi_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_mask_unpackhi_epi32(a, 0, a, b);
@@ -56801,7 +56837,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_epi32() {
+    const fn test_mm256_maskz_unpackhi_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_maskz_unpackhi_epi32(0, a, b);
@@ -56812,7 +56848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_epi32() {
+    const fn test_mm_mask_unpackhi_epi32() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_mask_unpackhi_epi32(a, 0, a, b);
@@ -56823,7 +56859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_epi32() {
+    const fn test_mm_maskz_unpackhi_epi32() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_maskz_unpackhi_epi32(0, a, b);
@@ -56834,7 +56870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpackhi_ps() {
+    const fn test_mm512_unpackhi_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56849,7 +56885,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpackhi_ps() {
+    const fn test_mm512_mask_unpackhi_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56866,7 +56902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpackhi_ps() {
+    const fn test_mm512_maskz_unpackhi_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -56883,7 +56919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_ps() {
+    const fn test_mm256_mask_unpackhi_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm256_mask_unpackhi_ps(a, 0, a, b);
@@ -56894,7 +56930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_ps() {
+    const fn test_mm256_maskz_unpackhi_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm256_maskz_unpackhi_ps(0, a, b);
@@ -56905,7 +56941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_ps() {
+    const fn test_mm_mask_unpackhi_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_mask_unpackhi_ps(a, 0, a, b);
@@ -56916,7 +56952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_ps() {
+    const fn test_mm_maskz_unpackhi_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_maskz_unpackhi_ps(0, a, b);
@@ -56927,7 +56963,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpacklo_epi32() {
+    const fn test_mm512_unpacklo_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56938,7 +56974,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpacklo_epi32() {
+    const fn test_mm512_mask_unpacklo_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56951,7 +56987,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpacklo_epi32() {
+    const fn test_mm512_maskz_unpacklo_epi32() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let b = _mm512_set_epi32(
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -56964,7 +57000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_epi32() {
+    const fn test_mm256_mask_unpacklo_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_mask_unpacklo_epi32(a, 0, a, b);
@@ -56975,7 +57011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_epi32() {
+    const fn test_mm256_maskz_unpacklo_epi32() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_set_epi32(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm256_maskz_unpacklo_epi32(0, a, b);
@@ -56986,7 +57022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_epi32() {
+    const fn test_mm_mask_unpacklo_epi32() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_mask_unpacklo_epi32(a, 0, a, b);
@@ -56997,7 +57033,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_epi32() {
+    const fn test_mm_maskz_unpacklo_epi32() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let b = _mm_set_epi32(17, 18, 19, 20);
         let r = _mm_maskz_unpacklo_epi32(0, a, b);
@@ -57008,7 +57044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpacklo_ps() {
+    const fn test_mm512_unpacklo_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -57023,7 +57059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpacklo_ps() {
+    const fn test_mm512_mask_unpacklo_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -57040,7 +57076,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpacklo_ps() {
+    const fn test_mm512_maskz_unpacklo_ps() {
         let a = _mm512_set_ps(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -57057,7 +57093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_ps() {
+    const fn test_mm256_mask_unpacklo_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm256_mask_unpacklo_ps(a, 0, a, b);
@@ -57068,7 +57104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_ps() {
+    const fn test_mm256_maskz_unpacklo_ps() {
         let a = _mm256_set_ps(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_set_ps(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm256_maskz_unpacklo_ps(0, a, b);
@@ -57079,7 +57115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_ps() {
+    const fn test_mm_mask_unpacklo_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_mask_unpacklo_ps(a, 0, a, b);
@@ -57090,7 +57126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_ps() {
+    const fn test_mm_maskz_unpacklo_ps() {
         let a = _mm_set_ps(1., 2., 3., 4.);
         let b = _mm_set_ps(17., 18., 19., 20.);
         let r = _mm_maskz_unpacklo_ps(0, a, b);
@@ -57101,7 +57137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_alignr_epi32() {
+    const fn test_mm512_alignr_epi32() {
         let a = _mm512_set_epi32(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi32(
             32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
@@ -57118,7 +57154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_alignr_epi32() {
+    const fn test_mm512_mask_alignr_epi32() {
         let a = _mm512_set_epi32(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi32(
             32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
@@ -57133,7 +57169,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_alignr_epi32() {
+    const fn test_mm512_maskz_alignr_epi32() {
         let a = _mm512_set_epi32(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi32(
             32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
@@ -57146,7 +57182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_alignr_epi32() {
+    const fn test_mm256_alignr_epi32() {
         let a = _mm256_set_epi32(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm256_set_epi32(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm256_alignr_epi32::<0>(a, b);
@@ -57157,7 +57193,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_alignr_epi32() {
+    const fn test_mm256_mask_alignr_epi32() {
         let a = _mm256_set_epi32(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm256_set_epi32(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm256_mask_alignr_epi32::<1>(a, 0, a, b);
@@ -57168,7 +57204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_alignr_epi32() {
+    const fn test_mm256_maskz_alignr_epi32() {
         let a = _mm256_set_epi32(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm256_set_epi32(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm256_maskz_alignr_epi32::<1>(0, a, b);
@@ -57179,7 +57215,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_alignr_epi32() {
+    const fn test_mm_alignr_epi32() {
         let a = _mm_set_epi32(4, 3, 2, 1);
         let b = _mm_set_epi32(8, 7, 6, 5);
         let r = _mm_alignr_epi32::<0>(a, b);
@@ -57190,7 +57226,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_alignr_epi32() {
+    const fn test_mm_mask_alignr_epi32() {
         let a = _mm_set_epi32(4, 3, 2, 1);
         let b = _mm_set_epi32(8, 7, 6, 5);
         let r = _mm_mask_alignr_epi32::<1>(a, 0, a, b);
@@ -57201,7 +57237,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_alignr_epi32() {
+    const fn test_mm_maskz_alignr_epi32() {
         let a = _mm_set_epi32(4, 3, 2, 1);
         let b = _mm_set_epi32(8, 7, 6, 5);
         let r = _mm_maskz_alignr_epi32::<1>(0, a, b);
@@ -57212,7 +57248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_and_epi32() {
+    const fn test_mm512_and_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57233,7 +57269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_and_epi32() {
+    const fn test_mm512_mask_and_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57262,7 +57298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_and_epi32() {
+    const fn test_mm512_maskz_and_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57285,7 +57321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_and_epi32() {
+    const fn test_mm256_mask_and_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_mask_and_epi32(a, 0, a, b);
@@ -57296,7 +57332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_and_epi32() {
+    const fn test_mm256_maskz_and_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_maskz_and_epi32(0, a, b);
@@ -57307,7 +57343,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_and_epi32() {
+    const fn test_mm_mask_and_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_mask_and_epi32(a, 0, a, b);
@@ -57318,7 +57354,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_and_epi32() {
+    const fn test_mm_maskz_and_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_maskz_and_epi32(0, a, b);
@@ -57329,7 +57365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_and_si512() {
+    const fn test_mm512_and_si512() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57344,13 +57380,13 @@ mod tests {
             0, 0, 0, 0,
             0, 0, 0, 1 << 3 | 1 << 4,
         );
-        let r = _mm512_and_epi32(a, b);
+        let r = _mm512_and_si512(a, b);
         let e = _mm512_set_epi32(1 << 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 << 3);
         assert_eq_m512i(r, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_or_epi32() {
+    const fn test_mm512_or_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57377,7 +57413,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_or_epi32() {
+    const fn test_mm512_mask_or_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57406,7 +57442,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_or_epi32() {
+    const fn test_mm512_maskz_or_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57435,7 +57471,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_or_epi32() {
+    const fn test_mm256_or_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_or_epi32(a, b);
@@ -57444,7 +57480,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_or_epi32() {
+    const fn test_mm256_mask_or_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_mask_or_epi32(a, 0, a, b);
@@ -57455,7 +57491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_or_epi32() {
+    const fn test_mm256_maskz_or_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_maskz_or_epi32(0, a, b);
@@ -57466,7 +57502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_or_epi32() {
+    const fn test_mm_or_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_or_epi32(a, b);
@@ -57475,7 +57511,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_or_epi32() {
+    const fn test_mm_mask_or_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_mask_or_epi32(a, 0, a, b);
@@ -57486,7 +57522,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_or_epi32() {
+    const fn test_mm_maskz_or_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_maskz_or_epi32(0, a, b);
@@ -57497,7 +57533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_or_si512() {
+    const fn test_mm512_or_si512() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57512,7 +57548,7 @@ mod tests {
             0, 0, 0, 0,
             0, 0, 0, 1 << 3 | 1 << 4,
         );
-        let r = _mm512_or_epi32(a, b);
+        let r = _mm512_or_si512(a, b);
         #[rustfmt::skip]
         let e = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57524,7 +57560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_xor_epi32() {
+    const fn test_mm512_xor_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57551,7 +57587,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_xor_epi32() {
+    const fn test_mm512_mask_xor_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57580,7 +57616,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_xor_epi32() {
+    const fn test_mm512_maskz_xor_epi32() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57603,7 +57639,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_xor_epi32() {
+    const fn test_mm256_xor_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_xor_epi32(a, b);
@@ -57612,7 +57648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_xor_epi32() {
+    const fn test_mm256_mask_xor_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_mask_xor_epi32(a, 0, a, b);
@@ -57623,7 +57659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_xor_epi32() {
+    const fn test_mm256_maskz_xor_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_maskz_xor_epi32(0, a, b);
@@ -57634,7 +57670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_xor_epi32() {
+    const fn test_mm_xor_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_xor_epi32(a, b);
@@ -57643,7 +57679,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_xor_epi32() {
+    const fn test_mm_mask_xor_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_mask_xor_epi32(a, 0, a, b);
@@ -57654,7 +57690,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_xor_epi32() {
+    const fn test_mm_maskz_xor_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_maskz_xor_epi32(0, a, b);
@@ -57665,7 +57701,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_xor_si512() {
+    const fn test_mm512_xor_si512() {
         #[rustfmt::skip]
         let a = _mm512_set_epi32(
             1 << 1 | 1 << 2, 0, 0, 0,
@@ -57680,7 +57716,7 @@ mod tests {
             0, 0, 0, 0,
             0, 0, 0, 1 << 3 | 1 << 4,
         );
-        let r = _mm512_xor_epi32(a, b);
+        let r = _mm512_xor_si512(a, b);
         #[rustfmt::skip]
         let e = _mm512_set_epi32(
             1 << 2, 0, 0, 0,
@@ -57692,7 +57728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_andnot_epi32() {
+    const fn test_mm512_andnot_epi32() {
         let a = _mm512_set1_epi32(0);
         let b = _mm512_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm512_andnot_epi32(a, b);
@@ -57701,7 +57737,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_andnot_epi32() {
+    const fn test_mm512_mask_andnot_epi32() {
         let a = _mm512_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm512_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm512_mask_andnot_epi32(a, 0, a, b);
@@ -57712,7 +57748,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_andnot_epi32() {
+    const fn test_mm512_maskz_andnot_epi32() {
         let a = _mm512_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm512_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm512_maskz_andnot_epi32(0, a, b);
@@ -57729,7 +57765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_andnot_epi32() {
+    const fn test_mm256_mask_andnot_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm256_mask_andnot_epi32(a, 0, a, b);
@@ -57740,7 +57776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_andnot_epi32() {
+    const fn test_mm256_maskz_andnot_epi32() {
         let a = _mm256_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm256_maskz_andnot_epi32(0, a, b);
@@ -57751,7 +57787,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_andnot_epi32() {
+    const fn test_mm_mask_andnot_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm_mask_andnot_epi32(a, 0, a, b);
@@ -57762,7 +57798,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_andnot_epi32() {
+    const fn test_mm_maskz_andnot_epi32() {
         let a = _mm_set1_epi32(1 << 1 | 1 << 2);
         let b = _mm_set1_epi32(1 << 3 | 1 << 4);
         let r = _mm_maskz_andnot_epi32(0, a, b);
@@ -57773,7 +57809,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_cvtmask16_u32() {
+    const fn test_cvtmask16_u32() {
         let a: __mmask16 = 0b11001100_00110011;
         let r = _cvtmask16_u32(a);
         let e: u32 = 0b11001100_00110011;
@@ -57781,7 +57817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_cvtu32_mask16() {
+    const fn test_cvtu32_mask16() {
         let a: u32 = 0b11001100_00110011;
         let r = _cvtu32_mask16(a);
         let e: __mmask16 = 0b11001100_00110011;
@@ -57789,7 +57825,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kand() {
+    const fn test_mm512_kand() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b11001100_00110011;
         let r = _mm512_kand(a, b);
@@ -57798,7 +57834,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kand_mask16() {
+    const fn test_kand_mask16() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b11001100_00110011;
         let r = _kand_mask16(a, b);
@@ -57807,7 +57843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kor() {
+    const fn test_mm512_kor() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kor(a, b);
@@ -57816,7 +57852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kor_mask16() {
+    const fn test_kor_mask16() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _kor_mask16(a, b);
@@ -57825,7 +57861,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kxor() {
+    const fn test_mm512_kxor() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kxor(a, b);
@@ -57834,7 +57870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kxor_mask16() {
+    const fn test_kxor_mask16() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _kxor_mask16(a, b);
@@ -57843,7 +57879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_knot() {
+    const fn test_mm512_knot() {
         let a: u16 = 0b11001100_00110011;
         let r = _mm512_knot(a);
         let e: u16 = 0b00110011_11001100;
@@ -57851,7 +57887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_knot_mask16() {
+    const fn test_knot_mask16() {
         let a: u16 = 0b11001100_00110011;
         let r = _knot_mask16(a);
         let e: u16 = 0b00110011_11001100;
@@ -57859,7 +57895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kandn() {
+    const fn test_mm512_kandn() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kandn(a, b);
@@ -57868,7 +57904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kandn_mask16() {
+    const fn test_kandn_mask16() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _kandn_mask16(a, b);
@@ -57877,7 +57913,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kxnor() {
+    const fn test_mm512_kxnor() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kxnor(a, b);
@@ -57886,7 +57922,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kxnor_mask16() {
+    const fn test_kxnor_mask16() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _kxnor_mask16(a, b);
@@ -57905,7 +57941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kortestc_mask16_u8() {
+    const fn test_kortestc_mask16_u8() {
         let a: __mmask16 = 0b0110100101101001;
         let b: __mmask16 = 0b1011011010110110;
         let r = _kortestc_mask16_u8(a, b);
@@ -57913,7 +57949,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kortestz_mask16_u8() {
+    const fn test_kortestz_mask16_u8() {
         let a: __mmask16 = 0b0110100101101001;
         let b: __mmask16 = 0b1011011010110110;
         let r = _kortestz_mask16_u8(a, b);
@@ -57921,7 +57957,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kshiftli_mask16() {
+    const fn test_kshiftli_mask16() {
         let a: __mmask16 = 0b1001011011000011;
         let r = _kshiftli_mask16::<3>(a);
         let e: __mmask16 = 0b1011011000011000;
@@ -57941,7 +57977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_kshiftri_mask16() {
+    const fn test_kshiftri_mask16() {
         let a: __mmask16 = 0b1010100100111100;
         let r = _kshiftri_mask16::<3>(a);
         let e: __mmask16 = 0b0001010100100111;
@@ -57978,7 +58014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kmov() {
+    const fn test_mm512_kmov() {
         let a: u16 = 0b11001100_00110011;
         let r = _mm512_kmov(a);
         let e: u16 = 0b11001100_00110011;
@@ -57986,7 +58022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_int2mask() {
+    const fn test_mm512_int2mask() {
         let a: i32 = 0b11001100_00110011;
         let r = _mm512_int2mask(a);
         let e: u16 = 0b11001100_00110011;
@@ -57994,7 +58030,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask2int() {
+    const fn test_mm512_mask2int() {
         let k1: __mmask16 = 0b11001100_00110011;
         let r = _mm512_mask2int(k1);
         let e: i32 = 0b11001100_00110011;
@@ -58002,7 +58038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kunpackb() {
+    const fn test_mm512_kunpackb() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kunpackb(a, b);
@@ -58011,7 +58047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kortestc() {
+    const fn test_mm512_kortestc() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kortestc(a, b);
@@ -58022,7 +58058,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_kortestz() {
+    const fn test_mm512_kortestz() {
         let a: u16 = 0b11001100_00110011;
         let b: u16 = 0b00101110_00001011;
         let r = _mm512_kortestz(a, b);
@@ -58032,7 +58068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_test_epi32_mask() {
+    const fn test_mm512_test_epi32_mask() {
         let a = _mm512_set1_epi32(1 << 0);
         let b = _mm512_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm512_test_epi32_mask(a, b);
@@ -58041,7 +58077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_test_epi32_mask() {
+    const fn test_mm512_mask_test_epi32_mask() {
         let a = _mm512_set1_epi32(1 << 0);
         let b = _mm512_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm512_mask_test_epi32_mask(0, a, b);
@@ -58052,7 +58088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_test_epi32_mask() {
+    const fn test_mm256_test_epi32_mask() {
         let a = _mm256_set1_epi32(1 << 0);
         let b = _mm256_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm256_test_epi32_mask(a, b);
@@ -58061,7 +58097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_test_epi32_mask() {
+    const fn test_mm256_mask_test_epi32_mask() {
         let a = _mm256_set1_epi32(1 << 0);
         let b = _mm256_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm256_mask_test_epi32_mask(0, a, b);
@@ -58072,7 +58108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_test_epi32_mask() {
+    const fn test_mm_test_epi32_mask() {
         let a = _mm_set1_epi32(1 << 0);
         let b = _mm_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm_test_epi32_mask(a, b);
@@ -58081,7 +58117,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_test_epi32_mask() {
+    const fn test_mm_mask_test_epi32_mask() {
         let a = _mm_set1_epi32(1 << 0);
         let b = _mm_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm_mask_test_epi32_mask(0, a, b);
@@ -58092,7 +58128,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_testn_epi32_mask() {
+    const fn test_mm512_testn_epi32_mask() {
         let a = _mm512_set1_epi32(1 << 0);
         let b = _mm512_set1_epi32(1 << 0 | 1 << 1);
         let r = _mm512_testn_epi32_mask(a, b);
@@ -58101,7 +58137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_testn_epi32_mask() {
+    const fn test_mm512_mask_testn_epi32_mask() {
         let a = _mm512_set1_epi32(1 << 0);
         let b = _mm512_set1_epi32(1 << 1);
         let r = _mm512_mask_test_epi32_mask(0, a, b);
@@ -58112,7 +58148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_testn_epi32_mask() {
+    const fn test_mm256_testn_epi32_mask() {
         let a = _mm256_set1_epi32(1 << 0);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_testn_epi32_mask(a, b);
@@ -58121,7 +58157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_testn_epi32_mask() {
+    const fn test_mm256_mask_testn_epi32_mask() {
         let a = _mm256_set1_epi32(1 << 0);
         let b = _mm256_set1_epi32(1 << 1);
         let r = _mm256_mask_test_epi32_mask(0, a, b);
@@ -58132,7 +58168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_testn_epi32_mask() {
+    const fn test_mm_testn_epi32_mask() {
         let a = _mm_set1_epi32(1 << 0);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_testn_epi32_mask(a, b);
@@ -58141,7 +58177,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_testn_epi32_mask() {
+    const fn test_mm_mask_testn_epi32_mask() {
         let a = _mm_set1_epi32(1 << 0);
         let b = _mm_set1_epi32(1 << 1);
         let r = _mm_mask_test_epi32_mask(0, a, b);
@@ -58210,91 +58246,91 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_add_epi32() {
+    const fn test_mm512_reduce_add_epi32() {
         let a = _mm512_set1_epi32(1);
         let e: i32 = _mm512_reduce_add_epi32(a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_add_epi32() {
+    const fn test_mm512_mask_reduce_add_epi32() {
         let a = _mm512_set1_epi32(1);
         let e: i32 = _mm512_mask_reduce_add_epi32(0b11111111_00000000, a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_add_ps() {
+    const fn test_mm512_reduce_add_ps() {
         let a = _mm512_set1_ps(1.);
         let e: f32 = _mm512_reduce_add_ps(a);
         assert_eq!(16., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_add_ps() {
+    const fn test_mm512_mask_reduce_add_ps() {
         let a = _mm512_set1_ps(1.);
         let e: f32 = _mm512_mask_reduce_add_ps(0b11111111_00000000, a);
         assert_eq!(8., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_mul_epi32() {
+    const fn test_mm512_reduce_mul_epi32() {
         let a = _mm512_set1_epi32(2);
         let e: i32 = _mm512_reduce_mul_epi32(a);
         assert_eq!(65536, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_mul_epi32() {
+    const fn test_mm512_mask_reduce_mul_epi32() {
         let a = _mm512_set1_epi32(2);
         let e: i32 = _mm512_mask_reduce_mul_epi32(0b11111111_00000000, a);
         assert_eq!(256, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_mul_ps() {
+    const fn test_mm512_reduce_mul_ps() {
         let a = _mm512_set1_ps(2.);
         let e: f32 = _mm512_reduce_mul_ps(a);
         assert_eq!(65536., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_mul_ps() {
+    const fn test_mm512_mask_reduce_mul_ps() {
         let a = _mm512_set1_ps(2.);
         let e: f32 = _mm512_mask_reduce_mul_ps(0b11111111_00000000, a);
         assert_eq!(256., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_max_epi32() {
+    const fn test_mm512_reduce_max_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i32 = _mm512_reduce_max_epi32(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_max_epi32() {
+    const fn test_mm512_mask_reduce_max_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i32 = _mm512_mask_reduce_max_epi32(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_max_epu32() {
+    const fn test_mm512_reduce_max_epu32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u32 = _mm512_reduce_max_epu32(a);
         assert_eq!(15, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_max_epu32() {
+    const fn test_mm512_mask_reduce_max_epu32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u32 = _mm512_mask_reduce_max_epu32(0b11111111_00000000, a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_reduce_max_ps() {
+    fn test_mm512_reduce_max_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58303,7 +58339,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_reduce_max_ps() {
+    fn test_mm512_mask_reduce_max_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58312,35 +58348,35 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_min_epi32() {
+    const fn test_mm512_reduce_min_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i32 = _mm512_reduce_min_epi32(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_min_epi32() {
+    const fn test_mm512_mask_reduce_min_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: i32 = _mm512_mask_reduce_min_epi32(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_min_epu32() {
+    const fn test_mm512_reduce_min_epu32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u32 = _mm512_reduce_min_epu32(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_min_epu32() {
+    const fn test_mm512_mask_reduce_min_epu32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let e: u32 = _mm512_mask_reduce_min_epu32(0b11111111_00000000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_reduce_min_ps() {
+    fn test_mm512_reduce_min_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58349,7 +58385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_reduce_min_ps() {
+    fn test_mm512_mask_reduce_min_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58358,35 +58394,35 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_and_epi32() {
+    const fn test_mm512_reduce_and_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e: i32 = _mm512_reduce_and_epi32(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_and_epi32() {
+    const fn test_mm512_mask_reduce_and_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e: i32 = _mm512_mask_reduce_and_epi32(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_or_epi32() {
+    const fn test_mm512_reduce_or_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e: i32 = _mm512_reduce_or_epi32(a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_or_epi32() {
+    const fn test_mm512_mask_reduce_or_epi32() {
         let a = _mm512_set_epi32(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2);
         let e: i32 = _mm512_mask_reduce_and_epi32(0b11111111_00000000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_compress_epi32() {
+    fn test_mm512_mask_compress_epi32() {
         let src = _mm512_set1_epi32(200);
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_mask_compress_epi32(src, 0, a);
@@ -58399,7 +58435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_compress_epi32() {
+    fn test_mm512_maskz_compress_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_compress_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -58409,7 +58445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_compress_epi32() {
+    fn test_mm256_mask_compress_epi32() {
         let src = _mm256_set1_epi32(200);
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_mask_compress_epi32(src, 0, a);
@@ -58420,7 +58456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_epi32() {
+    fn test_mm256_maskz_compress_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_compress_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -58430,7 +58466,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_compress_epi32() {
+    fn test_mm_mask_compress_epi32() {
         let src = _mm_set1_epi32(200);
         let a = _mm_set_epi32(0, 1, 2, 3);
         let r = _mm_mask_compress_epi32(src, 0, a);
@@ -58441,7 +58477,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_compress_epi32() {
+    fn test_mm_maskz_compress_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let r = _mm_maskz_compress_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -58451,7 +58487,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_compress_ps() {
+    fn test_mm512_mask_compress_ps() {
         let src = _mm512_set1_ps(200.);
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -58466,7 +58502,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_compress_ps() {
+    fn test_mm512_maskz_compress_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58480,7 +58516,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_compress_ps() {
+    fn test_mm256_mask_compress_ps() {
         let src = _mm256_set1_ps(200.);
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_mask_compress_ps(src, 0, a);
@@ -58491,7 +58527,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_ps() {
+    fn test_mm256_maskz_compress_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_maskz_compress_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -58501,7 +58537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_compress_ps() {
+    fn test_mm_mask_compress_ps() {
         let src = _mm_set1_ps(200.);
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_mask_compress_ps(src, 0, a);
@@ -58512,7 +58548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_compress_ps() {
+    fn test_mm_maskz_compress_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_maskz_compress_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -58667,7 +58703,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_expand_epi32() {
+    fn test_mm512_maskz_expand_epi32() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_expand_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -58677,7 +58713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_expand_epi32() {
+    fn test_mm256_mask_expand_epi32() {
         let src = _mm256_set1_epi32(200);
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_mask_expand_epi32(src, 0, a);
@@ -58688,7 +58724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_epi32() {
+    fn test_mm256_maskz_expand_epi32() {
         let a = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm256_maskz_expand_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -58698,7 +58734,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_expand_epi32() {
+    fn test_mm_mask_expand_epi32() {
         let src = _mm_set1_epi32(200);
         let a = _mm_set_epi32(0, 1, 2, 3);
         let r = _mm_mask_expand_epi32(src, 0, a);
@@ -58709,7 +58745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_expand_epi32() {
+    fn test_mm_maskz_expand_epi32() {
         let a = _mm_set_epi32(0, 1, 2, 3);
         let r = _mm_maskz_expand_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -58719,7 +58755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_expand_ps() {
+    fn test_mm512_mask_expand_ps() {
         let src = _mm512_set1_ps(200.);
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
@@ -58734,7 +58770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_expand_ps() {
+    fn test_mm512_maskz_expand_ps() {
         let a = _mm512_set_ps(
             0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.,
         );
@@ -58748,7 +58784,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_expand_ps() {
+    fn test_mm256_mask_expand_ps() {
         let src = _mm256_set1_ps(200.);
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_mask_expand_ps(src, 0, a);
@@ -58759,7 +58795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_ps() {
+    fn test_mm256_maskz_expand_ps() {
         let a = _mm256_set_ps(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm256_maskz_expand_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -58769,7 +58805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_expand_ps() {
+    fn test_mm_mask_expand_ps() {
         let src = _mm_set1_ps(200.);
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_mask_expand_ps(src, 0, a);
@@ -58780,7 +58816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_expand_ps() {
+    fn test_mm_maskz_expand_ps() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let r = _mm_maskz_expand_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -59170,7 +59206,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_set1_epi32() {
+    const fn test_mm512_mask_set1_epi32() {
         let src = _mm512_set1_epi32(2);
         let a: i32 = 11;
         let r = _mm512_mask_set1_epi32(src, 0, a);
@@ -59181,7 +59217,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_set1_epi32() {
+    const fn test_mm512_maskz_set1_epi32() {
         let a: i32 = 11;
         let r = _mm512_maskz_set1_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -59191,7 +59227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_set1_epi32() {
+    const fn test_mm256_mask_set1_epi32() {
         let src = _mm256_set1_epi32(2);
         let a: i32 = 11;
         let r = _mm256_mask_set1_epi32(src, 0, a);
@@ -59202,7 +59238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_set1_epi32() {
+    const fn test_mm256_maskz_set1_epi32() {
         let a: i32 = 11;
         let r = _mm256_maskz_set1_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -59212,7 +59248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_set1_epi32() {
+    const fn test_mm_mask_set1_epi32() {
         let src = _mm_set1_epi32(2);
         let a: i32 = 11;
         let r = _mm_mask_set1_epi32(src, 0, a);
@@ -59223,7 +59259,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_set1_epi32() {
+    const fn test_mm_maskz_set1_epi32() {
         let a: i32 = 11;
         let r = _mm_maskz_set1_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -59233,7 +59269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_move_ss() {
+    const fn test_mm_mask_move_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -59246,7 +59282,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_move_ss() {
+    const fn test_mm_maskz_move_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_move_ss(0, a, b);
@@ -59258,7 +59294,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_move_sd() {
+    const fn test_mm_mask_move_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59271,7 +59307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_move_sd() {
+    const fn test_mm_maskz_move_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_move_sd(0, a, b);
@@ -59283,7 +59319,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_add_ss() {
+    const fn test_mm_mask_add_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -59296,7 +59332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_add_ss() {
+    const fn test_mm_maskz_add_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_add_ss(0, a, b);
@@ -59308,7 +59344,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_add_sd() {
+    const fn test_mm_mask_add_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59321,7 +59357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_add_sd() {
+    const fn test_mm_maskz_add_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_add_sd(0, a, b);
@@ -59333,7 +59369,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_sub_ss() {
+    const fn test_mm_mask_sub_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -59346,7 +59382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_sub_ss() {
+    const fn test_mm_maskz_sub_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_sub_ss(0, a, b);
@@ -59358,7 +59394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_sub_sd() {
+    const fn test_mm_mask_sub_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59371,7 +59407,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_sub_sd() {
+    const fn test_mm_maskz_sub_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_sub_sd(0, a, b);
@@ -59383,7 +59419,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_mul_ss() {
+    const fn test_mm_mask_mul_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -59396,7 +59432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_mul_ss() {
+    const fn test_mm_maskz_mul_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_mul_ss(0, a, b);
@@ -59408,7 +59444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_mul_sd() {
+    const fn test_mm_mask_mul_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59421,7 +59457,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_mul_sd() {
+    const fn test_mm_maskz_mul_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_mul_sd(0, a, b);
@@ -59433,7 +59469,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_div_ss() {
+    const fn test_mm_mask_div_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -59446,7 +59482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_div_ss() {
+    const fn test_mm_maskz_div_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_div_ss(0, a, b);
@@ -59458,7 +59494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_div_sd() {
+    const fn test_mm_mask_div_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59471,7 +59507,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_div_sd() {
+    const fn test_mm_maskz_div_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_div_sd(0, a, b);
@@ -59483,7 +59519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_max_ss() {
+    fn test_mm_mask_max_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_mask_max_ss(a, 0, a, b);
@@ -59495,7 +59531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_max_ss() {
+    fn test_mm_maskz_max_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_maskz_max_ss(0, a, b);
@@ -59507,7 +59543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_max_sd() {
+    fn test_mm_mask_max_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_mask_max_sd(a, 0, a, b);
@@ -59519,7 +59555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_max_sd() {
+    fn test_mm_maskz_max_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_maskz_max_sd(0, a, b);
@@ -59531,7 +59567,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_min_ss() {
+    fn test_mm_mask_min_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_mask_min_ss(a, 0, a, b);
@@ -59543,7 +59579,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_min_ss() {
+    fn test_mm_maskz_min_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_maskz_min_ss(0, a, b);
@@ -59555,7 +59591,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_min_sd() {
+    fn test_mm_mask_min_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_mask_min_sd(a, 0, a, b);
@@ -59567,7 +59603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_min_sd() {
+    fn test_mm_maskz_min_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_maskz_min_sd(0, a, b);
@@ -59579,7 +59615,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sqrt_ss() {
+    fn test_mm_mask_sqrt_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
@@ -59592,7 +59628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sqrt_ss() {
+    fn test_mm_maskz_sqrt_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_maskz_sqrt_ss(0, a, b);
@@ -59604,7 +59640,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sqrt_sd() {
+    fn test_mm_mask_sqrt_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59617,7 +59653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sqrt_sd() {
+    fn test_mm_maskz_sqrt_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_sqrt_sd(0, a, b);
@@ -59629,7 +59665,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_rsqrt14_ss() {
+    fn test_mm_rsqrt14_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_rsqrt14_ss(a, b);
@@ -59638,7 +59674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_rsqrt14_ss() {
+    fn test_mm_mask_rsqrt14_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
@@ -59651,7 +59687,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_rsqrt14_ss() {
+    fn test_mm_maskz_rsqrt14_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_maskz_rsqrt14_ss(0, a, b);
@@ -59663,7 +59699,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_rsqrt14_sd() {
+    fn test_mm_rsqrt14_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_rsqrt14_sd(a, b);
@@ -59672,7 +59708,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_rsqrt14_sd() {
+    fn test_mm_mask_rsqrt14_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59685,7 +59721,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_rsqrt14_sd() {
+    fn test_mm_maskz_rsqrt14_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_rsqrt14_sd(0, a, b);
@@ -59697,7 +59733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_rcp14_ss() {
+    fn test_mm_rcp14_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_rcp14_ss(a, b);
@@ -59706,7 +59742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_rcp14_ss() {
+    fn test_mm_mask_rcp14_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
@@ -59719,7 +59755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_rcp14_ss() {
+    fn test_mm_maskz_rcp14_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_maskz_rcp14_ss(0, a, b);
@@ -59731,7 +59767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_rcp14_sd() {
+    fn test_mm_rcp14_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_rcp14_sd(a, b);
@@ -59740,7 +59776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_rcp14_sd() {
+    fn test_mm_mask_rcp14_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -59753,7 +59789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_rcp14_sd() {
+    fn test_mm_maskz_rcp14_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_rcp14_sd(0, a, b);
@@ -59765,7 +59801,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getexp_ss() {
+    fn test_mm_getexp_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_getexp_ss(a, b);
@@ -59774,7 +59810,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getexp_ss() {
+    fn test_mm_mask_getexp_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_mask_getexp_ss(a, 0, a, b);
@@ -59786,7 +59822,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getexp_ss() {
+    fn test_mm_maskz_getexp_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_maskz_getexp_ss(0, a, b);
@@ -59798,7 +59834,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getexp_sd() {
+    fn test_mm_getexp_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_getexp_sd(a, b);
@@ -59807,7 +59843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getexp_sd() {
+    fn test_mm_mask_getexp_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_mask_getexp_sd(a, 0, a, b);
@@ -59819,7 +59855,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getexp_sd() {
+    fn test_mm_maskz_getexp_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_maskz_getexp_sd(0, a, b);
@@ -59831,7 +59867,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getmant_ss() {
+    fn test_mm_getmant_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r = _mm_getmant_ss::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, b);
@@ -59840,7 +59876,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getmant_ss() {
+    fn test_mm_mask_getmant_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r = _mm_mask_getmant_ss::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a, b);
@@ -59852,7 +59888,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getmant_ss() {
+    fn test_mm_maskz_getmant_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r = _mm_maskz_getmant_ss::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a, b);
@@ -59864,7 +59900,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getmant_sd() {
+    fn test_mm_getmant_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r = _mm_getmant_sd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, b);
@@ -59873,7 +59909,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getmant_sd() {
+    fn test_mm_mask_getmant_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r = _mm_mask_getmant_sd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a, b);
@@ -59885,7 +59921,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getmant_sd() {
+    fn test_mm_maskz_getmant_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r = _mm_maskz_getmant_sd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a, b);
@@ -59897,7 +59933,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_roundscale_ss() {
+    fn test_mm_roundscale_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_roundscale_ss::<0>(a, b);
@@ -59906,7 +59942,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_roundscale_ss() {
+    fn test_mm_mask_roundscale_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_mask_roundscale_ss::<0>(a, 0, a, b);
@@ -59918,7 +59954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_roundscale_ss() {
+    fn test_mm_maskz_roundscale_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_maskz_roundscale_ss::<0>(0, a, b);
@@ -59930,7 +59966,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_roundscale_sd() {
+    fn test_mm_roundscale_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_roundscale_sd::<0>(a, b);
@@ -59939,7 +59975,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_roundscale_sd() {
+    fn test_mm_mask_roundscale_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_mask_roundscale_sd::<0>(a, 0, a, b);
@@ -59951,7 +59987,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_roundscale_sd() {
+    fn test_mm_maskz_roundscale_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_maskz_roundscale_sd::<0>(0, a, b);
@@ -59963,7 +59999,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_scalef_ss() {
+    fn test_mm_scalef_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_scalef_ss(a, b);
@@ -59972,7 +60008,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_scalef_ss() {
+    fn test_mm_mask_scalef_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_mask_scalef_ss(a, 0, a, b);
@@ -59984,7 +60020,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_scalef_ss() {
+    fn test_mm_maskz_scalef_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_maskz_scalef_ss(0, a, b);
@@ -59996,7 +60032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_scalef_sd() {
+    fn test_mm_scalef_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_scalef_sd(a, b);
@@ -60005,7 +60041,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_scalef_sd() {
+    fn test_mm_mask_scalef_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_mask_scalef_sd(a, 0, a, b);
@@ -60017,7 +60053,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_scalef_sd() {
+    fn test_mm_maskz_scalef_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_maskz_scalef_sd(0, a, b);
@@ -60029,7 +60065,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fmadd_ss() {
+    const fn test_mm_mask_fmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60041,7 +60077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fmadd_ss() {
+    const fn test_mm_maskz_fmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60054,7 +60090,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fmadd_ss() {
+    const fn test_mm_mask3_fmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60066,7 +60102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fmadd_sd() {
+    const fn test_mm_mask_fmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60078,7 +60114,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fmadd_sd() {
+    const fn test_mm_maskz_fmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60091,7 +60127,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fmadd_sd() {
+    const fn test_mm_mask3_fmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60103,7 +60139,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fmsub_ss() {
+    const fn test_mm_mask_fmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60115,7 +60151,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fmsub_ss() {
+    const fn test_mm_maskz_fmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60128,7 +60164,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fmsub_ss() {
+    const fn test_mm_mask3_fmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60140,7 +60176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fmsub_sd() {
+    const fn test_mm_mask_fmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60152,7 +60188,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fmsub_sd() {
+    const fn test_mm_maskz_fmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60165,7 +60201,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fmsub_sd() {
+    const fn test_mm_mask3_fmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60177,7 +60213,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fnmadd_ss() {
+    const fn test_mm_mask_fnmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60189,7 +60225,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fnmadd_ss() {
+    const fn test_mm_maskz_fnmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60202,7 +60238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fnmadd_ss() {
+    const fn test_mm_mask3_fnmadd_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60214,7 +60250,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fnmadd_sd() {
+    const fn test_mm_mask_fnmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60226,7 +60262,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fnmadd_sd() {
+    const fn test_mm_maskz_fnmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60239,7 +60275,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fnmadd_sd() {
+    const fn test_mm_mask3_fnmadd_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60251,7 +60287,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fnmsub_ss() {
+    const fn test_mm_mask_fnmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60263,7 +60299,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fnmsub_ss() {
+    const fn test_mm_maskz_fnmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60276,7 +60312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fnmsub_ss() {
+    const fn test_mm_mask3_fnmsub_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -60288,7 +60324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask_fnmsub_sd() {
+    const fn test_mm_mask_fnmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60300,7 +60336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_maskz_fnmsub_sd() {
+    const fn test_mm_maskz_fnmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60313,7 +60349,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_mask3_fnmsub_sd() {
+    const fn test_mm_mask3_fnmsub_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -60325,7 +60361,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_add_round_ss() {
+    fn test_mm_add_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_add_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60334,7 +60370,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_add_round_ss() {
+    fn test_mm_mask_add_round_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -60349,7 +60385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_add_round_ss() {
+    fn test_mm_maskz_add_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_add_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60362,7 +60398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_add_round_sd() {
+    fn test_mm_add_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_add_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60371,7 +60407,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_add_round_sd() {
+    fn test_mm_mask_add_round_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -60386,7 +60422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_add_round_sd() {
+    fn test_mm_maskz_add_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_add_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60399,7 +60435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_sub_round_ss() {
+    fn test_mm_sub_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_sub_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60408,7 +60444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sub_round_ss() {
+    fn test_mm_mask_sub_round_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -60423,7 +60459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sub_round_ss() {
+    fn test_mm_maskz_sub_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_sub_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60436,7 +60472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_sub_round_sd() {
+    fn test_mm_sub_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_sub_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60445,7 +60481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sub_round_sd() {
+    fn test_mm_mask_sub_round_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -60460,7 +60496,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sub_round_sd() {
+    fn test_mm_maskz_sub_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_sub_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60473,7 +60509,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mul_round_ss() {
+    fn test_mm_mul_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_mul_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60482,7 +60518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_mul_round_ss() {
+    fn test_mm_mask_mul_round_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -60497,7 +60533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_mul_round_ss() {
+    fn test_mm_maskz_mul_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_mul_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60510,7 +60546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mul_round_sd() {
+    fn test_mm_mul_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_mul_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60519,7 +60555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_mul_round_sd() {
+    fn test_mm_mask_mul_round_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -60534,7 +60570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_mul_round_sd() {
+    fn test_mm_maskz_mul_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_mul_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60547,7 +60583,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_div_round_ss() {
+    fn test_mm_div_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_div_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60556,7 +60592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_div_round_ss() {
+    fn test_mm_mask_div_round_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
@@ -60571,7 +60607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_div_round_ss() {
+    fn test_mm_maskz_div_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 40.);
         let r = _mm_maskz_div_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60584,7 +60620,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_div_round_sd() {
+    fn test_mm_div_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_div_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60593,7 +60629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_div_round_sd() {
+    fn test_mm_mask_div_round_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -60608,7 +60644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_div_round_sd() {
+    fn test_mm_maskz_div_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_div_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60621,7 +60657,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_max_round_ss() {
+    fn test_mm_max_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_max_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60630,7 +60666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_max_round_ss() {
+    fn test_mm_mask_max_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_mask_max_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60642,7 +60678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_max_round_ss() {
+    fn test_mm_maskz_max_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_maskz_max_round_ss::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60654,7 +60690,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_max_round_sd() {
+    fn test_mm_max_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_max_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60663,7 +60699,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_max_round_sd() {
+    fn test_mm_mask_max_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_mask_max_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60675,7 +60711,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_max_round_sd() {
+    fn test_mm_maskz_max_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_maskz_max_round_sd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60687,7 +60723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_min_round_ss() {
+    fn test_mm_min_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_min_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60696,7 +60732,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_min_round_ss() {
+    fn test_mm_mask_min_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_mask_min_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60708,7 +60744,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_min_round_ss() {
+    fn test_mm_maskz_min_round_ss() {
         let a = _mm_set_ps(0., 1., 2., 3.);
         let b = _mm_set_ps(4., 5., 6., 7.);
         let r = _mm_maskz_min_round_ss::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60720,7 +60756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_min_round_sd() {
+    fn test_mm_min_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_min_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60729,7 +60765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_min_round_sd() {
+    fn test_mm_mask_min_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_mask_min_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60741,7 +60777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_min_round_sd() {
+    fn test_mm_maskz_min_round_sd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_maskz_min_round_sd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60753,7 +60789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_sqrt_round_ss() {
+    fn test_mm_sqrt_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_sqrt_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60762,7 +60798,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sqrt_round_ss() {
+    fn test_mm_mask_sqrt_round_ss() {
         let src = _mm_set_ps(10., 11., 100., 110.);
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
@@ -60777,7 +60813,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sqrt_round_ss() {
+    fn test_mm_maskz_sqrt_round_ss() {
         let a = _mm_set_ps(1., 2., 10., 20.);
         let b = _mm_set_ps(3., 4., 30., 4.);
         let r = _mm_maskz_sqrt_round_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60790,7 +60826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_sqrt_round_sd() {
+    fn test_mm_sqrt_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_sqrt_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -60799,7 +60835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_sqrt_round_sd() {
+    fn test_mm_mask_sqrt_round_sd() {
         let src = _mm_set_pd(10., 11.);
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
@@ -60814,7 +60850,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_sqrt_round_sd() {
+    fn test_mm_maskz_sqrt_round_sd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(3., 4.);
         let r = _mm_maskz_sqrt_round_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -60827,7 +60863,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getexp_round_ss() {
+    fn test_mm_getexp_round_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_getexp_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60836,7 +60872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getexp_round_ss() {
+    fn test_mm_mask_getexp_round_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_mask_getexp_round_ss::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60848,7 +60884,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getexp_round_ss() {
+    fn test_mm_maskz_getexp_round_ss() {
         let a = _mm_set1_ps(2.);
         let b = _mm_set1_ps(3.);
         let r = _mm_maskz_getexp_round_ss::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60860,7 +60896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getexp_round_sd() {
+    fn test_mm_getexp_round_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_getexp_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -60869,7 +60905,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getexp_round_sd() {
+    fn test_mm_mask_getexp_round_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_mask_getexp_round_sd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -60881,7 +60917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getexp_round_sd() {
+    fn test_mm_maskz_getexp_round_sd() {
         let a = _mm_set1_pd(2.);
         let b = _mm_set1_pd(3.);
         let r = _mm_maskz_getexp_round_sd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -60893,7 +60929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getmant_round_ss() {
+    fn test_mm_getmant_round_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r =
@@ -60905,7 +60941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getmant_round_ss() {
+    fn test_mm_mask_getmant_round_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r = _mm_mask_getmant_round_ss::<
@@ -60925,7 +60961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getmant_round_ss() {
+    fn test_mm_maskz_getmant_round_ss() {
         let a = _mm_set1_ps(20.);
         let b = _mm_set1_ps(10.);
         let r = _mm_maskz_getmant_round_ss::<
@@ -60945,7 +60981,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_getmant_round_sd() {
+    fn test_mm_getmant_round_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r =
@@ -60957,7 +60993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_getmant_round_sd() {
+    fn test_mm_mask_getmant_round_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r = _mm_mask_getmant_round_sd::<
@@ -60977,7 +61013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_getmant_round_sd() {
+    fn test_mm_maskz_getmant_round_sd() {
         let a = _mm_set1_pd(20.);
         let b = _mm_set1_pd(10.);
         let r = _mm_maskz_getmant_round_sd::<
@@ -60997,7 +61033,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_roundscale_round_ss() {
+    fn test_mm_roundscale_round_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_roundscale_round_ss::<0, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -61006,7 +61042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_roundscale_round_ss() {
+    fn test_mm_mask_roundscale_round_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_mask_roundscale_round_ss::<0, _MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -61018,7 +61054,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_roundscale_round_ss() {
+    fn test_mm_maskz_roundscale_round_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_maskz_roundscale_round_ss::<0, _MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -61030,7 +61066,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_roundscale_round_sd() {
+    fn test_mm_roundscale_round_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_roundscale_round_sd::<0, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -61039,7 +61075,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_roundscale_round_sd() {
+    fn test_mm_mask_roundscale_round_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_mask_roundscale_round_sd::<0, _MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -61051,7 +61087,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_roundscale_round_sd() {
+    fn test_mm_maskz_roundscale_round_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_maskz_roundscale_round_sd::<0, _MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -61063,7 +61099,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_scalef_round_ss() {
+    fn test_mm_scalef_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_scalef_round_ss::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -61072,7 +61108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_scalef_round_ss() {
+    fn test_mm_mask_scalef_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r = _mm_mask_scalef_round_ss::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -61088,7 +61124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_scalef_round_ss() {
+    fn test_mm_maskz_scalef_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(3.);
         let r =
@@ -61103,7 +61139,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_scalef_round_sd() {
+    fn test_mm_scalef_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_scalef_round_sd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -61112,7 +61148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_scalef_round_sd() {
+    fn test_mm_mask_scalef_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_mask_scalef_round_sd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -61128,7 +61164,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_scalef_round_sd() {
+    fn test_mm_maskz_scalef_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r =
@@ -61143,7 +61179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fmadd_round_ss() {
+    fn test_mm_fmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61153,7 +61189,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fmadd_round_ss() {
+    fn test_mm_mask_fmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61169,7 +61205,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fmadd_round_ss() {
+    fn test_mm_maskz_fmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61186,7 +61222,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fmadd_round_ss() {
+    fn test_mm_mask3_fmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61202,7 +61238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fmadd_round_sd() {
+    fn test_mm_fmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61212,7 +61248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fmadd_round_sd() {
+    fn test_mm_mask_fmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61228,7 +61264,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fmadd_round_sd() {
+    fn test_mm_maskz_fmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61245,7 +61281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fmadd_round_sd() {
+    fn test_mm_mask3_fmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61261,7 +61297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fmsub_round_ss() {
+    fn test_mm_fmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61271,7 +61307,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fmsub_round_ss() {
+    fn test_mm_mask_fmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61287,7 +61323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fmsub_round_ss() {
+    fn test_mm_maskz_fmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61304,7 +61340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fmsub_round_ss() {
+    fn test_mm_mask3_fmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61320,7 +61356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fmsub_round_sd() {
+    fn test_mm_fmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61330,7 +61366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fmsub_round_sd() {
+    fn test_mm_mask_fmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61346,7 +61382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fmsub_round_sd() {
+    fn test_mm_maskz_fmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61363,7 +61399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fmsub_round_sd() {
+    fn test_mm_mask3_fmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61379,7 +61415,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fnmadd_round_ss() {
+    fn test_mm_fnmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61389,7 +61425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fnmadd_round_ss() {
+    fn test_mm_mask_fnmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61405,7 +61441,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fnmadd_round_ss() {
+    fn test_mm_maskz_fnmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61422,7 +61458,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fnmadd_round_ss() {
+    fn test_mm_mask3_fnmadd_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61438,7 +61474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fnmadd_round_sd() {
+    fn test_mm_fnmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61448,7 +61484,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fnmadd_round_sd() {
+    fn test_mm_mask_fnmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61464,7 +61500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fnmadd_round_sd() {
+    fn test_mm_maskz_fnmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61481,7 +61517,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fnmadd_round_sd() {
+    fn test_mm_mask3_fnmadd_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61497,7 +61533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fnmsub_round_ss() {
+    fn test_mm_fnmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61507,7 +61543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fnmsub_round_ss() {
+    fn test_mm_mask_fnmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61523,7 +61559,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fnmsub_round_ss() {
+    fn test_mm_maskz_fnmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61540,7 +61576,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fnmsub_round_ss() {
+    fn test_mm_mask3_fnmsub_round_ss() {
         let a = _mm_set1_ps(1.);
         let b = _mm_set1_ps(2.);
         let c = _mm_set1_ps(3.);
@@ -61556,7 +61592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fnmsub_round_sd() {
+    fn test_mm_fnmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61566,7 +61602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fnmsub_round_sd() {
+    fn test_mm_mask_fnmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61582,7 +61618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fnmsub_round_sd() {
+    fn test_mm_maskz_fnmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61599,7 +61635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask3_fnmsub_round_sd() {
+    fn test_mm_mask3_fnmsub_round_sd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let c = _mm_set1_pd(3.);
@@ -61615,7 +61651,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fixupimm_ss() {
+    fn test_mm_fixupimm_ss() {
         let a = _mm_set_ps(0., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61625,7 +61661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fixupimm_ss() {
+    fn test_mm_mask_fixupimm_ss() {
         let a = _mm_set_ps(0., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61635,7 +61671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fixupimm_ss() {
+    fn test_mm_maskz_fixupimm_ss() {
         let a = _mm_set_ps(0., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61648,7 +61684,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fixupimm_sd() {
+    fn test_mm_fixupimm_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61658,7 +61694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fixupimm_sd() {
+    fn test_mm_mask_fixupimm_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61668,7 +61704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fixupimm_sd() {
+    fn test_mm_maskz_fixupimm_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61681,7 +61717,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fixupimm_round_ss() {
+    fn test_mm_fixupimm_round_ss() {
         let a = _mm_set_ps(1., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61691,7 +61727,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fixupimm_round_ss() {
+    fn test_mm_mask_fixupimm_round_ss() {
         let a = _mm_set_ps(0., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61701,7 +61737,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fixupimm_round_ss() {
+    fn test_mm_maskz_fixupimm_round_ss() {
         let a = _mm_set_ps(0., 0., 0., f32::NAN);
         let b = _mm_set1_ps(f32::MAX);
         let c = _mm_set1_epi32(i32::MAX);
@@ -61714,7 +61750,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_fixupimm_round_sd() {
+    fn test_mm_fixupimm_round_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61724,7 +61760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_fixupimm_round_sd() {
+    fn test_mm_mask_fixupimm_round_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61734,7 +61770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_fixupimm_round_sd() {
+    fn test_mm_maskz_fixupimm_round_sd() {
         let a = _mm_set_pd(0., f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -61747,7 +61783,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cvtss_sd() {
+    fn test_mm_mask_cvtss_sd() {
         let a = _mm_set_pd(6., -7.5);
         let b = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_mask_cvtss_sd(a, 0, a, b);
@@ -61758,7 +61794,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_cvtss_sd() {
+    fn test_mm_maskz_cvtss_sd() {
         let a = _mm_set_pd(6., -7.5);
         let b = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_maskz_cvtss_sd(0, a, b);
@@ -61770,7 +61806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cvtsd_ss() {
+    fn test_mm_mask_cvtsd_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b = _mm_set_pd(6., -7.5);
         let r = _mm_mask_cvtsd_ss(a, 0, a, b);
@@ -61781,7 +61817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_cvtsd_ss() {
+    fn test_mm_maskz_cvtsd_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b = _mm_set_pd(6., -7.5);
         let r = _mm_maskz_cvtsd_ss(0, a, b);
@@ -61793,7 +61829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_sd() {
+    fn test_mm_cvt_roundss_sd() {
         let a = _mm_set_pd(6., -7.5);
         let b = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_sd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -61802,7 +61838,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cvt_roundss_sd() {
+    fn test_mm_mask_cvt_roundss_sd() {
         let a = _mm_set_pd(6., -7.5);
         let b = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_mask_cvt_roundss_sd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -61813,7 +61849,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_cvt_roundss_sd() {
+    fn test_mm_maskz_cvt_roundss_sd() {
         let a = _mm_set_pd(6., -7.5);
         let b = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_maskz_cvt_roundss_sd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -61825,7 +61861,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_ss() {
+    fn test_mm_cvt_roundsd_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b = _mm_set_pd(6., -7.5);
         let r = _mm_cvt_roundsd_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -61834,7 +61870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_mask_cvt_roundsd_ss() {
+    fn test_mm_mask_cvt_roundsd_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b = _mm_set_pd(6., -7.5);
         let r = _mm_mask_cvt_roundsd_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, 0, a, b);
@@ -61847,7 +61883,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_maskz_cvt_roundsd_ss() {
+    fn test_mm_maskz_cvt_roundsd_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b = _mm_set_pd(6., -7.5);
         let r = _mm_maskz_cvt_roundsd_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(0, a, b);
@@ -61861,7 +61897,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_si32() {
+    fn test_mm_cvt_roundss_si32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_si32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i32 = -1;
@@ -61869,7 +61905,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_i32() {
+    fn test_mm_cvt_roundss_i32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_i32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i32 = -1;
@@ -61877,7 +61913,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_u32() {
+    fn test_mm_cvt_roundss_u32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_u32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: u32 = u32::MAX;
@@ -61885,7 +61921,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtss_i32() {
+    fn test_mm_cvtss_i32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtss_i32(a);
         let e: i32 = -2;
@@ -61893,7 +61929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtss_u32() {
+    fn test_mm_cvtss_u32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtss_u32(a);
         let e: u32 = u32::MAX;
@@ -61901,7 +61937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_si32() {
+    fn test_mm_cvt_roundsd_si32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvt_roundsd_si32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i32 = -1;
@@ -61909,7 +61945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_i32() {
+    fn test_mm_cvt_roundsd_i32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvt_roundsd_i32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i32 = -1;
@@ -61917,7 +61953,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_u32() {
+    fn test_mm_cvt_roundsd_u32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvt_roundsd_u32::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: u32 = u32::MAX;
@@ -61925,7 +61961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtsd_i32() {
+    fn test_mm_cvtsd_i32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtsd_i32(a);
         let e: i32 = -2;
@@ -61933,7 +61969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtsd_u32() {
+    fn test_mm_cvtsd_u32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtsd_u32(a);
         let e: u32 = u32::MAX;
@@ -61941,7 +61977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundi32_ss() {
+    fn test_mm_cvt_roundi32_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i32 = 9;
         let r = _mm_cvt_roundi32_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -61950,7 +61986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsi32_ss() {
+    fn test_mm_cvt_roundsi32_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i32 = 9;
         let r = _mm_cvt_roundsi32_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -61959,7 +61995,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundu32_ss() {
+    fn test_mm_cvt_roundu32_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: u32 = 9;
         let r = _mm_cvt_roundu32_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -61968,7 +62004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvti32_ss() {
+    const fn test_mm_cvti32_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i32 = 9;
         let r = _mm_cvti32_ss(a, b);
@@ -61977,7 +62013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvti32_sd() {
+    const fn test_mm_cvti32_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: i32 = 9;
         let r = _mm_cvti32_sd(a, b);
@@ -61986,7 +62022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_si32() {
+    fn test_mm_cvtt_roundss_si32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_si32::<_MM_FROUND_NO_EXC>(a);
         let e: i32 = -1;
@@ -61994,7 +62030,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_i32() {
+    fn test_mm_cvtt_roundss_i32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_i32::<_MM_FROUND_NO_EXC>(a);
         let e: i32 = -1;
@@ -62002,7 +62038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_u32() {
+    fn test_mm_cvtt_roundss_u32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_u32::<_MM_FROUND_NO_EXC>(a);
         let e: u32 = u32::MAX;
@@ -62010,7 +62046,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttss_i32() {
+    fn test_mm_cvttss_i32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvttss_i32(a);
         let e: i32 = -1;
@@ -62018,7 +62054,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttss_u32() {
+    fn test_mm_cvttss_u32() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvttss_u32(a);
         let e: u32 = u32::MAX;
@@ -62026,7 +62062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_si32() {
+    fn test_mm_cvtt_roundsd_si32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_si32::<_MM_FROUND_NO_EXC>(a);
         let e: i32 = -1;
@@ -62034,7 +62070,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_i32() {
+    fn test_mm_cvtt_roundsd_i32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_i32::<_MM_FROUND_NO_EXC>(a);
         let e: i32 = -1;
@@ -62042,7 +62078,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_u32() {
+    fn test_mm_cvtt_roundsd_u32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_u32::<_MM_FROUND_NO_EXC>(a);
         let e: u32 = u32::MAX;
@@ -62050,7 +62086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttsd_i32() {
+    fn test_mm_cvttsd_i32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvttsd_i32(a);
         let e: i32 = -1;
@@ -62058,7 +62094,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttsd_u32() {
+    fn test_mm_cvttsd_u32() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvttsd_u32(a);
         let e: u32 = u32::MAX;
@@ -62066,7 +62102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvtu32_ss() {
+    const fn test_mm_cvtu32_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: u32 = 9;
         let r = _mm_cvtu32_ss(a, b);
@@ -62075,7 +62111,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvtu32_sd() {
+    const fn test_mm_cvtu32_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: u32 = 9;
         let r = _mm_cvtu32_sd(a, b);
@@ -62084,7 +62120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_comi_round_ss() {
+    fn test_mm_comi_round_ss() {
         let a = _mm_set1_ps(2.2);
         let b = _mm_set1_ps(1.1);
         let r = _mm_comi_round_ss::<0, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -62093,7 +62129,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_comi_round_sd() {
+    fn test_mm_comi_round_sd() {
         let a = _mm_set1_pd(2.2);
         let b = _mm_set1_pd(1.1);
         let r = _mm_comi_round_sd::<0, _MM_FROUND_CUR_DIRECTION>(a, b);
@@ -62102,7 +62138,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtsi512_si32() {
+    const fn test_mm512_cvtsi512_si32() {
         let a = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_cvtsi512_si32(a);
         let e: i32 = 1;
@@ -62110,7 +62146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtss_f32() {
+    const fn test_mm512_cvtss_f32() {
         let a = _mm512_setr_ps(
             312.0134, 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
         );
@@ -62118,13 +62154,13 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtsd_f64() {
+    const fn test_mm512_cvtsd_f64() {
         let r = _mm512_cvtsd_f64(_mm512_setr_pd(-1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8));
         assert_eq!(r, -1.1);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_pd() {
+    const fn test_mm512_shuffle_pd() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 1., 4., 5., 8.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 2., 3., 6., 7.);
         let r = _mm512_shuffle_pd::<0b11_11_11_11>(a, b);
@@ -62133,7 +62169,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_pd() {
+    const fn test_mm512_mask_shuffle_pd() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 1., 4., 5., 8.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 2., 3., 6., 7.);
         let r = _mm512_mask_shuffle_pd::<0b11_11_11_11>(a, 0, a, b);
@@ -62144,7 +62180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_pd() {
+    const fn test_mm512_maskz_shuffle_pd() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 1., 4., 5., 8.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 2., 3., 6., 7.);
         let r = _mm512_maskz_shuffle_pd::<0b11_11_11_11>(0, a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs b/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
index de058c307308..57d47c0bb010 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
@@ -247,7 +247,7 @@ pub const fn _mm512_setr_ph(
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_setzero_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_setzero_ph() -> __m128h {
     unsafe { transmute(f16x8::ZERO) }
@@ -258,7 +258,7 @@ pub const fn _mm_setzero_ph() -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_setzero_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_setzero_ph() -> __m256h {
     f16x16::ZERO.as_m256h()
@@ -269,7 +269,7 @@ pub const fn _mm256_setzero_ph() -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_setzero_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_setzero_ph() -> __m512h {
     f16x32::ZERO.as_m512h()
@@ -283,7 +283,7 @@ pub const fn _mm512_setzero_ph() -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_undefined_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_undefined_ph() -> __m128h {
     f16x8::ZERO.as_m128h()
@@ -297,7 +297,7 @@ pub const fn _mm_undefined_ph() -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_undefined_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_undefined_ph() -> __m256h {
     f16x16::ZERO.as_m256h()
@@ -311,7 +311,7 @@ pub const fn _mm256_undefined_ph() -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_undefined_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_undefined_ph() -> __m512h {
     f16x32::ZERO.as_m512h()
@@ -323,7 +323,7 @@ pub const fn _mm512_undefined_ph() -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castpd_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castpd_ph(a: __m128d) -> __m128h {
     unsafe { transmute(a) }
@@ -335,7 +335,7 @@ pub const fn _mm_castpd_ph(a: __m128d) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castpd_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castpd_ph(a: __m256d) -> __m256h {
     unsafe { transmute(a) }
@@ -347,7 +347,7 @@ pub const fn _mm256_castpd_ph(a: __m256d) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castpd_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castpd_ph(a: __m512d) -> __m512h {
     unsafe { transmute(a) }
@@ -359,7 +359,7 @@ pub const fn _mm512_castpd_ph(a: __m512d) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castph_pd)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castph_pd(a: __m128h) -> __m128d {
     unsafe { transmute(a) }
@@ -371,7 +371,7 @@ pub const fn _mm_castph_pd(a: __m128h) -> __m128d {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castph_pd)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castph_pd(a: __m256h) -> __m256d {
     unsafe { transmute(a) }
@@ -383,7 +383,7 @@ pub const fn _mm256_castph_pd(a: __m256h) -> __m256d {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph_pd)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph_pd(a: __m512h) -> __m512d {
     unsafe { transmute(a) }
@@ -395,7 +395,7 @@ pub const fn _mm512_castph_pd(a: __m512h) -> __m512d {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castps_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castps_ph(a: __m128) -> __m128h {
     unsafe { transmute(a) }
@@ -407,7 +407,7 @@ pub const fn _mm_castps_ph(a: __m128) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castps_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castps_ph(a: __m256) -> __m256h {
     unsafe { transmute(a) }
@@ -419,7 +419,7 @@ pub const fn _mm256_castps_ph(a: __m256) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castps_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castps_ph(a: __m512) -> __m512h {
     unsafe { transmute(a) }
@@ -431,7 +431,7 @@ pub const fn _mm512_castps_ph(a: __m512) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castph_ps)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castph_ps(a: __m128h) -> __m128 {
     unsafe { transmute(a) }
@@ -443,7 +443,7 @@ pub const fn _mm_castph_ps(a: __m128h) -> __m128 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castph_ps)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castph_ps(a: __m256h) -> __m256 {
     unsafe { transmute(a) }
@@ -455,7 +455,7 @@ pub const fn _mm256_castph_ps(a: __m256h) -> __m256 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph_ps)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph_ps(a: __m512h) -> __m512 {
     unsafe { transmute(a) }
@@ -467,7 +467,7 @@ pub const fn _mm512_castph_ps(a: __m512h) -> __m512 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castsi128_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castsi128_ph(a: __m128i) -> __m128h {
     unsafe { transmute(a) }
@@ -479,7 +479,7 @@ pub const fn _mm_castsi128_ph(a: __m128i) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castsi256_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castsi256_ph(a: __m256i) -> __m256h {
     unsafe { transmute(a) }
@@ -491,7 +491,7 @@ pub const fn _mm256_castsi256_ph(a: __m256i) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castsi512_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castsi512_ph(a: __m512i) -> __m512h {
     unsafe { transmute(a) }
@@ -503,7 +503,7 @@ pub const fn _mm512_castsi512_ph(a: __m512i) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castph_si128)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_castph_si128(a: __m128h) -> __m128i {
     unsafe { transmute(a) }
@@ -515,7 +515,7 @@ pub const fn _mm_castph_si128(a: __m128h) -> __m128i {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castph_si256)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castph_si256(a: __m256h) -> __m256i {
     unsafe { transmute(a) }
@@ -527,7 +527,7 @@ pub const fn _mm256_castph_si256(a: __m256h) -> __m256i {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph_si512)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph_si512(a: __m512h) -> __m512i {
     unsafe { transmute(a) }
@@ -539,7 +539,7 @@ pub const fn _mm512_castph_si512(a: __m512h) -> __m512i {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castph256_ph128)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castph256_ph128(a: __m256h) -> __m128h {
     unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]) }
@@ -551,7 +551,7 @@ pub const fn _mm256_castph256_ph128(a: __m256h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph512_ph128)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph512_ph128(a: __m512h) -> __m128h {
     unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]) }
@@ -563,7 +563,7 @@ pub const fn _mm512_castph512_ph128(a: __m512h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph512_ph256)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph512_ph256(a: __m512h) -> __m256h {
     unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) }
@@ -576,7 +576,7 @@ pub const fn _mm512_castph512_ph256(a: __m512h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_castph128_ph256)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_castph128_ph256(a: __m128h) -> __m256h {
     unsafe {
@@ -595,7 +595,7 @@ pub const fn _mm256_castph128_ph256(a: __m128h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph128_ph512)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph128_ph512(a: __m128h) -> __m512h {
     unsafe {
@@ -617,7 +617,7 @@ pub const fn _mm512_castph128_ph512(a: __m128h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_castph256_ph512)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_castph256_ph512(a: __m256h) -> __m512h {
     unsafe {
@@ -639,7 +639,7 @@ pub const fn _mm512_castph256_ph512(a: __m256h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_zextph128_ph256)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_zextph128_ph256(a: __m128h) -> __m256h {
     unsafe {
@@ -658,7 +658,7 @@ pub const fn _mm256_zextph128_ph256(a: __m128h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_zextph256_ph512)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_zextph256_ph512(a: __m256h) -> __m512h {
     unsafe {
@@ -680,7 +680,7 @@ pub const fn _mm512_zextph256_ph512(a: __m256h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_zextph128_ph512)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_zextph128_ph512(a: __m128h) -> __m512h {
     unsafe {
@@ -730,7 +730,7 @@ macro_rules! cmp_asm { // FIXME: use LLVM intrinsics
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmp_ph_mask<const IMM5: i32>(a: __m128h, b: __m128h) -> __mmask8 {
     unsafe {
         static_assert_uimm_bits!(IMM5, 5);
@@ -746,7 +746,7 @@ pub fn _mm_cmp_ph_mask<const IMM5: i32>(a: __m128h, b: __m128h) -> __mmask8 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmp_ph_mask<const IMM5: i32>(k1: __mmask8, a: __m128h, b: __m128h) -> __mmask8 {
     unsafe {
         static_assert_uimm_bits!(IMM5, 5);
@@ -761,7 +761,7 @@ pub fn _mm_mask_cmp_ph_mask<const IMM5: i32>(k1: __mmask8, a: __m128h, b: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cmp_ph_mask<const IMM5: i32>(a: __m256h, b: __m256h) -> __mmask16 {
     unsafe {
         static_assert_uimm_bits!(IMM5, 5);
@@ -777,7 +777,7 @@ pub fn _mm256_cmp_ph_mask<const IMM5: i32>(a: __m256h, b: __m256h) -> __mmask16
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cmp_ph_mask<const IMM5: i32>(
     k1: __mmask16,
     a: __m256h,
@@ -796,7 +796,7 @@ pub fn _mm256_mask_cmp_ph_mask<const IMM5: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cmp_ph_mask<const IMM5: i32>(a: __m512h, b: __m512h) -> __mmask32 {
     unsafe {
         static_assert_uimm_bits!(IMM5, 5);
@@ -812,7 +812,7 @@ pub fn _mm512_cmp_ph_mask<const IMM5: i32>(a: __m512h, b: __m512h) -> __mmask32
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cmp_ph_mask<const IMM5: i32>(
     k1: __mmask32,
     a: __m512h,
@@ -833,7 +833,7 @@ pub fn _mm512_mask_cmp_ph_mask<const IMM5: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cmp_round_ph_mask<const IMM5: i32, const SAE: i32>(
     a: __m512h,
     b: __m512h,
@@ -868,7 +868,7 @@ pub fn _mm512_cmp_round_ph_mask<const IMM5: i32, const SAE: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cmp_round_ph_mask<const IMM5: i32, const SAE: i32>(
     k1: __mmask32,
     a: __m512h,
@@ -903,7 +903,7 @@ pub fn _mm512_mask_cmp_round_ph_mask<const IMM5: i32, const SAE: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmp_round_sh_mask<const IMM5: i32, const SAE: i32>(a: __m128h, b: __m128h) -> __mmask8 {
     static_assert_uimm_bits!(IMM5, 5);
     static_assert_sae!(SAE);
@@ -918,7 +918,7 @@ pub fn _mm_cmp_round_sh_mask<const IMM5: i32, const SAE: i32>(a: __m128h, b: __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmp_round_sh_mask<const IMM5: i32, const SAE: i32>(
     k1: __mmask8,
     a: __m128h,
@@ -938,7 +938,7 @@ pub fn _mm_mask_cmp_round_sh_mask<const IMM5: i32, const SAE: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmp_sh_mask<const IMM5: i32>(a: __m128h, b: __m128h) -> __mmask8 {
     static_assert_uimm_bits!(IMM5, 5);
     _mm_cmp_round_sh_mask::<IMM5, _MM_FROUND_CUR_DIRECTION>(a, b)
@@ -951,7 +951,7 @@ pub fn _mm_cmp_sh_mask<const IMM5: i32>(a: __m128h, b: __m128h) -> __mmask8 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmp_sh_mask<const IMM5: i32>(k1: __mmask8, a: __m128h, b: __m128h) -> __mmask8 {
     static_assert_uimm_bits!(IMM5, 5);
     _mm_mask_cmp_round_sh_mask::<IMM5, _MM_FROUND_CUR_DIRECTION>(k1, a, b)
@@ -965,7 +965,7 @@ pub fn _mm_mask_cmp_sh_mask<const IMM5: i32>(k1: __mmask8, a: __m128h, b: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comi_round_sh<const IMM5: i32, const SAE: i32>(a: __m128h, b: __m128h) -> i32 {
     unsafe {
         static_assert_uimm_bits!(IMM5, 5);
@@ -981,7 +981,7 @@ pub fn _mm_comi_round_sh<const IMM5: i32, const SAE: i32>(a: __m128h, b: __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comi_sh<const IMM5: i32>(a: __m128h, b: __m128h) -> i32 {
     static_assert_uimm_bits!(IMM5, 5);
     _mm_comi_round_sh::<IMM5, _MM_FROUND_CUR_DIRECTION>(a, b)
@@ -993,7 +993,7 @@ pub fn _mm_comi_sh<const IMM5: i32>(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comieq_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comieq_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_EQ_OS>(a, b)
 }
@@ -1004,7 +1004,7 @@ pub fn _mm_comieq_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comige_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comige_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_GE_OS>(a, b)
 }
@@ -1015,7 +1015,7 @@ pub fn _mm_comige_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comigt_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comigt_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_GT_OS>(a, b)
 }
@@ -1026,7 +1026,7 @@ pub fn _mm_comigt_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comile_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comile_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_LE_OS>(a, b)
 }
@@ -1037,7 +1037,7 @@ pub fn _mm_comile_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comilt_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comilt_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_LT_OS>(a, b)
 }
@@ -1048,7 +1048,7 @@ pub fn _mm_comilt_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_comineq_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_comineq_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_NEQ_US>(a, b)
 }
@@ -1059,7 +1059,7 @@ pub fn _mm_comineq_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomieq_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomieq_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_EQ_OQ>(a, b)
 }
@@ -1070,7 +1070,7 @@ pub fn _mm_ucomieq_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomige_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomige_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_GE_OQ>(a, b)
 }
@@ -1081,7 +1081,7 @@ pub fn _mm_ucomige_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomigt_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomigt_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_GT_OQ>(a, b)
 }
@@ -1092,7 +1092,7 @@ pub fn _mm_ucomigt_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomile_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomile_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_LE_OQ>(a, b)
 }
@@ -1103,7 +1103,7 @@ pub fn _mm_ucomile_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomilt_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomilt_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_LT_OQ>(a, b)
 }
@@ -1114,7 +1114,7 @@ pub fn _mm_ucomilt_sh(a: __m128h, b: __m128h) -> i32 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ucomineq_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_ucomineq_sh(a: __m128h, b: __m128h) -> i32 {
     _mm_comi_sh::<_CMP_NEQ_UQ>(a, b)
 }
@@ -1248,7 +1248,7 @@ pub const unsafe fn _mm512_loadu_ph(mem_addr: *const f16) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_move_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_move_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1267,7 +1267,7 @@ pub const fn _mm_mask_move_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_maskz_move_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_move_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1285,7 +1285,7 @@ pub const fn _mm_maskz_move_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_move_sh)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_move_sh(a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1399,7 +1399,7 @@ pub const unsafe fn _mm512_storeu_ph(mem_addr: *mut f16, a: __m512h) {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_add_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_add(a, b) }
@@ -1412,7 +1412,7 @@ pub const fn _mm_add_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_add_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1428,7 +1428,7 @@ pub const fn _mm_mask_add_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_add_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1443,7 +1443,7 @@ pub const fn _mm_maskz_add_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_add_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_add(a, b) }
@@ -1456,7 +1456,7 @@ pub const fn _mm256_add_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_add_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -1472,7 +1472,7 @@ pub const fn _mm256_mask_add_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_add_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -1487,7 +1487,7 @@ pub const fn _mm256_maskz_add_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_add_ph(a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_add(a, b) }
@@ -1500,7 +1500,7 @@ pub const fn _mm512_add_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_add_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -1516,7 +1516,7 @@ pub const fn _mm512_mask_add_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_add_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -1539,7 +1539,7 @@ pub const fn _mm512_maskz_add_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_add_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -1562,7 +1562,7 @@ pub fn _mm512_add_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m51
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_add_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -1590,7 +1590,7 @@ pub fn _mm512_mask_add_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_add_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -1618,7 +1618,7 @@ pub fn _mm512_maskz_add_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_add_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_add_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -1640,7 +1640,7 @@ pub fn _mm_add_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_add_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -1669,7 +1669,7 @@ pub fn _mm_mask_add_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_add_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_add_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -1682,7 +1682,7 @@ pub fn _mm_maskz_add_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_add_sh(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_insert!(a, 0, _mm_cvtsh_h(a) + _mm_cvtsh_h(b)) }
@@ -1696,7 +1696,7 @@ pub const fn _mm_add_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_add_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1719,7 +1719,7 @@ pub const fn _mm_mask_add_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vaddsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_add_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1739,7 +1739,7 @@ pub const fn _mm_maskz_add_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_sub_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_sub(a, b) }
@@ -1752,7 +1752,7 @@ pub const fn _mm_sub_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_sub_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1768,7 +1768,7 @@ pub const fn _mm_mask_sub_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_sub_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -1783,7 +1783,7 @@ pub const fn _mm_maskz_sub_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_sub_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_sub(a, b) }
@@ -1796,7 +1796,7 @@ pub const fn _mm256_sub_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_sub_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -1812,7 +1812,7 @@ pub const fn _mm256_mask_sub_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_sub_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -1827,7 +1827,7 @@ pub const fn _mm256_maskz_sub_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_sub_ph(a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_sub(a, b) }
@@ -1840,7 +1840,7 @@ pub const fn _mm512_sub_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_sub_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -1856,7 +1856,7 @@ pub const fn _mm512_mask_sub_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_sub_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -1879,7 +1879,7 @@ pub const fn _mm512_maskz_sub_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_sub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -1902,7 +1902,7 @@ pub fn _mm512_sub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m51
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_sub_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -1931,7 +1931,7 @@ pub fn _mm512_mask_sub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_sub_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -1959,7 +1959,7 @@ pub fn _mm512_maskz_sub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_sub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_sub_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -1981,7 +1981,7 @@ pub fn _mm_sub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_sub_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -2010,7 +2010,7 @@ pub fn _mm_mask_sub_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_sub_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_sub_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -2023,7 +2023,7 @@ pub fn _mm_maskz_sub_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_sub_sh(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_insert!(a, 0, _mm_cvtsh_h(a) - _mm_cvtsh_h(b)) }
@@ -2037,7 +2037,7 @@ pub const fn _mm_sub_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_sub_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2060,7 +2060,7 @@ pub const fn _mm_mask_sub_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsubsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_sub_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2080,7 +2080,7 @@ pub const fn _mm_maskz_sub_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mul_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_mul(a, b) }
@@ -2093,7 +2093,7 @@ pub const fn _mm_mul_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_mul_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2109,7 +2109,7 @@ pub const fn _mm_mask_mul_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_mul_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2124,7 +2124,7 @@ pub const fn _mm_maskz_mul_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mul_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_mul(a, b) }
@@ -2137,7 +2137,7 @@ pub const fn _mm256_mul_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_mul_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -2153,7 +2153,7 @@ pub const fn _mm256_mask_mul_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_mul_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -2168,7 +2168,7 @@ pub const fn _mm256_maskz_mul_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mul_ph(a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_mul(a, b) }
@@ -2181,7 +2181,7 @@ pub const fn _mm512_mul_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_mul_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -2197,7 +2197,7 @@ pub const fn _mm512_mask_mul_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_mul_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -2220,7 +2220,7 @@ pub const fn _mm512_maskz_mul_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mul_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -2243,7 +2243,7 @@ pub fn _mm512_mul_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m51
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_mul_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -2272,7 +2272,7 @@ pub fn _mm512_mask_mul_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_mul_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -2300,7 +2300,7 @@ pub fn _mm512_maskz_mul_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mul_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_mul_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -2322,7 +2322,7 @@ pub fn _mm_mul_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_mul_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -2351,7 +2351,7 @@ pub fn _mm_mask_mul_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_mul_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_mul_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -2364,7 +2364,7 @@ pub fn _mm_maskz_mul_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mul_sh(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_insert!(a, 0, _mm_cvtsh_h(a) * _mm_cvtsh_h(b)) }
@@ -2378,7 +2378,7 @@ pub const fn _mm_mul_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_mul_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2401,7 +2401,7 @@ pub const fn _mm_mask_mul_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmulsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_mul_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2421,7 +2421,7 @@ pub const fn _mm_maskz_mul_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_div_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_div(a, b) }
@@ -2434,7 +2434,7 @@ pub const fn _mm_div_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_div_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2450,7 +2450,7 @@ pub const fn _mm_mask_div_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_div_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2465,7 +2465,7 @@ pub const fn _mm_maskz_div_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_div_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_div(a, b) }
@@ -2478,7 +2478,7 @@ pub const fn _mm256_div_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_div_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -2494,7 +2494,7 @@ pub const fn _mm256_mask_div_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_div_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe {
@@ -2509,7 +2509,7 @@ pub const fn _mm256_maskz_div_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_div_ph(a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_div(a, b) }
@@ -2522,7 +2522,7 @@ pub const fn _mm512_div_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_div_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -2538,7 +2538,7 @@ pub const fn _mm512_mask_div_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_div_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
@@ -2561,7 +2561,7 @@ pub const fn _mm512_maskz_div_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_div_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -2584,7 +2584,7 @@ pub fn _mm512_div_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m51
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_div_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -2613,7 +2613,7 @@ pub fn _mm512_mask_div_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_div_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -2641,7 +2641,7 @@ pub fn _mm512_maskz_div_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_div_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_div_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -2663,7 +2663,7 @@ pub fn _mm_div_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_div_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -2692,7 +2692,7 @@ pub fn _mm_mask_div_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_div_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_div_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -2705,7 +2705,7 @@ pub fn _mm_maskz_div_round_sh<const ROUNDING: i32>(k: __mmask8, a: __m128h, b: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_div_sh(a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_insert!(a, 0, _mm_cvtsh_h(a) / _mm_cvtsh_h(b)) }
@@ -2719,7 +2719,7 @@ pub const fn _mm_div_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_div_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2742,7 +2742,7 @@ pub const fn _mm_mask_div_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vdivsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_div_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe {
@@ -2764,7 +2764,7 @@ pub const fn _mm_maskz_div_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mul_pch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_pch(_mm_undefined_ph(), 0xff, a, b)
 }
@@ -2777,7 +2777,7 @@ pub fn _mm_mul_pch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_mul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { transmute(vfmulcph_128(transmute(a), transmute(b), transmute(src), k)) }
 }
@@ -2790,7 +2790,7 @@ pub fn _mm_mask_mul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_mul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_pch(_mm_setzero_ph(), k, a, b)
 }
@@ -2803,7 +2803,7 @@ pub fn _mm_maskz_mul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mul_pch(a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_mul_pch(_mm256_undefined_ph(), 0xff, a, b)
 }
@@ -2816,7 +2816,7 @@ pub fn _mm256_mul_pch(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_mul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     unsafe { transmute(vfmulcph_256(transmute(a), transmute(b), transmute(src), k)) }
 }
@@ -2829,7 +2829,7 @@ pub fn _mm256_mask_mul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_mul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_mul_pch(_mm256_setzero_ph(), k, a, b)
 }
@@ -2842,7 +2842,7 @@ pub fn _mm256_maskz_mul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mul_pch(a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_mul_pch(_mm512_undefined_ph(), 0xffff, a, b)
 }
@@ -2855,7 +2855,7 @@ pub fn _mm512_mul_pch(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_mul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_mul_round_pch::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -2868,7 +2868,7 @@ pub fn _mm512_mask_mul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h) -
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_mul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_mul_pch(_mm512_setzero_ph(), k, a, b)
 }
@@ -2890,7 +2890,7 @@ pub fn _mm512_maskz_mul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_mul_round_pch::<ROUNDING>(_mm512_undefined_ph(), 0xffff, a, b)
@@ -2913,7 +2913,7 @@ pub fn _mm512_mul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m5
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_mul_round_pch<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask16,
@@ -2949,7 +2949,7 @@ pub fn _mm512_mask_mul_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_mul_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -2968,7 +2968,7 @@ pub fn _mm512_maskz_mul_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mul_sch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_sch(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -2982,7 +2982,7 @@ pub fn _mm_mul_sch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_mul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_round_sch::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -2996,7 +2996,7 @@ pub fn _mm_mask_mul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_mul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_sch(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -3019,7 +3019,7 @@ pub fn _mm_maskz_mul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_mul_round_sch::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -3043,7 +3043,7 @@ pub fn _mm_mul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_mul_round_sch<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -3080,7 +3080,7 @@ pub fn _mm_mask_mul_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_mul_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -3098,7 +3098,7 @@ pub fn _mm_maskz_mul_round_sch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmul_pch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mul_pch(a, b)
 }
@@ -3111,7 +3111,7 @@ pub fn _mm_fmul_pch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_pch(src, k, a, b)
 }
@@ -3124,7 +3124,7 @@ pub fn _mm_mask_fmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_maskz_mul_pch(k, a, b)
 }
@@ -3137,7 +3137,7 @@ pub fn _mm_maskz_fmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_fmul_pch(a: __m256h, b: __m256h) -> __m256h {
     _mm256_mul_pch(a, b)
 }
@@ -3150,7 +3150,7 @@ pub fn _mm256_fmul_pch(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_fmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_mul_pch(src, k, a, b)
 }
@@ -3163,7 +3163,7 @@ pub fn _mm256_mask_fmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_fmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_maskz_mul_pch(k, a, b)
 }
@@ -3175,7 +3175,7 @@ pub fn _mm256_maskz_fmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmul_pch(a: __m512h, b: __m512h) -> __m512h {
     _mm512_mul_pch(a, b)
 }
@@ -3188,7 +3188,7 @@ pub fn _mm512_fmul_pch(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_mul_pch(src, k, a, b)
 }
@@ -3201,7 +3201,7 @@ pub fn _mm512_mask_fmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_maskz_mul_pch(k, a, b)
 }
@@ -3221,7 +3221,7 @@ pub fn _mm512_maskz_fmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mul_round_pch::<ROUNDING>(a, b)
@@ -3243,7 +3243,7 @@ pub fn _mm512_fmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmul_round_pch<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask16,
@@ -3270,7 +3270,7 @@ pub fn _mm512_mask_fmul_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmul_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -3288,7 +3288,7 @@ pub fn _mm512_maskz_fmul_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmul_sch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mul_sch(a, b)
 }
@@ -3301,7 +3301,7 @@ pub fn _mm_fmul_sch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_mul_sch(src, k, a, b)
 }
@@ -3314,7 +3314,7 @@ pub fn _mm_mask_fmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_maskz_mul_sch(k, a, b)
 }
@@ -3335,7 +3335,7 @@ pub fn _mm_maskz_fmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mul_round_sch::<ROUNDING>(a, b)
@@ -3358,7 +3358,7 @@ pub fn _mm_fmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmul_round_sch<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -3386,7 +3386,7 @@ pub fn _mm_mask_fmul_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmul_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -3405,7 +3405,7 @@ pub fn _mm_maskz_fmul_round_sch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmul_pch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_pch(_mm_undefined_ph(), 0xff, a, b)
 }
@@ -3419,7 +3419,7 @@ pub fn _mm_cmul_pch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { transmute(vfcmulcph_128(transmute(a), transmute(b), transmute(src), k)) }
 }
@@ -3433,7 +3433,7 @@ pub fn _mm_mask_cmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_pch(_mm_setzero_ph(), k, a, b)
 }
@@ -3447,7 +3447,7 @@ pub fn _mm_maskz_cmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cmul_pch(a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_cmul_pch(_mm256_undefined_ph(), 0xff, a, b)
 }
@@ -3461,7 +3461,7 @@ pub fn _mm256_cmul_pch(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     unsafe { transmute(vfcmulcph_256(transmute(a), transmute(b), transmute(src), k)) }
 }
@@ -3475,7 +3475,7 @@ pub fn _mm256_mask_cmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_cmul_pch(_mm256_setzero_ph(), k, a, b)
 }
@@ -3489,7 +3489,7 @@ pub fn _mm256_maskz_cmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cmul_pch(a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_cmul_pch(_mm512_undefined_ph(), 0xffff, a, b)
 }
@@ -3503,7 +3503,7 @@ pub fn _mm512_cmul_pch(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_cmul_round_pch::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -3517,7 +3517,7 @@ pub fn _mm512_mask_cmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_cmul_pch(_mm512_setzero_ph(), k, a, b)
 }
@@ -3540,7 +3540,7 @@ pub fn _mm512_maskz_cmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cmul_round_pch::<ROUNDING>(_mm512_undefined_ph(), 0xffff, a, b)
@@ -3564,7 +3564,7 @@ pub fn _mm512_cmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cmul_round_pch<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask16,
@@ -3601,7 +3601,7 @@ pub fn _mm512_mask_cmul_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cmul_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -3619,7 +3619,7 @@ pub fn _mm512_maskz_cmul_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmul_sch(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_sch(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -3633,7 +3633,7 @@ pub fn _mm_cmul_sch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_round_sch::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -3647,7 +3647,7 @@ pub fn _mm_mask_cmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_sch(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -3669,7 +3669,7 @@ pub fn _mm_maskz_cmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_cmul_round_sch::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -3693,7 +3693,7 @@ pub fn _mm_cmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cmul_round_sch<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -3730,7 +3730,7 @@ pub fn _mm_mask_cmul_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cmul_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -3749,7 +3749,7 @@ pub fn _mm_maskz_cmul_round_sch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmul_pch(a: __m128h, b: __m128h) -> __m128h {
     _mm_cmul_pch(a, b)
 }
@@ -3763,7 +3763,7 @@ pub fn _mm_fcmul_pch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_pch(src, k, a, b)
 }
@@ -3777,7 +3777,7 @@ pub fn _mm_mask_fcmul_pch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_maskz_cmul_pch(k, a, b)
 }
@@ -3791,7 +3791,7 @@ pub fn _mm_maskz_fcmul_pch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_fcmul_pch(a: __m256h, b: __m256h) -> __m256h {
     _mm256_cmul_pch(a, b)
 }
@@ -3805,7 +3805,7 @@ pub fn _mm256_fcmul_pch(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_fcmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_cmul_pch(src, k, a, b)
 }
@@ -3819,7 +3819,7 @@ pub fn _mm256_mask_fcmul_pch(src: __m256h, k: __mmask8, a: __m256h, b: __m256h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_fcmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
     _mm256_maskz_cmul_pch(k, a, b)
 }
@@ -3833,7 +3833,7 @@ pub fn _mm256_maskz_fcmul_pch(k: __mmask8, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fcmul_pch(a: __m512h, b: __m512h) -> __m512h {
     _mm512_cmul_pch(a, b)
 }
@@ -3847,7 +3847,7 @@ pub fn _mm512_fcmul_pch(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fcmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_cmul_pch(src, k, a, b)
 }
@@ -3861,7 +3861,7 @@ pub fn _mm512_mask_fcmul_pch(src: __m512h, k: __mmask16, a: __m512h, b: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fcmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
     _mm512_maskz_cmul_pch(k, a, b)
 }
@@ -3883,7 +3883,7 @@ pub fn _mm512_maskz_fcmul_pch(k: __mmask16, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fcmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_cmul_round_pch::<ROUNDING>(a, b)
@@ -3907,7 +3907,7 @@ pub fn _mm512_fcmul_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fcmul_round_pch<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask16,
@@ -3936,7 +3936,7 @@ pub fn _mm512_mask_fcmul_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fcmul_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -3955,7 +3955,7 @@ pub fn _mm512_maskz_fcmul_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmul_sch(a: __m128h, b: __m128h) -> __m128h {
     _mm_cmul_sch(a, b)
 }
@@ -3969,7 +3969,7 @@ pub fn _mm_fcmul_sch(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_cmul_sch(src, k, a, b)
 }
@@ -3983,7 +3983,7 @@ pub fn _mm_mask_fcmul_sch(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_maskz_cmul_sch(k, a, b)
 }
@@ -4005,7 +4005,7 @@ pub fn _mm_maskz_fcmul_sch(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_cmul_round_sch::<ROUNDING>(a, b)
@@ -4029,7 +4029,7 @@ pub fn _mm_fcmul_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmul_round_sch<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -4058,7 +4058,7 @@ pub fn _mm_mask_fcmul_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmulcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmul_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -4074,7 +4074,7 @@ pub fn _mm_maskz_fcmul_round_sch<const ROUNDING: i32>(
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_abs_ph(v2: __m128h) -> __m128h {
     unsafe { transmute(_mm_and_si128(transmute(v2), _mm_set1_epi16(i16::MAX))) }
@@ -4086,7 +4086,7 @@ pub const fn _mm_abs_ph(v2: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_abs_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_abs_ph(v2: __m256h) -> __m256h {
     unsafe { transmute(_mm256_and_si256(transmute(v2), _mm256_set1_epi16(i16::MAX))) }
@@ -4098,7 +4098,7 @@ pub const fn _mm256_abs_ph(v2: __m256h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_abs_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_abs_ph(v2: __m512h) -> __m512h {
     unsafe { transmute(_mm512_and_si512(transmute(v2), _mm512_set1_epi16(i16::MAX))) }
@@ -4112,7 +4112,7 @@ pub const fn _mm512_abs_ph(v2: __m512h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_conj_pch(a: __m128h) -> __m128h {
     unsafe { transmute(_mm_xor_si128(transmute(a), _mm_set1_epi32(i32::MIN))) }
@@ -4126,7 +4126,7 @@ pub const fn _mm_conj_pch(a: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_conj_pch(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe {
@@ -4143,7 +4143,7 @@ pub const fn _mm_mask_conj_pch(src: __m128h, k: __mmask8, a: __m128h) -> __m128h
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_maskz_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_conj_pch(k: __mmask8, a: __m128h) -> __m128h {
     _mm_mask_conj_pch(_mm_setzero_ph(), k, a)
@@ -4156,7 +4156,7 @@ pub const fn _mm_maskz_conj_pch(k: __mmask8, a: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_conj_pch(a: __m256h) -> __m256h {
     unsafe { transmute(_mm256_xor_si256(transmute(a), _mm256_set1_epi32(i32::MIN))) }
@@ -4170,7 +4170,7 @@ pub const fn _mm256_conj_pch(a: __m256h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_conj_pch(src: __m256h, k: __mmask8, a: __m256h) -> __m256h {
     unsafe {
@@ -4187,7 +4187,7 @@ pub const fn _mm256_mask_conj_pch(src: __m256h, k: __mmask8, a: __m256h) -> __m2
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_maskz_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_conj_pch(k: __mmask8, a: __m256h) -> __m256h {
     _mm256_mask_conj_pch(_mm256_setzero_ph(), k, a)
@@ -4200,7 +4200,7 @@ pub const fn _mm256_maskz_conj_pch(k: __mmask8, a: __m256h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_conj_pch(a: __m512h) -> __m512h {
     unsafe { transmute(_mm512_xor_si512(transmute(a), _mm512_set1_epi32(i32::MIN))) }
@@ -4214,7 +4214,7 @@ pub const fn _mm512_conj_pch(a: __m512h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_conj_pch(src: __m512h, k: __mmask16, a: __m512h) -> __m512h {
     unsafe {
@@ -4231,7 +4231,7 @@ pub const fn _mm512_mask_conj_pch(src: __m512h, k: __mmask16, a: __m512h) -> __m
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_maskz_conj_pch)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_conj_pch(k: __mmask16, a: __m512h) -> __m512h {
     _mm512_mask_conj_pch(_mm512_setzero_ph(), k, a)
@@ -4245,7 +4245,7 @@ pub const fn _mm512_maskz_conj_pch(k: __mmask16, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmadd_pch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_mask3_fmadd_pch(a, b, c, 0xff)
 }
@@ -4259,7 +4259,7 @@ pub fn _mm_fmadd_pch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmadd_pch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         let r: __m128 = transmute(_mm_mask3_fmadd_pch(a, b, c, k)); // using `0xff` would have been fine here, but this is what CLang does
@@ -4276,7 +4276,7 @@ pub fn _mm_mask_fmadd_pch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fmadd_pch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
         transmute(vfmaddcph_mask3_128(
@@ -4297,7 +4297,7 @@ pub fn _mm_mask3_fmadd_pch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmadd_pch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         transmute(vfmaddcph_maskz_128(
@@ -4317,7 +4317,7 @@ pub fn _mm_maskz_fmadd_pch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_fmadd_pch(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     _mm256_mask3_fmadd_pch(a, b, c, 0xff)
 }
@@ -4331,7 +4331,7 @@ pub fn _mm256_fmadd_pch(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_fmadd_pch(a: __m256h, k: __mmask8, b: __m256h, c: __m256h) -> __m256h {
     unsafe {
         let r: __m256 = transmute(_mm256_mask3_fmadd_pch(a, b, c, k)); // using `0xff` would have been fine here, but this is what CLang does
@@ -4348,7 +4348,7 @@ pub fn _mm256_mask_fmadd_pch(a: __m256h, k: __mmask8, b: __m256h, c: __m256h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask3_fmadd_pch(a: __m256h, b: __m256h, c: __m256h, k: __mmask8) -> __m256h {
     unsafe {
         transmute(vfmaddcph_mask3_256(
@@ -4369,7 +4369,7 @@ pub fn _mm256_mask3_fmadd_pch(a: __m256h, b: __m256h, c: __m256h, k: __mmask8) -
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_fmadd_pch(k: __mmask8, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe {
         transmute(vfmaddcph_maskz_256(
@@ -4389,7 +4389,7 @@ pub fn _mm256_maskz_fmadd_pch(k: __mmask8, a: __m256h, b: __m256h, c: __m256h) -
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmadd_pch(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     _mm512_fmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, b, c)
 }
@@ -4403,7 +4403,7 @@ pub fn _mm512_fmadd_pch(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmadd_pch(a: __m512h, k: __mmask16, b: __m512h, c: __m512h) -> __m512h {
     _mm512_mask_fmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, k, b, c)
 }
@@ -4417,7 +4417,7 @@ pub fn _mm512_mask_fmadd_pch(a: __m512h, k: __mmask16, b: __m512h, c: __m512h) -
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmadd_pch(a: __m512h, b: __m512h, c: __m512h, k: __mmask16) -> __m512h {
     _mm512_mask3_fmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, b, c, k)
 }
@@ -4431,7 +4431,7 @@ pub fn _mm512_mask3_fmadd_pch(a: __m512h, b: __m512h, c: __m512h, k: __mmask16)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmadd_pch(k: __mmask16, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     _mm512_maskz_fmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(k, a, b, c)
 }
@@ -4453,7 +4453,7 @@ pub fn _mm512_maskz_fmadd_pch(k: __mmask16, a: __m512h, b: __m512h, c: __m512h)
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmadd_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask3_fmadd_round_pch::<ROUNDING>(a, b, c, 0xffff)
@@ -4477,7 +4477,7 @@ pub fn _mm512_fmadd_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmadd_round_pch<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask16,
@@ -4509,7 +4509,7 @@ pub fn _mm512_mask_fmadd_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmadd_round_pch<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -4546,7 +4546,7 @@ pub fn _mm512_mask3_fmadd_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmadd_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -4574,7 +4574,7 @@ pub fn _mm512_maskz_fmadd_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmadd_sch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_fmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, b, c)
 }
@@ -4589,7 +4589,7 @@ pub fn _mm_fmadd_sch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmadd_sch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     _mm_mask_fmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, k, b, c)
 }
@@ -4604,7 +4604,7 @@ pub fn _mm_mask_fmadd_sch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fmadd_sch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     _mm_mask3_fmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, b, c, k)
 }
@@ -4619,7 +4619,7 @@ pub fn _mm_mask3_fmadd_sch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmadd_sch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_maskz_fmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(k, a, b, c)
 }
@@ -4641,7 +4641,7 @@ pub fn _mm_maskz_fmadd_sch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> _
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmadd_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -4674,7 +4674,7 @@ pub fn _mm_fmadd_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmadd_round_sch<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -4708,7 +4708,7 @@ pub fn _mm_mask_fmadd_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fmadd_round_sch<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -4742,7 +4742,7 @@ pub fn _mm_mask3_fmadd_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmadd_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -4770,7 +4770,7 @@ pub fn _mm_maskz_fmadd_round_sch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmadd_pch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_mask3_fcmadd_pch(a, b, c, 0xff)
 }
@@ -4785,7 +4785,7 @@ pub fn _mm_fcmadd_pch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmadd_pch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         let r: __m128 = transmute(_mm_mask3_fcmadd_pch(a, b, c, k)); // using `0xff` would have been fine here, but this is what CLang does
@@ -4803,7 +4803,7 @@ pub fn _mm_mask_fcmadd_pch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fcmadd_pch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
         transmute(vfcmaddcph_mask3_128(
@@ -4825,7 +4825,7 @@ pub fn _mm_mask3_fcmadd_pch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmadd_pch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         transmute(vfcmaddcph_maskz_128(
@@ -4846,7 +4846,7 @@ pub fn _mm_maskz_fcmadd_pch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_fcmadd_pch(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     _mm256_mask3_fcmadd_pch(a, b, c, 0xff)
 }
@@ -4861,7 +4861,7 @@ pub fn _mm256_fcmadd_pch(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_fcmadd_pch(a: __m256h, k: __mmask8, b: __m256h, c: __m256h) -> __m256h {
     unsafe {
         let r: __m256 = transmute(_mm256_mask3_fcmadd_pch(a, b, c, k)); // using `0xff` would have been fine here, but this is what CLang does
@@ -4879,7 +4879,7 @@ pub fn _mm256_mask_fcmadd_pch(a: __m256h, k: __mmask8, b: __m256h, c: __m256h) -
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask3_fcmadd_pch(a: __m256h, b: __m256h, c: __m256h, k: __mmask8) -> __m256h {
     unsafe {
         transmute(vfcmaddcph_mask3_256(
@@ -4901,7 +4901,7 @@ pub fn _mm256_mask3_fcmadd_pch(a: __m256h, b: __m256h, c: __m256h, k: __mmask8)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_fcmadd_pch(k: __mmask8, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe {
         transmute(vfcmaddcph_maskz_256(
@@ -4922,7 +4922,7 @@ pub fn _mm256_maskz_fcmadd_pch(k: __mmask8, a: __m256h, b: __m256h, c: __m256h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fcmadd_pch(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     _mm512_fcmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, b, c)
 }
@@ -4937,7 +4937,7 @@ pub fn _mm512_fcmadd_pch(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fcmadd_pch(a: __m512h, k: __mmask16, b: __m512h, c: __m512h) -> __m512h {
     _mm512_mask_fcmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, k, b, c)
 }
@@ -4952,7 +4952,7 @@ pub fn _mm512_mask_fcmadd_pch(a: __m512h, k: __mmask16, b: __m512h, c: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fcmadd_pch(a: __m512h, b: __m512h, c: __m512h, k: __mmask16) -> __m512h {
     _mm512_mask3_fcmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(a, b, c, k)
 }
@@ -4967,7 +4967,7 @@ pub fn _mm512_mask3_fcmadd_pch(a: __m512h, b: __m512h, c: __m512h, k: __mmask16)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fcmadd_pch(k: __mmask16, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     _mm512_maskz_fcmadd_round_pch::<_MM_FROUND_CUR_DIRECTION>(k, a, b, c)
 }
@@ -4990,7 +4990,7 @@ pub fn _mm512_maskz_fcmadd_pch(k: __mmask16, a: __m512h, b: __m512h, c: __m512h)
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fcmadd_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask3_fcmadd_round_pch::<ROUNDING>(a, b, c, 0xffff)
@@ -5015,7 +5015,7 @@ pub fn _mm512_fcmadd_round_pch<const ROUNDING: i32>(a: __m512h, b: __m512h, c: _
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fcmadd_round_pch<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask16,
@@ -5048,7 +5048,7 @@ pub fn _mm512_mask_fcmadd_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fcmadd_round_pch<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -5086,7 +5086,7 @@ pub fn _mm512_mask3_fcmadd_round_pch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fcmadd_round_pch<const ROUNDING: i32>(
     k: __mmask16,
     a: __m512h,
@@ -5115,7 +5115,7 @@ pub fn _mm512_maskz_fcmadd_round_pch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmadd_sch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_fcmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, b, c)
 }
@@ -5131,7 +5131,7 @@ pub fn _mm_fcmadd_sch(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmadd_sch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     _mm_mask_fcmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, k, b, c)
 }
@@ -5147,7 +5147,7 @@ pub fn _mm_mask_fcmadd_sch(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fcmadd_sch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     _mm_mask3_fcmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(a, b, c, k)
 }
@@ -5163,7 +5163,7 @@ pub fn _mm_mask3_fcmadd_sch(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmadd_sch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_maskz_fcmadd_round_sch::<_MM_FROUND_CUR_DIRECTION>(k, a, b, c)
 }
@@ -5187,7 +5187,7 @@ pub fn _mm_maskz_fcmadd_sch(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) ->
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fcmadd_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -5221,7 +5221,7 @@ pub fn _mm_fcmadd_round_sch<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m1
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fcmadd_round_sch<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -5256,7 +5256,7 @@ pub fn _mm_mask_fcmadd_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fcmadd_round_sch<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -5291,7 +5291,7 @@ pub fn _mm_mask3_fcmadd_round_sch<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfcmaddcsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fcmadd_round_sch<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -5317,7 +5317,7 @@ pub fn _mm_maskz_fcmadd_round_sch<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_fma(a, b, c) }
@@ -5331,7 +5331,7 @@ pub const fn _mm_fmadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmadd_ph(a, b, c), a) }
@@ -5345,7 +5345,7 @@ pub const fn _mm_mask_fmadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmadd_ph(a, b, c), c) }
@@ -5359,7 +5359,7 @@ pub const fn _mm_mask3_fmadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmadd_ph(a, b, c), _mm_setzero_ph()) }
@@ -5372,7 +5372,7 @@ pub const fn _mm_maskz_fmadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fmadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_fma(a, b, c) }
@@ -5386,7 +5386,7 @@ pub const fn _mm256_fmadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fmadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmadd_ph(a, b, c), a) }
@@ -5400,7 +5400,7 @@ pub const fn _mm256_mask_fmadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fmadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmadd_ph(a, b, c), c) }
@@ -5414,7 +5414,7 @@ pub const fn _mm256_mask3_fmadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fmadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmadd_ph(a, b, c), _mm256_setzero_ph()) }
@@ -5427,7 +5427,7 @@ pub const fn _mm256_maskz_fmadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fmadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_fma(a, b, c) }
@@ -5441,7 +5441,7 @@ pub const fn _mm512_fmadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fmadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmadd_ph(a, b, c), a) }
@@ -5455,7 +5455,7 @@ pub const fn _mm512_mask_fmadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fmadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmadd_ph(a, b, c), c) }
@@ -5469,7 +5469,7 @@ pub const fn _mm512_mask3_fmadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fmadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmadd_ph(a, b, c), _mm512_setzero_ph()) }
@@ -5491,7 +5491,7 @@ pub const fn _mm512_maskz_fmadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m5
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmadd_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -5516,7 +5516,7 @@ pub fn _mm512_fmadd_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -5546,7 +5546,7 @@ pub fn _mm512_mask_fmadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -5576,7 +5576,7 @@ pub fn _mm512_mask3_fmadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmadd_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -5601,7 +5601,7 @@ pub fn _mm512_maskz_fmadd_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmadd_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -5622,7 +5622,7 @@ pub const fn _mm_fmadd_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmadd_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -5645,7 +5645,7 @@ pub const fn _mm_mask_fmadd_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmadd_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
@@ -5668,7 +5668,7 @@ pub const fn _mm_mask3_fmadd_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmadd_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -5700,7 +5700,7 @@ pub const fn _mm_maskz_fmadd_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h)
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmadd_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -5730,7 +5730,7 @@ pub fn _mm_fmadd_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmadd_round_sh<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -5767,7 +5767,7 @@ pub fn _mm_mask_fmadd_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fmadd_round_sh<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -5804,7 +5804,7 @@ pub fn _mm_mask3_fmadd_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmadd_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -5832,7 +5832,7 @@ pub fn _mm_maskz_fmadd_round_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_fma(a, b, simd_neg(c)) }
@@ -5846,7 +5846,7 @@ pub const fn _mm_fmsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsub_ph(a, b, c), a) }
@@ -5860,7 +5860,7 @@ pub const fn _mm_mask_fmsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsub_ph(a, b, c), c) }
@@ -5874,7 +5874,7 @@ pub const fn _mm_mask3_fmsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsub_ph(a, b, c), _mm_setzero_ph()) }
@@ -5887,7 +5887,7 @@ pub const fn _mm_maskz_fmsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fmsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_fma(a, b, simd_neg(c)) }
@@ -5901,7 +5901,7 @@ pub const fn _mm256_fmsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fmsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsub_ph(a, b, c), a) }
@@ -5915,7 +5915,7 @@ pub const fn _mm256_mask_fmsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fmsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsub_ph(a, b, c), c) }
@@ -5929,7 +5929,7 @@ pub const fn _mm256_mask3_fmsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fmsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsub_ph(a, b, c), _mm256_setzero_ph()) }
@@ -5942,7 +5942,7 @@ pub const fn _mm256_maskz_fmsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fmsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_fma(a, b, simd_neg(c)) }
@@ -5956,7 +5956,7 @@ pub const fn _mm512_fmsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fmsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsub_ph(a, b, c), a) }
@@ -5970,7 +5970,7 @@ pub const fn _mm512_mask_fmsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fmsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsub_ph(a, b, c), c) }
@@ -5984,7 +5984,7 @@ pub const fn _mm512_mask3_fmsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fmsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsub_ph(a, b, c), _mm512_setzero_ph()) }
@@ -6006,7 +6006,7 @@ pub const fn _mm512_maskz_fmsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m5
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmsub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -6031,7 +6031,7 @@ pub fn _mm512_fmsub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -6061,7 +6061,7 @@ pub fn _mm512_mask_fmsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -6091,7 +6091,7 @@ pub fn _mm512_mask3_fmsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmsub_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -6116,7 +6116,7 @@ pub fn _mm512_maskz_fmsub_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmsub_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6137,7 +6137,7 @@ pub const fn _mm_fmsub_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmsub_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6160,7 +6160,7 @@ pub const fn _mm_mask_fmsub_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmsub_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
@@ -6183,7 +6183,7 @@ pub const fn _mm_mask3_fmsub_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmsub_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6215,7 +6215,7 @@ pub const fn _mm_maskz_fmsub_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h)
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fmsub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -6245,7 +6245,7 @@ pub fn _mm_fmsub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fmsub_round_sh<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -6282,7 +6282,7 @@ pub fn _mm_mask_fmsub_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fmsub_round_sh<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -6311,7 +6311,7 @@ pub fn _mm_mask3_fmsub_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fmsub_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -6338,7 +6338,7 @@ pub fn _mm_maskz_fmsub_round_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fnmadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_fma(simd_neg(a), b, c) }
@@ -6352,7 +6352,7 @@ pub const fn _mm_fnmadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fnmadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmadd_ph(a, b, c), a) }
@@ -6366,7 +6366,7 @@ pub const fn _mm_mask_fnmadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fnmadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmadd_ph(a, b, c), c) }
@@ -6380,7 +6380,7 @@ pub const fn _mm_mask3_fnmadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fnmadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmadd_ph(a, b, c), _mm_setzero_ph()) }
@@ -6393,7 +6393,7 @@ pub const fn _mm_maskz_fnmadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fnmadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_fma(simd_neg(a), b, c) }
@@ -6407,7 +6407,7 @@ pub const fn _mm256_fnmadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fnmadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmadd_ph(a, b, c), a) }
@@ -6421,7 +6421,7 @@ pub const fn _mm256_mask_fnmadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fnmadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmadd_ph(a, b, c), c) }
@@ -6435,7 +6435,7 @@ pub const fn _mm256_mask3_fnmadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __mma
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fnmadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmadd_ph(a, b, c), _mm256_setzero_ph()) }
@@ -6448,7 +6448,7 @@ pub const fn _mm256_maskz_fnmadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fnmadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_fma(simd_neg(a), b, c) }
@@ -6462,7 +6462,7 @@ pub const fn _mm512_fnmadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fnmadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmadd_ph(a, b, c), a) }
@@ -6476,7 +6476,7 @@ pub const fn _mm512_mask_fnmadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fnmadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmadd_ph(a, b, c), c) }
@@ -6490,7 +6490,7 @@ pub const fn _mm512_mask3_fnmadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __mma
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fnmadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmadd_ph(a, b, c), _mm512_setzero_ph()) }
@@ -6512,7 +6512,7 @@ pub const fn _mm512_maskz_fnmadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fnmadd_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -6537,7 +6537,7 @@ pub fn _mm512_fnmadd_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fnmadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -6567,7 +6567,7 @@ pub fn _mm512_mask_fnmadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fnmadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -6597,7 +6597,7 @@ pub fn _mm512_mask3_fnmadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fnmadd_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -6622,7 +6622,7 @@ pub fn _mm512_maskz_fnmadd_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fnmadd_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6643,7 +6643,7 @@ pub const fn _mm_fnmadd_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fnmadd_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6666,7 +6666,7 @@ pub const fn _mm_mask_fnmadd_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fnmadd_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
@@ -6689,7 +6689,7 @@ pub const fn _mm_mask3_fnmadd_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fnmadd_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -6721,7 +6721,7 @@ pub const fn _mm_maskz_fnmadd_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fnmadd_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -6751,7 +6751,7 @@ pub fn _mm_fnmadd_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fnmadd_round_sh<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -6788,7 +6788,7 @@ pub fn _mm_mask_fnmadd_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fnmadd_round_sh<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -6825,7 +6825,7 @@ pub fn _mm_mask3_fnmadd_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fnmadd_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -6852,7 +6852,7 @@ pub fn _mm_maskz_fnmadd_round_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fnmsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_fma(simd_neg(a), b, simd_neg(c)) }
@@ -6866,7 +6866,7 @@ pub const fn _mm_fnmsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fnmsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmsub_ph(a, b, c), a) }
@@ -6880,7 +6880,7 @@ pub const fn _mm_mask_fnmsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fnmsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmsub_ph(a, b, c), c) }
@@ -6894,7 +6894,7 @@ pub const fn _mm_mask3_fnmsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fnmsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fnmsub_ph(a, b, c), _mm_setzero_ph()) }
@@ -6907,7 +6907,7 @@ pub const fn _mm_maskz_fnmsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fnmsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_fma(simd_neg(a), b, simd_neg(c)) }
@@ -6921,7 +6921,7 @@ pub const fn _mm256_fnmsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fnmsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmsub_ph(a, b, c), a) }
@@ -6935,7 +6935,7 @@ pub const fn _mm256_mask_fnmsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fnmsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmsub_ph(a, b, c), c) }
@@ -6949,7 +6949,7 @@ pub const fn _mm256_mask3_fnmsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __mma
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fnmsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fnmsub_ph(a, b, c), _mm256_setzero_ph()) }
@@ -6962,7 +6962,7 @@ pub const fn _mm256_maskz_fnmsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fnmsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_fma(simd_neg(a), b, simd_neg(c)) }
@@ -6976,7 +6976,7 @@ pub const fn _mm512_fnmsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fnmsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmsub_ph(a, b, c), a) }
@@ -6990,7 +6990,7 @@ pub const fn _mm512_mask_fnmsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fnmsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmsub_ph(a, b, c), c) }
@@ -7004,7 +7004,7 @@ pub const fn _mm512_mask3_fnmsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __mma
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fnmsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fnmsub_ph(a, b, c), _mm512_setzero_ph()) }
@@ -7026,7 +7026,7 @@ pub const fn _mm512_maskz_fnmsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fnmsub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -7051,7 +7051,7 @@ pub fn _mm512_fnmsub_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h, c: __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fnmsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -7081,7 +7081,7 @@ pub fn _mm512_mask_fnmsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fnmsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -7111,7 +7111,7 @@ pub fn _mm512_mask3_fnmsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fnmsub_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -7136,7 +7136,7 @@ pub fn _mm512_maskz_fnmsub_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fnmsub_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -7157,7 +7157,7 @@ pub const fn _mm_fnmsub_sh(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fnmsub_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -7180,7 +7180,7 @@ pub const fn _mm_mask_fnmsub_sh(a: __m128h, k: __mmask8, b: __m128h, c: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fnmsub_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe {
@@ -7203,7 +7203,7 @@ pub const fn _mm_mask3_fnmsub_sh(a: __m128h, b: __m128h, c: __m128h, k: __mmask8
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fnmsub_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -7235,7 +7235,7 @@ pub const fn _mm_maskz_fnmsub_sh(k: __mmask8, a: __m128h, b: __m128h, c: __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fnmsub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -7265,7 +7265,7 @@ pub fn _mm_fnmsub_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h, c: __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fnmsub_round_sh<const ROUNDING: i32>(
     a: __m128h,
     k: __mmask8,
@@ -7302,7 +7302,7 @@ pub fn _mm_mask_fnmsub_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask3_fnmsub_round_sh<const ROUNDING: i32>(
     a: __m128h,
     b: __m128h,
@@ -7339,7 +7339,7 @@ pub fn _mm_mask3_fnmsub_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_fnmsub_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -7366,7 +7366,7 @@ pub fn _mm_maskz_fnmsub_round_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmaddsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe {
@@ -7384,7 +7384,7 @@ pub const fn _mm_fmaddsub_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmaddsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmaddsub_ph(a, b, c), a) }
@@ -7398,7 +7398,7 @@ pub const fn _mm_mask_fmaddsub_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmaddsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmaddsub_ph(a, b, c), c) }
@@ -7412,7 +7412,7 @@ pub const fn _mm_mask3_fmaddsub_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmaddsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmaddsub_ph(a, b, c), _mm_setzero_ph()) }
@@ -7425,7 +7425,7 @@ pub const fn _mm_maskz_fmaddsub_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m12
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fmaddsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe {
@@ -7447,7 +7447,7 @@ pub const fn _mm256_fmaddsub_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fmaddsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ph(a, b, c), a) }
@@ -7461,7 +7461,7 @@ pub const fn _mm256_mask_fmaddsub_ph(a: __m256h, k: __mmask16, b: __m256h, c: __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fmaddsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ph(a, b, c), c) }
@@ -7475,7 +7475,7 @@ pub const fn _mm256_mask3_fmaddsub_ph(a: __m256h, b: __m256h, c: __m256h, k: __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fmaddsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ph(a, b, c), _mm256_setzero_ph()) }
@@ -7488,7 +7488,7 @@ pub const fn _mm256_maskz_fmaddsub_ph(k: __mmask16, a: __m256h, b: __m256h, c: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fmaddsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe {
@@ -7513,7 +7513,7 @@ pub const fn _mm512_fmaddsub_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fmaddsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ph(a, b, c), a) }
@@ -7527,7 +7527,7 @@ pub const fn _mm512_mask_fmaddsub_ph(a: __m512h, k: __mmask32, b: __m512h, c: __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fmaddsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ph(a, b, c), c) }
@@ -7541,7 +7541,7 @@ pub const fn _mm512_mask3_fmaddsub_ph(a: __m512h, b: __m512h, c: __m512h, k: __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fmaddsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ph(a, b, c), _mm512_setzero_ph()) }
@@ -7563,7 +7563,7 @@ pub const fn _mm512_maskz_fmaddsub_ph(k: __mmask32, a: __m512h, b: __m512h, c: _
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmaddsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -7592,7 +7592,7 @@ pub fn _mm512_fmaddsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmaddsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -7622,7 +7622,7 @@ pub fn _mm512_mask_fmaddsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmaddsub_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -7652,7 +7652,7 @@ pub fn _mm512_mask3_fmaddsub_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmaddsub_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -7676,7 +7676,7 @@ pub fn _mm512_maskz_fmaddsub_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_fmsubadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     _mm_fmaddsub_ph(a, b, unsafe { simd_neg(c) })
@@ -7690,7 +7690,7 @@ pub const fn _mm_fmsubadd_ph(a: __m128h, b: __m128h, c: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_fmsubadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsubadd_ph(a, b, c), a) }
@@ -7704,7 +7704,7 @@ pub const fn _mm_mask_fmsubadd_ph(a: __m128h, k: __mmask8, b: __m128h, c: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask3_fmsubadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmask8) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsubadd_ph(a, b, c), c) }
@@ -7718,7 +7718,7 @@ pub const fn _mm_mask3_fmsubadd_ph(a: __m128h, b: __m128h, c: __m128h, k: __mmas
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_maskz_fmsubadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_fmsubadd_ph(a, b, c), _mm_setzero_ph()) }
@@ -7731,7 +7731,7 @@ pub const fn _mm_maskz_fmsubadd_ph(k: __mmask8, a: __m128h, b: __m128h, c: __m12
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_fmsubadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     _mm256_fmaddsub_ph(a, b, unsafe { simd_neg(c) })
@@ -7745,7 +7745,7 @@ pub const fn _mm256_fmsubadd_ph(a: __m256h, b: __m256h, c: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_fmsubadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ph(a, b, c), a) }
@@ -7759,7 +7759,7 @@ pub const fn _mm256_mask_fmsubadd_ph(a: __m256h, k: __mmask16, b: __m256h, c: __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask3_fmsubadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __mmask16) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ph(a, b, c), c) }
@@ -7773,7 +7773,7 @@ pub const fn _mm256_mask3_fmsubadd_ph(a: __m256h, b: __m256h, c: __m256h, k: __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_maskz_fmsubadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ph(a, b, c), _mm256_setzero_ph()) }
@@ -7786,7 +7786,7 @@ pub const fn _mm256_maskz_fmsubadd_ph(k: __mmask16, a: __m256h, b: __m256h, c: _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_fmsubadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     _mm512_fmaddsub_ph(a, b, unsafe { simd_neg(c) })
@@ -7800,7 +7800,7 @@ pub const fn _mm512_fmsubadd_ph(a: __m512h, b: __m512h, c: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_fmsubadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ph(a, b, c), a) }
@@ -7814,7 +7814,7 @@ pub const fn _mm512_mask_fmsubadd_ph(a: __m512h, k: __mmask32, b: __m512h, c: __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask3_fmsubadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __mmask32) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ph(a, b, c), c) }
@@ -7828,7 +7828,7 @@ pub const fn _mm512_mask3_fmsubadd_ph(a: __m512h, b: __m512h, c: __m512h, k: __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_maskz_fmsubadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ph(a, b, c), _mm512_setzero_ph()) }
@@ -7850,7 +7850,7 @@ pub const fn _mm512_maskz_fmsubadd_ph(k: __mmask32, a: __m512h, b: __m512h, c: _
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fmsubadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -7879,7 +7879,7 @@ pub fn _mm512_fmsubadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fmsubadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     k: __mmask32,
@@ -7909,7 +7909,7 @@ pub fn _mm512_mask_fmsubadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask3_fmsubadd_round_ph<const ROUNDING: i32>(
     a: __m512h,
     b: __m512h,
@@ -7939,7 +7939,7 @@ pub fn _mm512_mask3_fmsubadd_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_fmsubadd_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -7963,7 +7963,7 @@ pub fn _mm512_maskz_fmsubadd_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_rcp_ph(a: __m128h) -> __m128h {
     _mm_mask_rcp_ph(_mm_undefined_ph(), 0xff, a)
 }
@@ -7976,7 +7976,7 @@ pub fn _mm_rcp_ph(a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_rcp_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe { vrcpph_128(a, src, k) }
 }
@@ -7989,7 +7989,7 @@ pub fn _mm_mask_rcp_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_rcp_ph(k: __mmask8, a: __m128h) -> __m128h {
     _mm_mask_rcp_ph(_mm_setzero_ph(), k, a)
 }
@@ -8001,7 +8001,7 @@ pub fn _mm_maskz_rcp_ph(k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_rcp_ph(a: __m256h) -> __m256h {
     _mm256_mask_rcp_ph(_mm256_undefined_ph(), 0xffff, a)
 }
@@ -8014,7 +8014,7 @@ pub fn _mm256_rcp_ph(a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_rcp_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
     unsafe { vrcpph_256(a, src, k) }
 }
@@ -8027,7 +8027,7 @@ pub fn _mm256_mask_rcp_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_rcp_ph(k: __mmask16, a: __m256h) -> __m256h {
     _mm256_mask_rcp_ph(_mm256_setzero_ph(), k, a)
 }
@@ -8039,7 +8039,7 @@ pub fn _mm256_maskz_rcp_ph(k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_rcp_ph(a: __m512h) -> __m512h {
     _mm512_mask_rcp_ph(_mm512_undefined_ph(), 0xffffffff, a)
 }
@@ -8052,7 +8052,7 @@ pub fn _mm512_rcp_ph(a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_rcp_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
     unsafe { vrcpph_512(a, src, k) }
 }
@@ -8065,7 +8065,7 @@ pub fn _mm512_mask_rcp_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_rcp_ph(k: __mmask32, a: __m512h) -> __m512h {
     _mm512_mask_rcp_ph(_mm512_setzero_ph(), k, a)
 }
@@ -8079,7 +8079,7 @@ pub fn _mm512_maskz_rcp_ph(k: __mmask32, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_rcp_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_rcp_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -8093,7 +8093,7 @@ pub fn _mm_rcp_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_rcp_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { vrcpsh(a, b, src, k) }
 }
@@ -8107,7 +8107,7 @@ pub fn _mm_mask_rcp_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrcpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_rcp_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_rcp_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -8120,7 +8120,7 @@ pub fn _mm_maskz_rcp_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_rsqrt_ph(a: __m128h) -> __m128h {
     _mm_mask_rsqrt_ph(_mm_undefined_ph(), 0xff, a)
 }
@@ -8134,7 +8134,7 @@ pub fn _mm_rsqrt_ph(a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_rsqrt_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe { vrsqrtph_128(a, src, k) }
 }
@@ -8148,7 +8148,7 @@ pub fn _mm_mask_rsqrt_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_rsqrt_ph(k: __mmask8, a: __m128h) -> __m128h {
     _mm_mask_rsqrt_ph(_mm_setzero_ph(), k, a)
 }
@@ -8161,7 +8161,7 @@ pub fn _mm_maskz_rsqrt_ph(k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_rsqrt_ph(a: __m256h) -> __m256h {
     _mm256_mask_rsqrt_ph(_mm256_undefined_ph(), 0xffff, a)
 }
@@ -8175,7 +8175,7 @@ pub fn _mm256_rsqrt_ph(a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_rsqrt_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
     unsafe { vrsqrtph_256(a, src, k) }
 }
@@ -8189,7 +8189,7 @@ pub fn _mm256_mask_rsqrt_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_rsqrt_ph(k: __mmask16, a: __m256h) -> __m256h {
     _mm256_mask_rsqrt_ph(_mm256_setzero_ph(), k, a)
 }
@@ -8202,7 +8202,7 @@ pub fn _mm256_maskz_rsqrt_ph(k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_rsqrt_ph(a: __m512h) -> __m512h {
     _mm512_mask_rsqrt_ph(_mm512_undefined_ph(), 0xffffffff, a)
 }
@@ -8216,7 +8216,7 @@ pub fn _mm512_rsqrt_ph(a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_rsqrt_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
     unsafe { vrsqrtph_512(a, src, k) }
 }
@@ -8230,7 +8230,7 @@ pub fn _mm512_mask_rsqrt_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_rsqrt_ph(k: __mmask32, a: __m512h) -> __m512h {
     _mm512_mask_rsqrt_ph(_mm512_setzero_ph(), k, a)
 }
@@ -8244,7 +8244,7 @@ pub fn _mm512_maskz_rsqrt_ph(k: __mmask32, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_rsqrt_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_rsqrt_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -8258,7 +8258,7 @@ pub fn _mm_rsqrt_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_rsqrt_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { vrsqrtsh(a, b, src, k) }
 }
@@ -8272,7 +8272,7 @@ pub fn _mm_mask_rsqrt_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_rsqrt_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_rsqrt_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -8284,7 +8284,7 @@ pub fn _mm_maskz_rsqrt_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_sqrt_ph(a: __m128h) -> __m128h {
     unsafe { simd_fsqrt(a) }
 }
@@ -8296,7 +8296,7 @@ pub fn _mm_sqrt_ph(a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_sqrt_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_sqrt_ph(a), src) }
 }
@@ -8308,7 +8308,7 @@ pub fn _mm_mask_sqrt_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_sqrt_ph(k: __mmask8, a: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_sqrt_ph(a), _mm_setzero_ph()) }
 }
@@ -8320,7 +8320,7 @@ pub fn _mm_maskz_sqrt_ph(k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_sqrt_ph(a: __m256h) -> __m256h {
     unsafe { simd_fsqrt(a) }
 }
@@ -8332,7 +8332,7 @@ pub fn _mm256_sqrt_ph(a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_sqrt_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_sqrt_ph(a), src) }
 }
@@ -8344,7 +8344,7 @@ pub fn _mm256_mask_sqrt_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_sqrt_ph(k: __mmask16, a: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_sqrt_ph(a), _mm256_setzero_ph()) }
 }
@@ -8356,7 +8356,7 @@ pub fn _mm256_maskz_sqrt_ph(k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_sqrt_ph(a: __m512h) -> __m512h {
     unsafe { simd_fsqrt(a) }
 }
@@ -8368,7 +8368,7 @@ pub fn _mm512_sqrt_ph(a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_sqrt_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_sqrt_ph(a), src) }
 }
@@ -8380,7 +8380,7 @@ pub fn _mm512_mask_sqrt_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_sqrt_ph(k: __mmask32, a: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_sqrt_ph(a), _mm512_setzero_ph()) }
 }
@@ -8400,7 +8400,7 @@ pub fn _mm512_maskz_sqrt_ph(k: __mmask32, a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_sqrt_round_ph<const ROUNDING: i32>(a: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -8423,7 +8423,7 @@ pub fn _mm512_sqrt_round_ph<const ROUNDING: i32>(a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_sqrt_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -8450,7 +8450,7 @@ pub fn _mm512_mask_sqrt_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_sqrt_round_ph<const ROUNDING: i32>(k: __mmask32, a: __m512h) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -8466,7 +8466,7 @@ pub fn _mm512_maskz_sqrt_round_ph<const ROUNDING: i32>(k: __mmask32, a: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_sqrt_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_sqrt_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -8479,7 +8479,7 @@ pub fn _mm_sqrt_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_sqrt_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_sqrt_round_sh::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -8492,7 +8492,7 @@ pub fn _mm_mask_sqrt_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_sqrt_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_sqrt_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -8513,7 +8513,7 @@ pub fn _mm_maskz_sqrt_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_sqrt_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_sqrt_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -8535,7 +8535,7 @@ pub fn _mm_sqrt_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_sqrt_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -8564,7 +8564,7 @@ pub fn _mm_mask_sqrt_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vsqrtsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_sqrt_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -8582,7 +8582,7 @@ pub fn _mm_maskz_sqrt_round_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_max_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { vmaxph_128(a, b) }
 }
@@ -8596,7 +8596,7 @@ pub fn _mm_max_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_max_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_max_ph(a, b), src) }
 }
@@ -8610,7 +8610,7 @@ pub fn _mm_mask_max_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_max_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_max_ph(a, b), _mm_setzero_ph()) }
 }
@@ -8623,7 +8623,7 @@ pub fn _mm_maskz_max_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_max_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { vmaxph_256(a, b) }
 }
@@ -8637,7 +8637,7 @@ pub fn _mm256_max_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_max_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_max_ph(a, b), src) }
 }
@@ -8651,7 +8651,7 @@ pub fn _mm256_mask_max_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_max_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_max_ph(a, b), _mm256_setzero_ph()) }
 }
@@ -8664,7 +8664,7 @@ pub fn _mm256_maskz_max_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_max_ph(a: __m512h, b: __m512h) -> __m512h {
     _mm512_max_round_ph::<_MM_FROUND_CUR_DIRECTION>(a, b)
 }
@@ -8678,7 +8678,7 @@ pub fn _mm512_max_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_max_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_max_ph(a, b), src) }
 }
@@ -8692,7 +8692,7 @@ pub fn _mm512_mask_max_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_max_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_max_ph(a, b), _mm512_setzero_ph()) }
 }
@@ -8707,7 +8707,7 @@ pub fn _mm512_maskz_max_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_max_round_ph<const SAE: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_sae!(SAE);
@@ -8725,7 +8725,7 @@ pub fn _mm512_max_round_ph<const SAE: i32>(a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_max_round_ph<const SAE: i32>(
     src: __m512h,
     k: __mmask32,
@@ -8748,7 +8748,7 @@ pub fn _mm512_mask_max_round_ph<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vmaxph, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_max_round_ph<const SAE: i32>(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_sae!(SAE);
@@ -8765,7 +8765,7 @@ pub fn _mm512_maskz_max_round_ph<const SAE: i32>(k: __mmask32, a: __m512h, b: __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_max_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_max_sh(_mm_undefined_ph(), 0xff, a, b)
 }
@@ -8779,7 +8779,7 @@ pub fn _mm_max_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_max_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_max_round_sh::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -8793,7 +8793,7 @@ pub fn _mm_mask_max_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_max_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_max_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -8808,7 +8808,7 @@ pub fn _mm_maskz_max_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_max_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_max_round_sh::<SAE>(_mm_undefined_ph(), 0xff, a, b)
@@ -8825,7 +8825,7 @@ pub fn _mm_max_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_max_round_sh<const SAE: i32>(
     src: __m128h,
     k: __mmask8,
@@ -8849,7 +8849,7 @@ pub fn _mm_mask_max_round_sh<const SAE: i32>(
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vmaxsh, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_max_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_max_round_sh::<SAE>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -8863,7 +8863,7 @@ pub fn _mm_maskz_max_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_min_ph(a: __m128h, b: __m128h) -> __m128h {
     unsafe { vminph_128(a, b) }
 }
@@ -8877,7 +8877,7 @@ pub fn _mm_min_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_min_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_min_ph(a, b), src) }
 }
@@ -8891,7 +8891,7 @@ pub fn _mm_mask_min_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_min_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_min_ph(a, b), _mm_setzero_ph()) }
 }
@@ -8904,7 +8904,7 @@ pub fn _mm_maskz_min_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_min_ph(a: __m256h, b: __m256h) -> __m256h {
     unsafe { vminph_256(a, b) }
 }
@@ -8918,7 +8918,7 @@ pub fn _mm256_min_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_min_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_min_ph(a, b), src) }
 }
@@ -8932,7 +8932,7 @@ pub fn _mm256_mask_min_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_min_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_min_ph(a, b), _mm256_setzero_ph()) }
 }
@@ -8945,7 +8945,7 @@ pub fn _mm256_maskz_min_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_min_ph(a: __m512h, b: __m512h) -> __m512h {
     _mm512_min_round_ph::<_MM_FROUND_CUR_DIRECTION>(a, b)
 }
@@ -8959,7 +8959,7 @@ pub fn _mm512_min_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_min_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_min_ph(a, b), src) }
 }
@@ -8973,7 +8973,7 @@ pub fn _mm512_mask_min_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_min_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_min_ph(a, b), _mm512_setzero_ph()) }
 }
@@ -8987,7 +8987,7 @@ pub fn _mm512_maskz_min_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_min_round_ph<const SAE: i32>(a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_sae!(SAE);
@@ -9005,7 +9005,7 @@ pub fn _mm512_min_round_ph<const SAE: i32>(a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_min_round_ph<const SAE: i32>(
     src: __m512h,
     k: __mmask32,
@@ -9028,7 +9028,7 @@ pub fn _mm512_mask_min_round_ph<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vminph, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_min_round_ph<const SAE: i32>(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe {
         static_assert_sae!(SAE);
@@ -9045,7 +9045,7 @@ pub fn _mm512_maskz_min_round_ph<const SAE: i32>(k: __mmask32, a: __m512h, b: __
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_min_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_min_sh(_mm_undefined_ph(), 0xff, a, b)
 }
@@ -9059,7 +9059,7 @@ pub fn _mm_min_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_min_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_min_round_sh::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -9073,7 +9073,7 @@ pub fn _mm_mask_min_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_min_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_min_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -9088,7 +9088,7 @@ pub fn _mm_maskz_min_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_min_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_min_round_sh::<SAE>(_mm_undefined_ph(), 0xff, a, b)
@@ -9105,7 +9105,7 @@ pub fn _mm_min_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_min_round_sh<const SAE: i32>(
     src: __m128h,
     k: __mmask8,
@@ -9129,7 +9129,7 @@ pub fn _mm_mask_min_round_sh<const SAE: i32>(
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vminsh, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_min_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_min_round_sh::<SAE>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -9143,7 +9143,7 @@ pub fn _mm_maskz_min_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m128
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getexp_ph(a: __m128h) -> __m128h {
     _mm_mask_getexp_ph(_mm_undefined_ph(), 0xff, a)
 }
@@ -9157,7 +9157,7 @@ pub fn _mm_getexp_ph(a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getexp_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe { vgetexpph_128(a, src, k) }
 }
@@ -9171,7 +9171,7 @@ pub fn _mm_mask_getexp_ph(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getexp_ph(k: __mmask8, a: __m128h) -> __m128h {
     _mm_mask_getexp_ph(_mm_setzero_ph(), k, a)
 }
@@ -9184,7 +9184,7 @@ pub fn _mm_maskz_getexp_ph(k: __mmask8, a: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_getexp_ph(a: __m256h) -> __m256h {
     _mm256_mask_getexp_ph(_mm256_undefined_ph(), 0xffff, a)
 }
@@ -9198,7 +9198,7 @@ pub fn _mm256_getexp_ph(a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_getexp_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
     unsafe { vgetexpph_256(a, src, k) }
 }
@@ -9212,7 +9212,7 @@ pub fn _mm256_mask_getexp_ph(src: __m256h, k: __mmask16, a: __m256h) -> __m256h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_getexp_ph(k: __mmask16, a: __m256h) -> __m256h {
     _mm256_mask_getexp_ph(_mm256_setzero_ph(), k, a)
 }
@@ -9225,7 +9225,7 @@ pub fn _mm256_maskz_getexp_ph(k: __mmask16, a: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_getexp_ph(a: __m512h) -> __m512h {
     _mm512_mask_getexp_ph(_mm512_undefined_ph(), 0xffffffff, a)
 }
@@ -9239,7 +9239,7 @@ pub fn _mm512_getexp_ph(a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_getexp_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
     _mm512_mask_getexp_round_ph::<_MM_FROUND_CUR_DIRECTION>(src, k, a)
 }
@@ -9253,7 +9253,7 @@ pub fn _mm512_mask_getexp_ph(src: __m512h, k: __mmask32, a: __m512h) -> __m512h
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_getexp_ph(k: __mmask32, a: __m512h) -> __m512h {
     _mm512_mask_getexp_ph(_mm512_setzero_ph(), k, a)
 }
@@ -9268,7 +9268,7 @@ pub fn _mm512_maskz_getexp_ph(k: __mmask32, a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_getexp_round_ph<const SAE: i32>(a: __m512h) -> __m512h {
     static_assert_sae!(SAE);
     _mm512_mask_getexp_round_ph::<SAE>(_mm512_undefined_ph(), 0xffffffff, a)
@@ -9284,7 +9284,7 @@ pub fn _mm512_getexp_round_ph<const SAE: i32>(a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_getexp_round_ph<const SAE: i32>(
     src: __m512h,
     k: __mmask32,
@@ -9306,7 +9306,7 @@ pub fn _mm512_mask_getexp_round_ph<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpph, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_getexp_round_ph<const SAE: i32>(k: __mmask32, a: __m512h) -> __m512h {
     static_assert_sae!(SAE);
     _mm512_mask_getexp_round_ph::<SAE>(_mm512_setzero_ph(), k, a)
@@ -9321,7 +9321,7 @@ pub fn _mm512_maskz_getexp_round_ph<const SAE: i32>(k: __mmask32, a: __m512h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getexp_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_getexp_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -9336,7 +9336,7 @@ pub fn _mm_getexp_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getexp_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_getexp_round_sh::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -9351,7 +9351,7 @@ pub fn _mm_mask_getexp_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getexp_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_getexp_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -9367,7 +9367,7 @@ pub fn _mm_maskz_getexp_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getexp_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_getexp_round_sh::<SAE>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -9384,7 +9384,7 @@ pub fn _mm_getexp_round_sh<const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getexp_round_sh<const SAE: i32>(
     src: __m128h,
     k: __mmask8,
@@ -9408,7 +9408,7 @@ pub fn _mm_mask_getexp_round_sh<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetexpsh, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getexp_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_sae!(SAE);
     _mm_mask_getexp_round_sh::<SAE>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -9436,7 +9436,7 @@ pub fn _mm_maskz_getexp_round_sh<const SAE: i32>(k: __mmask8, a: __m128h, b: __m
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(1, 2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
     a: __m128h,
 ) -> __m128h {
@@ -9468,7 +9468,7 @@ pub fn _mm_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTIS
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9507,7 +9507,7 @@ pub fn _mm_mask_getmant_ph<
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9542,7 +9542,7 @@ pub fn _mm_maskz_getmant_ph<
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(1, 2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
     a: __m256h,
 ) -> __m256h {
@@ -9574,7 +9574,7 @@ pub fn _mm256_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MAN
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9613,7 +9613,7 @@ pub fn _mm256_mask_getmant_ph<
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9648,7 +9648,7 @@ pub fn _mm256_maskz_getmant_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(1, 2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
     a: __m512h,
 ) -> __m512h {
@@ -9680,7 +9680,7 @@ pub fn _mm512_getmant_ph<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MAN
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9717,7 +9717,7 @@ pub fn _mm512_mask_getmant_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_getmant_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9755,7 +9755,7 @@ pub fn _mm512_maskz_getmant_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(1, 2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_getmant_round_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9795,7 +9795,7 @@ pub fn _mm512_getmant_round_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4, 5)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_getmant_round_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9839,7 +9839,7 @@ pub fn _mm512_mask_getmant_round_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantph, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_getmant_round_ph<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9877,7 +9877,7 @@ pub fn _mm512_maskz_getmant_round_ph<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getmant_sh<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
     a: __m128h,
     b: __m128h,
@@ -9911,7 +9911,7 @@ pub fn _mm_getmant_sh<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTIS
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(4, 5)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getmant_sh<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9950,7 +9950,7 @@ pub fn _mm_mask_getmant_sh<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getmant_sh<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -9990,7 +9990,7 @@ pub fn _mm_maskz_getmant_sh<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_getmant_round_sh<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -10031,7 +10031,7 @@ pub fn _mm_getmant_round_sh<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(4, 5, 6)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_getmant_round_sh<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -10076,7 +10076,7 @@ pub fn _mm_mask_getmant_round_sh<
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vgetmantsh, NORM = 0, SIGN = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4, 5)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_getmant_round_sh<
     const NORM: _MM_MANTISSA_NORM_ENUM,
     const SIGN: _MM_MANTISSA_SIGN_ENUM,
@@ -10108,7 +10108,7 @@ pub fn _mm_maskz_getmant_round_sh<
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_roundscale_ph<const IMM8: i32>(a: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_roundscale_ph::<IMM8>(_mm_undefined_ph(), 0xff, a)
@@ -10131,7 +10131,7 @@ pub fn _mm_roundscale_ph<const IMM8: i32>(a: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_roundscale_ph<const IMM8: i32>(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -10156,7 +10156,7 @@ pub fn _mm_mask_roundscale_ph<const IMM8: i32>(src: __m128h, k: __mmask8, a: __m
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_roundscale_ph<const IMM8: i32>(k: __mmask8, a: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_roundscale_ph::<IMM8>(_mm_setzero_ph(), k, a)
@@ -10178,7 +10178,7 @@ pub fn _mm_maskz_roundscale_ph<const IMM8: i32>(k: __mmask8, a: __m128h) -> __m1
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_roundscale_ph<const IMM8: i32>(a: __m256h) -> __m256h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm256_mask_roundscale_ph::<IMM8>(_mm256_undefined_ph(), 0xffff, a)
@@ -10201,7 +10201,7 @@ pub fn _mm256_roundscale_ph<const IMM8: i32>(a: __m256h) -> __m256h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_roundscale_ph<const IMM8: i32>(
     src: __m256h,
     k: __mmask16,
@@ -10230,7 +10230,7 @@ pub fn _mm256_mask_roundscale_ph<const IMM8: i32>(
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_roundscale_ph<const IMM8: i32>(k: __mmask16, a: __m256h) -> __m256h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm256_mask_roundscale_ph::<IMM8>(_mm256_setzero_ph(), k, a)
@@ -10252,7 +10252,7 @@ pub fn _mm256_maskz_roundscale_ph<const IMM8: i32>(k: __mmask16, a: __m256h) ->
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_roundscale_ph<const IMM8: i32>(a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm512_mask_roundscale_ph::<IMM8>(_mm512_undefined_ph(), 0xffffffff, a)
@@ -10275,7 +10275,7 @@ pub fn _mm512_roundscale_ph<const IMM8: i32>(a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_roundscale_ph<const IMM8: i32>(
     src: __m512h,
     k: __mmask32,
@@ -10302,7 +10302,7 @@ pub fn _mm512_mask_roundscale_ph<const IMM8: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_roundscale_ph<const IMM8: i32>(k: __mmask32, a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm512_mask_roundscale_ph::<IMM8>(_mm512_setzero_ph(), k, a)
@@ -10325,7 +10325,7 @@ pub fn _mm512_maskz_roundscale_ph<const IMM8: i32>(k: __mmask32, a: __m512h) ->
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(1, 2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_roundscale_round_ph<const IMM8: i32, const SAE: i32>(a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     static_assert_sae!(SAE);
@@ -10350,7 +10350,7 @@ pub fn _mm512_roundscale_round_ph<const IMM8: i32, const SAE: i32>(a: __m512h) -
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_roundscale_round_ph<const IMM8: i32, const SAE: i32>(
     src: __m512h,
     k: __mmask32,
@@ -10380,7 +10380,7 @@ pub fn _mm512_mask_roundscale_round_ph<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscaleph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_roundscale_round_ph<const IMM8: i32, const SAE: i32>(
     k: __mmask32,
     a: __m512h,
@@ -10407,7 +10407,7 @@ pub fn _mm512_maskz_roundscale_round_ph<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_roundscale_sh<const IMM8: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_roundscale_sh::<IMM8>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -10430,7 +10430,7 @@ pub fn _mm_roundscale_sh<const IMM8: i32>(a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_roundscale_sh<const IMM8: i32>(
     src: __m128h,
     k: __mmask8,
@@ -10458,7 +10458,7 @@ pub fn _mm_mask_roundscale_sh<const IMM8: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_roundscale_sh<const IMM8: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_roundscale_sh::<IMM8>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -10483,7 +10483,7 @@ pub fn _mm_maskz_roundscale_sh<const IMM8: i32>(k: __mmask8, a: __m128h, b: __m1
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_roundscale_round_sh<const IMM8: i32, const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     static_assert_sae!(SAE);
@@ -10509,7 +10509,7 @@ pub fn _mm_roundscale_round_sh<const IMM8: i32, const SAE: i32>(a: __m128h, b: _
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(4, 5)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_roundscale_round_sh<const IMM8: i32, const SAE: i32>(
     src: __m128h,
     k: __mmask8,
@@ -10542,7 +10542,7 @@ pub fn _mm_mask_roundscale_round_sh<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vrndscalesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_roundscale_round_sh<const IMM8: i32, const SAE: i32>(
     k: __mmask8,
     a: __m128h,
@@ -10560,7 +10560,7 @@ pub fn _mm_maskz_roundscale_round_sh<const IMM8: i32, const SAE: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_scalef_ph(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_scalef_ph(_mm_undefined_ph(), 0xff, a, b)
 }
@@ -10572,7 +10572,7 @@ pub fn _mm_scalef_ph(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_scalef_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { vscalefph_128(a, b, src, k) }
 }
@@ -10584,7 +10584,7 @@ pub fn _mm_mask_scalef_ph(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_scalef_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_scalef_ph(_mm_setzero_ph(), k, a, b)
 }
@@ -10596,7 +10596,7 @@ pub fn _mm_maskz_scalef_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_scalef_ph(a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_scalef_ph(_mm256_undefined_ph(), 0xffff, a, b)
 }
@@ -10608,7 +10608,7 @@ pub fn _mm256_scalef_ph(a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_scalef_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { vscalefph_256(a, b, src, k) }
 }
@@ -10620,7 +10620,7 @@ pub fn _mm256_mask_scalef_ph(src: __m256h, k: __mmask16, a: __m256h, b: __m256h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_scalef_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     _mm256_mask_scalef_ph(_mm256_setzero_ph(), k, a, b)
 }
@@ -10632,7 +10632,7 @@ pub fn _mm256_maskz_scalef_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_scalef_ph(a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_scalef_ph(_mm512_undefined_ph(), 0xffffffff, a, b)
 }
@@ -10644,7 +10644,7 @@ pub fn _mm512_scalef_ph(a: __m512h, b: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_scalef_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_scalef_round_ph::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -10656,7 +10656,7 @@ pub fn _mm512_mask_scalef_ph(src: __m512h, k: __mmask32, a: __m512h, b: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_scalef_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     _mm512_mask_scalef_ph(_mm512_setzero_ph(), k, a, b)
 }
@@ -10677,7 +10677,7 @@ pub fn _mm512_maskz_scalef_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_scalef_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_scalef_round_ph::<ROUNDING>(_mm512_undefined_ph(), 0xffffffff, a, b)
@@ -10699,7 +10699,7 @@ pub fn _mm512_scalef_round_ph<const ROUNDING: i32>(a: __m512h, b: __m512h) -> __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_scalef_round_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -10728,7 +10728,7 @@ pub fn _mm512_mask_scalef_round_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_scalef_round_ph<const ROUNDING: i32>(
     k: __mmask32,
     a: __m512h,
@@ -10746,7 +10746,7 @@ pub fn _mm512_maskz_scalef_round_ph<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_scalef_sh(a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_scalef_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -10759,7 +10759,7 @@ pub fn _mm_scalef_sh(a: __m128h, b: __m128h) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_scalef_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_scalef_round_sh::<_MM_FROUND_CUR_DIRECTION>(src, k, a, b)
 }
@@ -10772,7 +10772,7 @@ pub fn _mm_mask_scalef_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_scalef_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     _mm_mask_scalef_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -10794,7 +10794,7 @@ pub fn _mm_maskz_scalef_sh(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_scalef_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_scalef_round_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -10817,7 +10817,7 @@ pub fn _mm_scalef_round_sh<const ROUNDING: i32>(a: __m128h, b: __m128h) -> __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_scalef_round_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -10847,7 +10847,7 @@ pub fn _mm_mask_scalef_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vscalefsh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_scalef_round_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -10873,7 +10873,7 @@ pub fn _mm_maskz_scalef_round_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_reduce_ph<const IMM8: i32>(a: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_reduce_ph::<IMM8>(_mm_undefined_ph(), 0xff, a)
@@ -10896,7 +10896,7 @@ pub fn _mm_reduce_ph<const IMM8: i32>(a: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_reduce_ph<const IMM8: i32>(src: __m128h, k: __mmask8, a: __m128h) -> __m128h {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -10921,7 +10921,7 @@ pub fn _mm_mask_reduce_ph<const IMM8: i32>(src: __m128h, k: __mmask8, a: __m128h
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_reduce_ph<const IMM8: i32>(k: __mmask8, a: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_reduce_ph::<IMM8>(_mm_setzero_ph(), k, a)
@@ -10943,7 +10943,7 @@ pub fn _mm_maskz_reduce_ph<const IMM8: i32>(k: __mmask8, a: __m128h) -> __m128h
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_reduce_ph<const IMM8: i32>(a: __m256h) -> __m256h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm256_mask_reduce_ph::<IMM8>(_mm256_undefined_ph(), 0xffff, a)
@@ -10966,7 +10966,7 @@ pub fn _mm256_reduce_ph<const IMM8: i32>(a: __m256h) -> __m256h {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_reduce_ph<const IMM8: i32>(src: __m256h, k: __mmask16, a: __m256h) -> __m256h {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -10991,7 +10991,7 @@ pub fn _mm256_mask_reduce_ph<const IMM8: i32>(src: __m256h, k: __mmask16, a: __m
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_reduce_ph<const IMM8: i32>(k: __mmask16, a: __m256h) -> __m256h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm256_mask_reduce_ph::<IMM8>(_mm256_setzero_ph(), k, a)
@@ -11013,7 +11013,7 @@ pub fn _mm256_maskz_reduce_ph<const IMM8: i32>(k: __mmask16, a: __m256h) -> __m2
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_reduce_ph<const IMM8: i32>(a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm512_mask_reduce_ph::<IMM8>(_mm512_undefined_ph(), 0xffffffff, a)
@@ -11036,7 +11036,7 @@ pub fn _mm512_reduce_ph<const IMM8: i32>(a: __m512h) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_reduce_ph<const IMM8: i32>(src: __m512h, k: __mmask32, a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm512_mask_reduce_round_ph::<IMM8, _MM_FROUND_CUR_DIRECTION>(src, k, a)
@@ -11059,7 +11059,7 @@ pub fn _mm512_mask_reduce_ph<const IMM8: i32>(src: __m512h, k: __mmask32, a: __m
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_reduce_ph<const IMM8: i32>(k: __mmask32, a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm512_mask_reduce_ph::<IMM8>(_mm512_setzero_ph(), k, a)
@@ -11083,7 +11083,7 @@ pub fn _mm512_maskz_reduce_ph<const IMM8: i32>(k: __mmask32, a: __m512h) -> __m5
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(1, 2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_reduce_round_ph<const IMM8: i32, const SAE: i32>(a: __m512h) -> __m512h {
     static_assert_uimm_bits!(IMM8, 8);
     static_assert_sae!(SAE);
@@ -11109,7 +11109,7 @@ pub fn _mm512_reduce_round_ph<const IMM8: i32, const SAE: i32>(a: __m512h) -> __
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_reduce_round_ph<const IMM8: i32, const SAE: i32>(
     src: __m512h,
     k: __mmask32,
@@ -11141,7 +11141,7 @@ pub fn _mm512_mask_reduce_round_ph<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreduceph, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_reduce_round_ph<const IMM8: i32, const SAE: i32>(
     k: __mmask32,
     a: __m512h,
@@ -11168,7 +11168,7 @@ pub fn _mm512_maskz_reduce_round_ph<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_reduce_sh<const IMM8: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_reduce_sh::<IMM8>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -11192,7 +11192,7 @@ pub fn _mm_reduce_sh<const IMM8: i32>(a: __m128h, b: __m128h) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_reduce_sh<const IMM8: i32>(
     src: __m128h,
     k: __mmask8,
@@ -11221,7 +11221,7 @@ pub fn _mm_mask_reduce_sh<const IMM8: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_reduce_sh<const IMM8: i32>(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     _mm_mask_reduce_sh::<IMM8>(f16x8::ZERO.as_m128h(), k, a, b)
@@ -11246,7 +11246,7 @@ pub fn _mm_maskz_reduce_sh<const IMM8: i32>(k: __mmask8, a: __m128h, b: __m128h)
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(2, 3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_reduce_round_sh<const IMM8: i32, const SAE: i32>(a: __m128h, b: __m128h) -> __m128h {
     static_assert_uimm_bits!(IMM8, 8);
     static_assert_sae!(SAE);
@@ -11273,7 +11273,7 @@ pub fn _mm_reduce_round_sh<const IMM8: i32, const SAE: i32>(a: __m128h, b: __m12
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(4, 5)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_reduce_round_sh<const IMM8: i32, const SAE: i32>(
     src: __m128h,
     k: __mmask8,
@@ -11307,7 +11307,7 @@ pub fn _mm_mask_reduce_round_sh<const IMM8: i32, const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vreducesh, IMM8 = 0, SAE = 8))]
 #[rustc_legacy_const_generics(3, 4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_reduce_round_sh<const IMM8: i32, const SAE: i32>(
     k: __mmask8,
     a: __m128h,
@@ -11582,7 +11582,7 @@ macro_rules! fpclass_asm { // FIXME: use LLVM intrinsics
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fpclass_ph_mask<const IMM8: i32>(a: __m128h) -> __mmask8 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11609,7 +11609,7 @@ pub fn _mm_fpclass_ph_mask<const IMM8: i32>(a: __m128h) -> __mmask8 {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask8, a: __m128h) -> __mmask8 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11635,7 +11635,7 @@ pub fn _mm_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask8, a: __m128h) -> __
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_fpclass_ph_mask<const IMM8: i32>(a: __m256h) -> __mmask16 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11662,7 +11662,7 @@ pub fn _mm256_fpclass_ph_mask<const IMM8: i32>(a: __m256h) -> __mmask16 {
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask16, a: __m256h) -> __mmask16 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11688,7 +11688,7 @@ pub fn _mm256_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask16, a: __m256h) -
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_fpclass_ph_mask<const IMM8: i32>(a: __m512h) -> __mmask32 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11715,7 +11715,7 @@ pub fn _mm512_fpclass_ph_mask<const IMM8: i32>(a: __m512h) -> __mmask32 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfpclassph, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask32, a: __m512h) -> __mmask32 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11741,7 +11741,7 @@ pub fn _mm512_mask_fpclass_ph_mask<const IMM8: i32>(k1: __mmask32, a: __m512h) -
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfpclasssh, IMM8 = 0))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_fpclass_sh_mask<const IMM8: i32>(a: __m128h) -> __mmask8 {
     _mm_mask_fpclass_sh_mask::<IMM8>(0xff, a)
 }
@@ -11765,7 +11765,7 @@ pub fn _mm_fpclass_sh_mask<const IMM8: i32>(a: __m128h) -> __mmask8 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vfpclasssh, IMM8 = 0))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_fpclass_sh_mask<const IMM8: i32>(k1: __mmask8, a: __m128h) -> __mmask8 {
     unsafe {
         static_assert_uimm_bits!(IMM8, 8);
@@ -11779,7 +11779,7 @@ pub fn _mm_mask_fpclass_sh_mask<const IMM8: i32>(k1: __mmask8, a: __m128h) -> __
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mask_blend_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_mask_blend_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
     unsafe { simd_select_bitmask(k, b, a) }
@@ -11791,7 +11791,7 @@ pub const fn _mm_mask_blend_ph(k: __mmask8, a: __m128h, b: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_mask_blend_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm256_mask_blend_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m256h {
     unsafe { simd_select_bitmask(k, b, a) }
@@ -11803,7 +11803,7 @@ pub const fn _mm256_mask_blend_ph(k: __mmask16, a: __m256h, b: __m256h) -> __m25
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_mask_blend_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm512_mask_blend_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m512h {
     unsafe { simd_select_bitmask(k, b, a) }
@@ -11815,7 +11815,7 @@ pub const fn _mm512_mask_blend_ph(k: __mmask32, a: __m512h, b: __m512h) -> __m51
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_permutex2var_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_permutex2var_ph(a: __m128h, idx: __m128i, b: __m128h) -> __m128h {
     _mm_castsi128_ph(_mm_permutex2var_epi16(
         _mm_castph_si128(a),
@@ -11830,7 +11830,7 @@ pub fn _mm_permutex2var_ph(a: __m128h, idx: __m128i, b: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_permutex2var_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_permutex2var_ph(a: __m256h, idx: __m256i, b: __m256h) -> __m256h {
     _mm256_castsi256_ph(_mm256_permutex2var_epi16(
         _mm256_castph_si256(a),
@@ -11845,7 +11845,7 @@ pub fn _mm256_permutex2var_ph(a: __m256h, idx: __m256i, b: __m256h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_permutex2var_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_permutex2var_ph(a: __m512h, idx: __m512i, b: __m512h) -> __m512h {
     _mm512_castsi512_ph(_mm512_permutex2var_epi16(
         _mm512_castph_si512(a),
@@ -11860,7 +11860,7 @@ pub fn _mm512_permutex2var_ph(a: __m512h, idx: __m512i, b: __m512h) -> __m512h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_permutexvar_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_permutexvar_ph(idx: __m128i, a: __m128h) -> __m128h {
     _mm_castsi128_ph(_mm_permutexvar_epi16(idx, _mm_castph_si128(a)))
 }
@@ -11871,7 +11871,7 @@ pub fn _mm_permutexvar_ph(idx: __m128i, a: __m128h) -> __m128h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm256_permutexvar_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_permutexvar_ph(idx: __m256i, a: __m256h) -> __m256h {
     _mm256_castsi256_ph(_mm256_permutexvar_epi16(idx, _mm256_castph_si256(a)))
 }
@@ -11882,7 +11882,7 @@ pub fn _mm256_permutexvar_ph(idx: __m256i, a: __m256h) -> __m256h {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm512_permutexvar_ph)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_permutexvar_ph(idx: __m512i, a: __m512h) -> __m512h {
     _mm512_castsi512_ph(_mm512_permutexvar_epi16(idx, _mm512_castph_si512(a)))
 }
@@ -11894,7 +11894,7 @@ pub fn _mm512_permutexvar_ph(idx: __m512i, a: __m512h) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepi16_ph(a: __m128i) -> __m128h {
     unsafe { vcvtw2ph_128(a.as_i16x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -11907,7 +11907,7 @@ pub fn _mm_cvtepi16_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepi16_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_cvtepi16_ph(a), src) }
 }
@@ -11919,7 +11919,7 @@ pub fn _mm_mask_cvtepi16_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepi16_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepi16_ph(_mm_setzero_ph(), k, a)
 }
@@ -11931,7 +11931,7 @@ pub fn _mm_maskz_cvtepi16_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepi16_ph(a: __m256i) -> __m256h {
     unsafe { vcvtw2ph_256(a.as_i16x16(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -11944,7 +11944,7 @@ pub fn _mm256_cvtepi16_ph(a: __m256i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepi16_ph(src: __m256h, k: __mmask16, a: __m256i) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_cvtepi16_ph(a), src) }
 }
@@ -11956,7 +11956,7 @@ pub fn _mm256_mask_cvtepi16_ph(src: __m256h, k: __mmask16, a: __m256i) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepi16_ph(k: __mmask16, a: __m256i) -> __m256h {
     _mm256_mask_cvtepi16_ph(_mm256_setzero_ph(), k, a)
 }
@@ -11968,7 +11968,7 @@ pub fn _mm256_maskz_cvtepi16_ph(k: __mmask16, a: __m256i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepi16_ph(a: __m512i) -> __m512h {
     unsafe { vcvtw2ph_512(a.as_i16x32(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -11981,7 +11981,7 @@ pub fn _mm512_cvtepi16_ph(a: __m512i) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepi16_ph(src: __m512h, k: __mmask32, a: __m512i) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepi16_ph(a), src) }
 }
@@ -11993,7 +11993,7 @@ pub fn _mm512_mask_cvtepi16_ph(src: __m512h, k: __mmask32, a: __m512i) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepi16_ph(k: __mmask32, a: __m512i) -> __m512h {
     _mm512_mask_cvtepi16_ph(_mm512_setzero_ph(), k, a)
 }
@@ -12014,7 +12014,7 @@ pub fn _mm512_maskz_cvtepi16_ph(k: __mmask32, a: __m512i) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepi16_ph<const ROUNDING: i32>(a: __m512i) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12039,7 +12039,7 @@ pub fn _mm512_cvt_roundepi16_ph<const ROUNDING: i32>(a: __m512i) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepi16_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -12067,7 +12067,7 @@ pub fn _mm512_mask_cvt_roundepi16_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepi16_ph<const ROUNDING: i32>(k: __mmask32, a: __m512i) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepi16_ph::<ROUNDING>(_mm512_setzero_ph(), k, a)
@@ -12080,7 +12080,7 @@ pub fn _mm512_maskz_cvt_roundepi16_ph<const ROUNDING: i32>(k: __mmask32, a: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepu16_ph(a: __m128i) -> __m128h {
     unsafe { vcvtuw2ph_128(a.as_u16x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12093,7 +12093,7 @@ pub fn _mm_cvtepu16_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepu16_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm_cvtepu16_ph(a), src) }
 }
@@ -12105,7 +12105,7 @@ pub fn _mm_mask_cvtepu16_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepu16_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepu16_ph(_mm_setzero_ph(), k, a)
 }
@@ -12117,7 +12117,7 @@ pub fn _mm_maskz_cvtepu16_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepu16_ph(a: __m256i) -> __m256h {
     unsafe { vcvtuw2ph_256(a.as_u16x16(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12130,7 +12130,7 @@ pub fn _mm256_cvtepu16_ph(a: __m256i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepu16_ph(src: __m256h, k: __mmask16, a: __m256i) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm256_cvtepu16_ph(a), src) }
 }
@@ -12142,7 +12142,7 @@ pub fn _mm256_mask_cvtepu16_ph(src: __m256h, k: __mmask16, a: __m256i) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepu16_ph(k: __mmask16, a: __m256i) -> __m256h {
     _mm256_mask_cvtepu16_ph(_mm256_setzero_ph(), k, a)
 }
@@ -12154,7 +12154,7 @@ pub fn _mm256_maskz_cvtepu16_ph(k: __mmask16, a: __m256i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepu16_ph(a: __m512i) -> __m512h {
     unsafe { vcvtuw2ph_512(a.as_u16x32(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12167,7 +12167,7 @@ pub fn _mm512_cvtepu16_ph(a: __m512i) -> __m512h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepu16_ph(src: __m512h, k: __mmask32, a: __m512i) -> __m512h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepu16_ph(a), src) }
 }
@@ -12179,7 +12179,7 @@ pub fn _mm512_mask_cvtepu16_ph(src: __m512h, k: __mmask32, a: __m512i) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepu16_ph(k: __mmask32, a: __m512i) -> __m512h {
     _mm512_mask_cvtepu16_ph(_mm512_setzero_ph(), k, a)
 }
@@ -12200,7 +12200,7 @@ pub fn _mm512_maskz_cvtepu16_ph(k: __mmask32, a: __m512i) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepu16_ph<const ROUNDING: i32>(a: __m512i) -> __m512h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12225,7 +12225,7 @@ pub fn _mm512_cvt_roundepu16_ph<const ROUNDING: i32>(a: __m512i) -> __m512h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepu16_ph<const ROUNDING: i32>(
     src: __m512h,
     k: __mmask32,
@@ -12253,7 +12253,7 @@ pub fn _mm512_mask_cvt_roundepu16_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuw2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepu16_ph<const ROUNDING: i32>(k: __mmask32, a: __m512i) -> __m512h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepu16_ph::<ROUNDING>(_mm512_setzero_ph(), k, a)
@@ -12266,7 +12266,7 @@ pub fn _mm512_maskz_cvt_roundepu16_ph<const ROUNDING: i32>(k: __mmask32, a: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepi32_ph(a: __m128i) -> __m128h {
     _mm_mask_cvtepi32_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12279,7 +12279,7 @@ pub fn _mm_cvtepi32_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepi32_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { vcvtdq2ph_128(a.as_i32x4(), src, k) }
 }
@@ -12292,7 +12292,7 @@ pub fn _mm_mask_cvtepi32_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepi32_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepi32_ph(_mm_setzero_ph(), k, a)
 }
@@ -12304,7 +12304,7 @@ pub fn _mm_maskz_cvtepi32_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepi32_ph(a: __m256i) -> __m128h {
     unsafe { vcvtdq2ph_256(a.as_i32x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12317,7 +12317,7 @@ pub fn _mm256_cvtepi32_ph(a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepi32_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm256_cvtepi32_ph(a), src) }
 }
@@ -12329,7 +12329,7 @@ pub fn _mm256_mask_cvtepi32_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepi32_ph(k: __mmask8, a: __m256i) -> __m128h {
     _mm256_mask_cvtepi32_ph(_mm_setzero_ph(), k, a)
 }
@@ -12341,7 +12341,7 @@ pub fn _mm256_maskz_cvtepi32_ph(k: __mmask8, a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepi32_ph(a: __m512i) -> __m256h {
     unsafe { vcvtdq2ph_512(a.as_i32x16(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12354,7 +12354,7 @@ pub fn _mm512_cvtepi32_ph(a: __m512i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepi32_ph(src: __m256h, k: __mmask16, a: __m512i) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepi32_ph(a), src) }
 }
@@ -12366,7 +12366,7 @@ pub fn _mm512_mask_cvtepi32_ph(src: __m256h, k: __mmask16, a: __m512i) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepi32_ph(k: __mmask16, a: __m512i) -> __m256h {
     _mm512_mask_cvtepi32_ph(f16x16::ZERO.as_m256h(), k, a)
 }
@@ -12387,7 +12387,7 @@ pub fn _mm512_maskz_cvtepi32_ph(k: __mmask16, a: __m512i) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepi32_ph<const ROUNDING: i32>(a: __m512i) -> __m256h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12412,7 +12412,7 @@ pub fn _mm512_cvt_roundepi32_ph<const ROUNDING: i32>(a: __m512i) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepi32_ph<const ROUNDING: i32>(
     src: __m256h,
     k: __mmask16,
@@ -12440,7 +12440,7 @@ pub fn _mm512_mask_cvt_roundepi32_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtdq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepi32_ph<const ROUNDING: i32>(k: __mmask16, a: __m512i) -> __m256h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepi32_ph::<ROUNDING>(f16x16::ZERO.as_m256h(), k, a)
@@ -12454,7 +12454,7 @@ pub fn _mm512_maskz_cvt_roundepi32_ph<const ROUNDING: i32>(k: __mmask16, a: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsi2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvti32_sh(a: __m128h, b: i32) -> __m128h {
     unsafe { vcvtsi2sh(a, b, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12476,7 +12476,7 @@ pub fn _mm_cvti32_sh(a: __m128h, b: i32) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsi2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundi32_sh<const ROUNDING: i32>(a: __m128h, b: i32) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12491,7 +12491,7 @@ pub fn _mm_cvt_roundi32_sh<const ROUNDING: i32>(a: __m128h, b: i32) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepu32_ph(a: __m128i) -> __m128h {
     _mm_mask_cvtepu32_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12504,7 +12504,7 @@ pub fn _mm_cvtepu32_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepu32_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { vcvtudq2ph_128(a.as_u32x4(), src, k) }
 }
@@ -12517,7 +12517,7 @@ pub fn _mm_mask_cvtepu32_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepu32_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepu32_ph(_mm_setzero_ph(), k, a)
 }
@@ -12529,7 +12529,7 @@ pub fn _mm_maskz_cvtepu32_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepu32_ph(a: __m256i) -> __m128h {
     unsafe { vcvtudq2ph_256(a.as_u32x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12542,7 +12542,7 @@ pub fn _mm256_cvtepu32_ph(a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepu32_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm256_cvtepu32_ph(a), src) }
 }
@@ -12554,7 +12554,7 @@ pub fn _mm256_mask_cvtepu32_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepu32_ph(k: __mmask8, a: __m256i) -> __m128h {
     _mm256_mask_cvtepu32_ph(_mm_setzero_ph(), k, a)
 }
@@ -12566,7 +12566,7 @@ pub fn _mm256_maskz_cvtepu32_ph(k: __mmask8, a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepu32_ph(a: __m512i) -> __m256h {
     unsafe { vcvtudq2ph_512(a.as_u32x16(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12579,7 +12579,7 @@ pub fn _mm512_cvtepu32_ph(a: __m512i) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepu32_ph(src: __m256h, k: __mmask16, a: __m512i) -> __m256h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepu32_ph(a), src) }
 }
@@ -12591,7 +12591,7 @@ pub fn _mm512_mask_cvtepu32_ph(src: __m256h, k: __mmask16, a: __m512i) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepu32_ph(k: __mmask16, a: __m512i) -> __m256h {
     _mm512_mask_cvtepu32_ph(f16x16::ZERO.as_m256h(), k, a)
 }
@@ -12612,7 +12612,7 @@ pub fn _mm512_maskz_cvtepu32_ph(k: __mmask16, a: __m512i) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepu32_ph<const ROUNDING: i32>(a: __m512i) -> __m256h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12637,7 +12637,7 @@ pub fn _mm512_cvt_roundepu32_ph<const ROUNDING: i32>(a: __m512i) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepu32_ph<const ROUNDING: i32>(
     src: __m256h,
     k: __mmask16,
@@ -12665,7 +12665,7 @@ pub fn _mm512_mask_cvt_roundepu32_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtudq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepu32_ph<const ROUNDING: i32>(k: __mmask16, a: __m512i) -> __m256h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepu32_ph::<ROUNDING>(f16x16::ZERO.as_m256h(), k, a)
@@ -12679,7 +12679,7 @@ pub fn _mm512_maskz_cvt_roundepu32_ph<const ROUNDING: i32>(k: __mmask16, a: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtusi2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtu32_sh(a: __m128h, b: u32) -> __m128h {
     unsafe { vcvtusi2sh(a, b, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12701,7 +12701,7 @@ pub fn _mm_cvtu32_sh(a: __m128h, b: u32) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtusi2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundu32_sh<const ROUNDING: i32>(a: __m128h, b: u32) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12716,7 +12716,7 @@ pub fn _mm_cvt_roundu32_sh<const ROUNDING: i32>(a: __m128h, b: u32) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepi64_ph(a: __m128i) -> __m128h {
     _mm_mask_cvtepi64_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12729,7 +12729,7 @@ pub fn _mm_cvtepi64_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { vcvtqq2ph_128(a.as_i64x2(), src, k) }
 }
@@ -12742,7 +12742,7 @@ pub fn _mm_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepi64_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepi64_ph(_mm_setzero_ph(), k, a)
 }
@@ -12754,7 +12754,7 @@ pub fn _mm_maskz_cvtepi64_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepi64_ph(a: __m256i) -> __m128h {
     _mm256_mask_cvtepi64_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12767,7 +12767,7 @@ pub fn _mm256_cvtepi64_ph(a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h {
     unsafe { vcvtqq2ph_256(a.as_i64x4(), src, k) }
 }
@@ -12780,7 +12780,7 @@ pub fn _mm256_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepi64_ph(k: __mmask8, a: __m256i) -> __m128h {
     _mm256_mask_cvtepi64_ph(_mm_setzero_ph(), k, a)
 }
@@ -12792,7 +12792,7 @@ pub fn _mm256_maskz_cvtepi64_ph(k: __mmask8, a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepi64_ph(a: __m512i) -> __m128h {
     unsafe { vcvtqq2ph_512(a.as_i64x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12805,7 +12805,7 @@ pub fn _mm512_cvtepi64_ph(a: __m512i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m512i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepi64_ph(a), src) }
 }
@@ -12817,7 +12817,7 @@ pub fn _mm512_mask_cvtepi64_ph(src: __m128h, k: __mmask8, a: __m512i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepi64_ph(k: __mmask8, a: __m512i) -> __m128h {
     _mm512_mask_cvtepi64_ph(f16x8::ZERO.as_m128h(), k, a)
 }
@@ -12838,7 +12838,7 @@ pub fn _mm512_maskz_cvtepi64_ph(k: __mmask8, a: __m512i) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepi64_ph<const ROUNDING: i32>(a: __m512i) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -12863,7 +12863,7 @@ pub fn _mm512_cvt_roundepi64_ph<const ROUNDING: i32>(a: __m512i) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepi64_ph<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -12891,7 +12891,7 @@ pub fn _mm512_mask_cvt_roundepi64_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepi64_ph<const ROUNDING: i32>(k: __mmask8, a: __m512i) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepi64_ph::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a)
@@ -12904,7 +12904,7 @@ pub fn _mm512_maskz_cvt_roundepi64_ph<const ROUNDING: i32>(k: __mmask8, a: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtepu64_ph(a: __m128i) -> __m128h {
     _mm_mask_cvtepu64_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12917,7 +12917,7 @@ pub fn _mm_cvtepu64_ph(a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
     unsafe { vcvtuqq2ph_128(a.as_u64x2(), src, k) }
 }
@@ -12930,7 +12930,7 @@ pub fn _mm_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtepu64_ph(k: __mmask8, a: __m128i) -> __m128h {
     _mm_mask_cvtepu64_ph(_mm_setzero_ph(), k, a)
 }
@@ -12942,7 +12942,7 @@ pub fn _mm_maskz_cvtepu64_ph(k: __mmask8, a: __m128i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtepu64_ph(a: __m256i) -> __m128h {
     _mm256_mask_cvtepu64_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -12955,7 +12955,7 @@ pub fn _mm256_cvtepu64_ph(a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h {
     unsafe { vcvtuqq2ph_256(a.as_u64x4(), src, k) }
 }
@@ -12968,7 +12968,7 @@ pub fn _mm256_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m256i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtepu64_ph(k: __mmask8, a: __m256i) -> __m128h {
     _mm256_mask_cvtepu64_ph(_mm_setzero_ph(), k, a)
 }
@@ -12980,7 +12980,7 @@ pub fn _mm256_maskz_cvtepu64_ph(k: __mmask8, a: __m256i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtepu64_ph(a: __m512i) -> __m128h {
     unsafe { vcvtuqq2ph_512(a.as_u64x8(), _MM_FROUND_CUR_DIRECTION) }
 }
@@ -12993,7 +12993,7 @@ pub fn _mm512_cvtepu64_ph(a: __m512i) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m512i) -> __m128h {
     unsafe { simd_select_bitmask(k, _mm512_cvtepu64_ph(a), src) }
 }
@@ -13005,7 +13005,7 @@ pub fn _mm512_mask_cvtepu64_ph(src: __m128h, k: __mmask8, a: __m512i) -> __m128h
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtepu64_ph(k: __mmask8, a: __m512i) -> __m128h {
     _mm512_mask_cvtepu64_ph(f16x8::ZERO.as_m128h(), k, a)
 }
@@ -13026,7 +13026,7 @@ pub fn _mm512_maskz_cvtepu64_ph(k: __mmask8, a: __m512i) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundepu64_ph<const ROUNDING: i32>(a: __m512i) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -13051,7 +13051,7 @@ pub fn _mm512_cvt_roundepu64_ph<const ROUNDING: i32>(a: __m512i) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundepu64_ph<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -13079,7 +13079,7 @@ pub fn _mm512_mask_cvt_roundepu64_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtuqq2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundepu64_ph<const ROUNDING: i32>(k: __mmask8, a: __m512i) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundepu64_ph::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a)
@@ -13092,7 +13092,7 @@ pub fn _mm512_maskz_cvt_roundepu64_ph<const ROUNDING: i32>(k: __mmask8, a: __m51
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtxps_ph(a: __m128) -> __m128h {
     _mm_mask_cvtxps_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -13105,7 +13105,7 @@ pub fn _mm_cvtxps_ph(a: __m128) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtxps_ph(src: __m128h, k: __mmask8, a: __m128) -> __m128h {
     unsafe { vcvtps2phx_128(a, src, k) }
 }
@@ -13118,7 +13118,7 @@ pub fn _mm_mask_cvtxps_ph(src: __m128h, k: __mmask8, a: __m128) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtxps_ph(k: __mmask8, a: __m128) -> __m128h {
     _mm_mask_cvtxps_ph(_mm_setzero_ph(), k, a)
 }
@@ -13130,7 +13130,7 @@ pub fn _mm_maskz_cvtxps_ph(k: __mmask8, a: __m128) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtxps_ph(a: __m256) -> __m128h {
     _mm256_mask_cvtxps_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -13143,7 +13143,7 @@ pub fn _mm256_cvtxps_ph(a: __m256) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtxps_ph(src: __m128h, k: __mmask8, a: __m256) -> __m128h {
     unsafe { vcvtps2phx_256(a, src, k) }
 }
@@ -13156,7 +13156,7 @@ pub fn _mm256_mask_cvtxps_ph(src: __m128h, k: __mmask8, a: __m256) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtxps_ph(k: __mmask8, a: __m256) -> __m128h {
     _mm256_mask_cvtxps_ph(_mm_setzero_ph(), k, a)
 }
@@ -13168,7 +13168,7 @@ pub fn _mm256_maskz_cvtxps_ph(k: __mmask8, a: __m256) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtxps_ph(a: __m512) -> __m256h {
     _mm512_mask_cvtxps_ph(f16x16::ZERO.as_m256h(), 0xffff, a)
 }
@@ -13181,7 +13181,7 @@ pub fn _mm512_cvtxps_ph(a: __m512) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtxps_ph(src: __m256h, k: __mmask16, a: __m512) -> __m256h {
     unsafe { vcvtps2phx_512(a, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -13194,7 +13194,7 @@ pub fn _mm512_mask_cvtxps_ph(src: __m256h, k: __mmask16, a: __m512) -> __m256h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtxps_ph(k: __mmask16, a: __m512) -> __m256h {
     _mm512_mask_cvtxps_ph(f16x16::ZERO.as_m256h(), k, a)
 }
@@ -13215,7 +13215,7 @@ pub fn _mm512_maskz_cvtxps_ph(k: __mmask16, a: __m512) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtx_roundps_ph<const ROUNDING: i32>(a: __m512) -> __m256h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvtx_roundps_ph::<ROUNDING>(f16x16::ZERO.as_m256h(), 0xffff, a)
@@ -13238,7 +13238,7 @@ pub fn _mm512_cvtx_roundps_ph<const ROUNDING: i32>(a: __m512) -> __m256h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtx_roundps_ph<const ROUNDING: i32>(
     src: __m256h,
     k: __mmask16,
@@ -13267,7 +13267,7 @@ pub fn _mm512_mask_cvtx_roundps_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtps2phx, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtx_roundps_ph<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m256h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvtx_roundps_ph::<ROUNDING>(f16x16::ZERO.as_m256h(), k, a)
@@ -13281,7 +13281,7 @@ pub fn _mm512_maskz_cvtx_roundps_ph<const ROUNDING: i32>(k: __mmask16, a: __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtss_sh(a: __m128h, b: __m128) -> __m128h {
     _mm_mask_cvtss_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -13295,7 +13295,7 @@ pub fn _mm_cvtss_sh(a: __m128h, b: __m128) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtss_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128) -> __m128h {
     unsafe { vcvtss2sh(a, b, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -13309,7 +13309,7 @@ pub fn _mm_mask_cvtss_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128) -> __
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtss_sh(k: __mmask8, a: __m128h, b: __m128) -> __m128h {
     _mm_mask_cvtss_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -13331,7 +13331,7 @@ pub fn _mm_maskz_cvtss_sh(k: __mmask8, a: __m128h, b: __m128) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundss_sh<const ROUNDING: i32>(a: __m128h, b: __m128) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_cvt_roundss_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -13355,7 +13355,7 @@ pub fn _mm_cvt_roundss_sh<const ROUNDING: i32>(a: __m128h, b: __m128) -> __m128h
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvt_roundss_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -13386,7 +13386,7 @@ pub fn _mm_mask_cvt_roundss_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtss2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvt_roundss_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -13403,7 +13403,7 @@ pub fn _mm_maskz_cvt_roundss_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtpd_ph(a: __m128d) -> __m128h {
     _mm_mask_cvtpd_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -13416,7 +13416,7 @@ pub fn _mm_cvtpd_ph(a: __m128d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m128d) -> __m128h {
     unsafe { vcvtpd2ph_128(a, src, k) }
 }
@@ -13429,7 +13429,7 @@ pub fn _mm_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m128d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtpd_ph(k: __mmask8, a: __m128d) -> __m128h {
     _mm_mask_cvtpd_ph(_mm_setzero_ph(), k, a)
 }
@@ -13441,7 +13441,7 @@ pub fn _mm_maskz_cvtpd_ph(k: __mmask8, a: __m128d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtpd_ph(a: __m256d) -> __m128h {
     _mm256_mask_cvtpd_ph(_mm_setzero_ph(), 0xff, a)
 }
@@ -13454,7 +13454,7 @@ pub fn _mm256_cvtpd_ph(a: __m256d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m256d) -> __m128h {
     unsafe { vcvtpd2ph_256(a, src, k) }
 }
@@ -13467,7 +13467,7 @@ pub fn _mm256_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m256d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtpd_ph(k: __mmask8, a: __m256d) -> __m128h {
     _mm256_mask_cvtpd_ph(_mm_setzero_ph(), k, a)
 }
@@ -13479,7 +13479,7 @@ pub fn _mm256_maskz_cvtpd_ph(k: __mmask8, a: __m256d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtpd_ph(a: __m512d) -> __m128h {
     _mm512_mask_cvtpd_ph(f16x8::ZERO.as_m128h(), 0xff, a)
 }
@@ -13492,7 +13492,7 @@ pub fn _mm512_cvtpd_ph(a: __m512d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m512d) -> __m128h {
     unsafe { vcvtpd2ph_512(a, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -13505,7 +13505,7 @@ pub fn _mm512_mask_cvtpd_ph(src: __m128h, k: __mmask8, a: __m512d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtpd_ph(k: __mmask8, a: __m512d) -> __m128h {
     _mm512_mask_cvtpd_ph(f16x8::ZERO.as_m128h(), k, a)
 }
@@ -13526,7 +13526,7 @@ pub fn _mm512_maskz_cvtpd_ph(k: __mmask8, a: __m512d) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundpd_ph<const ROUNDING: i32>(a: __m512d) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundpd_ph::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a)
@@ -13549,7 +13549,7 @@ pub fn _mm512_cvt_roundpd_ph<const ROUNDING: i32>(a: __m512d) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundpd_ph<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -13578,7 +13578,7 @@ pub fn _mm512_mask_cvt_roundpd_ph<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtpd2ph, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundpd_ph<const ROUNDING: i32>(k: __mmask8, a: __m512d) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundpd_ph::<ROUNDING>(f16x8::ZERO.as_m128h(), k, a)
@@ -13592,7 +13592,7 @@ pub fn _mm512_maskz_cvt_roundpd_ph<const ROUNDING: i32>(k: __mmask8, a: __m512d)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsd_sh(a: __m128h, b: __m128d) -> __m128h {
     _mm_mask_cvtsd_sh(f16x8::ZERO.as_m128h(), 0xff, a, b)
 }
@@ -13606,7 +13606,7 @@ pub fn _mm_cvtsd_sh(a: __m128h, b: __m128d) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtsd_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128d) -> __m128h {
     unsafe { vcvtsd2sh(a, b, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -13620,7 +13620,7 @@ pub fn _mm_mask_cvtsd_sh(src: __m128h, k: __mmask8, a: __m128h, b: __m128d) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtsd_sh(k: __mmask8, a: __m128h, b: __m128d) -> __m128h {
     _mm_mask_cvtsd_sh(f16x8::ZERO.as_m128h(), k, a, b)
 }
@@ -13642,7 +13642,7 @@ pub fn _mm_maskz_cvtsd_sh(k: __mmask8, a: __m128h, b: __m128d) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsd_sh<const ROUNDING: i32>(a: __m128h, b: __m128d) -> __m128h {
     static_assert_rounding!(ROUNDING);
     _mm_mask_cvt_roundsd_sh::<ROUNDING>(f16x8::ZERO.as_m128h(), 0xff, a, b)
@@ -13666,7 +13666,7 @@ pub fn _mm_cvt_roundsd_sh<const ROUNDING: i32>(a: __m128h, b: __m128d) -> __m128
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvt_roundsd_sh<const ROUNDING: i32>(
     src: __m128h,
     k: __mmask8,
@@ -13697,7 +13697,7 @@ pub fn _mm_mask_cvt_roundsd_sh<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsd2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvt_roundsd_sh<const ROUNDING: i32>(
     k: __mmask8,
     a: __m128h,
@@ -13714,7 +13714,7 @@ pub fn _mm_maskz_cvt_roundsd_sh<const ROUNDING: i32>(
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epi16(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi16(_mm_undefined_si128(), 0xff, a)
 }
@@ -13727,7 +13727,7 @@ pub fn _mm_cvtph_epi16(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epi16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2w_128(a, src.as_i16x8(), k)) }
 }
@@ -13739,7 +13739,7 @@ pub fn _mm_mask_cvtph_epi16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epi16(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi16(_mm_setzero_si128(), k, a)
 }
@@ -13751,7 +13751,7 @@ pub fn _mm_maskz_cvtph_epi16(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epi16(a: __m256h) -> __m256i {
     _mm256_mask_cvtph_epi16(_mm256_undefined_si256(), 0xffff, a)
 }
@@ -13764,7 +13764,7 @@ pub fn _mm256_cvtph_epi16(a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epi16(src: __m256i, k: __mmask16, a: __m256h) -> __m256i {
     unsafe { transmute(vcvtph2w_256(a, src.as_i16x16(), k)) }
 }
@@ -13776,7 +13776,7 @@ pub fn _mm256_mask_cvtph_epi16(src: __m256i, k: __mmask16, a: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epi16(k: __mmask16, a: __m256h) -> __m256i {
     _mm256_mask_cvtph_epi16(_mm256_setzero_si256(), k, a)
 }
@@ -13788,7 +13788,7 @@ pub fn _mm256_maskz_cvtph_epi16(k: __mmask16, a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epi16(a: __m512h) -> __m512i {
     _mm512_mask_cvtph_epi16(_mm512_undefined_epi32(), 0xffffffff, a)
 }
@@ -13801,7 +13801,7 @@ pub fn _mm512_cvtph_epi16(a: __m512h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epi16(src: __m512i, k: __mmask32, a: __m512h) -> __m512i {
     unsafe {
         transmute(vcvtph2w_512(
@@ -13820,7 +13820,7 @@ pub fn _mm512_mask_cvtph_epi16(src: __m512i, k: __mmask32, a: __m512h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epi16(k: __mmask32, a: __m512h) -> __m512i {
     _mm512_mask_cvtph_epi16(_mm512_setzero_si512(), k, a)
 }
@@ -13841,7 +13841,7 @@ pub fn _mm512_maskz_cvtph_epi16(k: __mmask32, a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epi16<const ROUNDING: i32>(a: __m512h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi16::<ROUNDING>(_mm512_undefined_epi32(), 0xffffffff, a)
@@ -13864,7 +13864,7 @@ pub fn _mm512_cvt_roundph_epi16<const ROUNDING: i32>(a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epi16<const ROUNDING: i32>(
     src: __m512i,
     k: __mmask32,
@@ -13892,7 +13892,7 @@ pub fn _mm512_mask_cvt_roundph_epi16<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2w, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epi16<const ROUNDING: i32>(k: __mmask32, a: __m512h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi16::<ROUNDING>(_mm512_setzero_si512(), k, a)
@@ -13905,7 +13905,7 @@ pub fn _mm512_maskz_cvt_roundph_epi16<const ROUNDING: i32>(k: __mmask32, a: __m5
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epu16(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu16(_mm_undefined_si128(), 0xff, a)
 }
@@ -13918,7 +13918,7 @@ pub fn _mm_cvtph_epu16(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epu16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2uw_128(a, src.as_u16x8(), k)) }
 }
@@ -13930,7 +13930,7 @@ pub fn _mm_mask_cvtph_epu16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epu16(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu16(_mm_setzero_si128(), k, a)
 }
@@ -13942,7 +13942,7 @@ pub fn _mm_maskz_cvtph_epu16(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epu16(a: __m256h) -> __m256i {
     _mm256_mask_cvtph_epu16(_mm256_undefined_si256(), 0xffff, a)
 }
@@ -13955,7 +13955,7 @@ pub fn _mm256_cvtph_epu16(a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epu16(src: __m256i, k: __mmask16, a: __m256h) -> __m256i {
     unsafe { transmute(vcvtph2uw_256(a, src.as_u16x16(), k)) }
 }
@@ -13967,7 +13967,7 @@ pub fn _mm256_mask_cvtph_epu16(src: __m256i, k: __mmask16, a: __m256h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epu16(k: __mmask16, a: __m256h) -> __m256i {
     _mm256_mask_cvtph_epu16(_mm256_setzero_si256(), k, a)
 }
@@ -13979,7 +13979,7 @@ pub fn _mm256_maskz_cvtph_epu16(k: __mmask16, a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epu16(a: __m512h) -> __m512i {
     _mm512_mask_cvtph_epu16(_mm512_undefined_epi32(), 0xffffffff, a)
 }
@@ -13992,7 +13992,7 @@ pub fn _mm512_cvtph_epu16(a: __m512h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epu16(src: __m512i, k: __mmask32, a: __m512h) -> __m512i {
     unsafe {
         transmute(vcvtph2uw_512(
@@ -14011,7 +14011,7 @@ pub fn _mm512_mask_cvtph_epu16(src: __m512i, k: __mmask32, a: __m512h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epu16(k: __mmask32, a: __m512h) -> __m512i {
     _mm512_mask_cvtph_epu16(_mm512_setzero_si512(), k, a)
 }
@@ -14026,7 +14026,7 @@ pub fn _mm512_maskz_cvtph_epu16(k: __mmask32, a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epu16<const SAE: i32>(a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvt_roundph_epu16::<SAE>(_mm512_undefined_epi32(), 0xffffffff, a)
@@ -14043,7 +14043,7 @@ pub fn _mm512_cvt_roundph_epu16<const SAE: i32>(a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epu16<const SAE: i32>(
     src: __m512i,
     k: __mmask32,
@@ -14065,7 +14065,7 @@ pub fn _mm512_mask_cvt_roundph_epu16<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epu16<const SAE: i32>(k: __mmask32, a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvt_roundph_epu16::<SAE>(_mm512_setzero_si512(), k, a)
@@ -14078,7 +14078,7 @@ pub fn _mm512_maskz_cvt_roundph_epu16<const SAE: i32>(k: __mmask32, a: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epi16(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi16(_mm_undefined_si128(), 0xff, a)
 }
@@ -14091,7 +14091,7 @@ pub fn _mm_cvttph_epi16(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epi16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2w_128(a, src.as_i16x8(), k)) }
 }
@@ -14104,7 +14104,7 @@ pub fn _mm_mask_cvttph_epi16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epi16(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi16(_mm_setzero_si128(), k, a)
 }
@@ -14116,7 +14116,7 @@ pub fn _mm_maskz_cvttph_epi16(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epi16(a: __m256h) -> __m256i {
     _mm256_mask_cvttph_epi16(_mm256_undefined_si256(), 0xffff, a)
 }
@@ -14129,7 +14129,7 @@ pub fn _mm256_cvttph_epi16(a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epi16(src: __m256i, k: __mmask16, a: __m256h) -> __m256i {
     unsafe { transmute(vcvttph2w_256(a, src.as_i16x16(), k)) }
 }
@@ -14142,7 +14142,7 @@ pub fn _mm256_mask_cvttph_epi16(src: __m256i, k: __mmask16, a: __m256h) -> __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epi16(k: __mmask16, a: __m256h) -> __m256i {
     _mm256_mask_cvttph_epi16(_mm256_setzero_si256(), k, a)
 }
@@ -14154,7 +14154,7 @@ pub fn _mm256_maskz_cvttph_epi16(k: __mmask16, a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epi16(a: __m512h) -> __m512i {
     _mm512_mask_cvttph_epi16(_mm512_undefined_epi32(), 0xffffffff, a)
 }
@@ -14167,7 +14167,7 @@ pub fn _mm512_cvttph_epi16(a: __m512h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epi16(src: __m512i, k: __mmask32, a: __m512h) -> __m512i {
     unsafe {
         transmute(vcvttph2w_512(
@@ -14187,7 +14187,7 @@ pub fn _mm512_mask_cvttph_epi16(src: __m512i, k: __mmask32, a: __m512h) -> __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epi16(k: __mmask32, a: __m512h) -> __m512i {
     _mm512_mask_cvttph_epi16(_mm512_setzero_si512(), k, a)
 }
@@ -14202,7 +14202,7 @@ pub fn _mm512_maskz_cvttph_epi16(k: __mmask32, a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epi16<const SAE: i32>(a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi16::<SAE>(_mm512_undefined_epi32(), 0xffffffff, a)
@@ -14219,7 +14219,7 @@ pub fn _mm512_cvtt_roundph_epi16<const SAE: i32>(a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epi16<const SAE: i32>(
     src: __m512i,
     k: __mmask32,
@@ -14242,7 +14242,7 @@ pub fn _mm512_mask_cvtt_roundph_epi16<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2w, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epi16<const SAE: i32>(k: __mmask32, a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi16::<SAE>(_mm512_setzero_si512(), k, a)
@@ -14255,7 +14255,7 @@ pub fn _mm512_maskz_cvtt_roundph_epi16<const SAE: i32>(k: __mmask32, a: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epu16(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu16(_mm_undefined_si128(), 0xff, a)
 }
@@ -14268,7 +14268,7 @@ pub fn _mm_cvttph_epu16(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epu16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2uw_128(a, src.as_u16x8(), k)) }
 }
@@ -14281,7 +14281,7 @@ pub fn _mm_mask_cvttph_epu16(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epu16(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu16(_mm_setzero_si128(), k, a)
 }
@@ -14293,7 +14293,7 @@ pub fn _mm_maskz_cvttph_epu16(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epu16(a: __m256h) -> __m256i {
     _mm256_mask_cvttph_epu16(_mm256_undefined_si256(), 0xffff, a)
 }
@@ -14306,7 +14306,7 @@ pub fn _mm256_cvttph_epu16(a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epu16(src: __m256i, k: __mmask16, a: __m256h) -> __m256i {
     unsafe { transmute(vcvttph2uw_256(a, src.as_u16x16(), k)) }
 }
@@ -14319,7 +14319,7 @@ pub fn _mm256_mask_cvttph_epu16(src: __m256i, k: __mmask16, a: __m256h) -> __m25
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epu16(k: __mmask16, a: __m256h) -> __m256i {
     _mm256_mask_cvttph_epu16(_mm256_setzero_si256(), k, a)
 }
@@ -14331,7 +14331,7 @@ pub fn _mm256_maskz_cvttph_epu16(k: __mmask16, a: __m256h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epu16(a: __m512h) -> __m512i {
     _mm512_mask_cvttph_epu16(_mm512_undefined_epi32(), 0xffffffff, a)
 }
@@ -14344,7 +14344,7 @@ pub fn _mm512_cvttph_epu16(a: __m512h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epu16(src: __m512i, k: __mmask32, a: __m512h) -> __m512i {
     unsafe {
         transmute(vcvttph2uw_512(
@@ -14364,7 +14364,7 @@ pub fn _mm512_mask_cvttph_epu16(src: __m512i, k: __mmask32, a: __m512h) -> __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epu16(k: __mmask32, a: __m512h) -> __m512i {
     _mm512_mask_cvttph_epu16(_mm512_setzero_si512(), k, a)
 }
@@ -14379,7 +14379,7 @@ pub fn _mm512_maskz_cvttph_epu16(k: __mmask32, a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epu16<const SAE: i32>(a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu16::<SAE>(_mm512_undefined_epi32(), 0xffffffff, a)
@@ -14396,7 +14396,7 @@ pub fn _mm512_cvtt_roundph_epu16<const SAE: i32>(a: __m512h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epu16<const SAE: i32>(
     src: __m512i,
     k: __mmask32,
@@ -14419,7 +14419,7 @@ pub fn _mm512_mask_cvtt_roundph_epu16<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uw, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epu16<const SAE: i32>(k: __mmask32, a: __m512h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu16::<SAE>(_mm512_setzero_si512(), k, a)
@@ -14432,7 +14432,7 @@ pub fn _mm512_maskz_cvtt_roundph_epu16<const SAE: i32>(k: __mmask32, a: __m512h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epi32(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi32(_mm_undefined_si128(), 0xff, a)
 }
@@ -14444,7 +14444,7 @@ pub fn _mm_cvtph_epi32(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epi32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2dq_128(a, src.as_i32x4(), k)) }
 }
@@ -14456,7 +14456,7 @@ pub fn _mm_mask_cvtph_epi32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epi32(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi32(_mm_setzero_si128(), k, a)
 }
@@ -14468,7 +14468,7 @@ pub fn _mm_maskz_cvtph_epi32(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epi32(a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epi32(_mm256_undefined_si256(), 0xff, a)
 }
@@ -14480,7 +14480,7 @@ pub fn _mm256_cvtph_epi32(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epi32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvtph2dq_256(a, src.as_i32x8(), k)) }
 }
@@ -14492,7 +14492,7 @@ pub fn _mm256_mask_cvtph_epi32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epi32(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epi32(_mm256_setzero_si256(), k, a)
 }
@@ -14504,7 +14504,7 @@ pub fn _mm256_maskz_cvtph_epi32(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epi32(a: __m256h) -> __m512i {
     _mm512_mask_cvtph_epi32(_mm512_undefined_epi32(), 0xffff, a)
 }
@@ -14516,7 +14516,7 @@ pub fn _mm512_cvtph_epi32(a: __m256h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epi32(src: __m512i, k: __mmask16, a: __m256h) -> __m512i {
     unsafe {
         transmute(vcvtph2dq_512(
@@ -14535,7 +14535,7 @@ pub fn _mm512_mask_cvtph_epi32(src: __m512i, k: __mmask16, a: __m256h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epi32(k: __mmask16, a: __m256h) -> __m512i {
     _mm512_mask_cvtph_epi32(_mm512_setzero_si512(), k, a)
 }
@@ -14556,7 +14556,7 @@ pub fn _mm512_maskz_cvtph_epi32(k: __mmask16, a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epi32<const ROUNDING: i32>(a: __m256h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi32::<ROUNDING>(_mm512_undefined_epi32(), 0xffff, a)
@@ -14578,7 +14578,7 @@ pub fn _mm512_cvt_roundph_epi32<const ROUNDING: i32>(a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epi32<const ROUNDING: i32>(
     src: __m512i,
     k: __mmask16,
@@ -14606,7 +14606,7 @@ pub fn _mm512_mask_cvt_roundph_epi32<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2dq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epi32<const ROUNDING: i32>(k: __mmask16, a: __m256h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi32::<ROUNDING>(_mm512_setzero_si512(), k, a)
@@ -14619,7 +14619,7 @@ pub fn _mm512_maskz_cvt_roundph_epi32<const ROUNDING: i32>(k: __mmask16, a: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2si))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_i32(a: __m128h) -> i32 {
     unsafe { vcvtsh2si32(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -14640,7 +14640,7 @@ pub fn _mm_cvtsh_i32(a: __m128h) -> i32 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2si, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_i32<const ROUNDING: i32>(a: __m128h) -> i32 {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -14655,7 +14655,7 @@ pub fn _mm_cvt_roundsh_i32<const ROUNDING: i32>(a: __m128h) -> i32 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epu32(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu32(_mm_undefined_si128(), 0xff, a)
 }
@@ -14667,7 +14667,7 @@ pub fn _mm_cvtph_epu32(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epu32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2udq_128(a, src.as_u32x4(), k)) }
 }
@@ -14679,7 +14679,7 @@ pub fn _mm_mask_cvtph_epu32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epu32(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu32(_mm_setzero_si128(), k, a)
 }
@@ -14691,7 +14691,7 @@ pub fn _mm_maskz_cvtph_epu32(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epu32(a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epu32(_mm256_undefined_si256(), 0xff, a)
 }
@@ -14703,7 +14703,7 @@ pub fn _mm256_cvtph_epu32(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epu32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvtph2udq_256(a, src.as_u32x8(), k)) }
 }
@@ -14715,7 +14715,7 @@ pub fn _mm256_mask_cvtph_epu32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epu32(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epu32(_mm256_setzero_si256(), k, a)
 }
@@ -14727,7 +14727,7 @@ pub fn _mm256_maskz_cvtph_epu32(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epu32(a: __m256h) -> __m512i {
     _mm512_mask_cvtph_epu32(_mm512_undefined_epi32(), 0xffff, a)
 }
@@ -14739,7 +14739,7 @@ pub fn _mm512_cvtph_epu32(a: __m256h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epu32(src: __m512i, k: __mmask16, a: __m256h) -> __m512i {
     unsafe {
         transmute(vcvtph2udq_512(
@@ -14758,7 +14758,7 @@ pub fn _mm512_mask_cvtph_epu32(src: __m512i, k: __mmask16, a: __m256h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epu32(k: __mmask16, a: __m256h) -> __m512i {
     _mm512_mask_cvtph_epu32(_mm512_setzero_si512(), k, a)
 }
@@ -14779,7 +14779,7 @@ pub fn _mm512_maskz_cvtph_epu32(k: __mmask16, a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epu32<const ROUNDING: i32>(a: __m256h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epu32::<ROUNDING>(_mm512_undefined_epi32(), 0xffff, a)
@@ -14801,7 +14801,7 @@ pub fn _mm512_cvt_roundph_epu32<const ROUNDING: i32>(a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epu32<const ROUNDING: i32>(
     src: __m512i,
     k: __mmask16,
@@ -14829,7 +14829,7 @@ pub fn _mm512_mask_cvt_roundph_epu32<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2udq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epu32<const ROUNDING: i32>(k: __mmask16, a: __m256h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epu32::<ROUNDING>(_mm512_setzero_si512(), k, a)
@@ -14842,7 +14842,7 @@ pub fn _mm512_maskz_cvt_roundph_epu32<const ROUNDING: i32>(k: __mmask16, a: __m2
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2usi))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_u32(a: __m128h) -> u32 {
     unsafe { vcvtsh2usi32(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -14857,7 +14857,7 @@ pub fn _mm_cvtsh_u32(a: __m128h) -> u32 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2usi, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_u32<const SAE: i32>(a: __m128h) -> u32 {
     unsafe {
         static_assert_rounding!(SAE);
@@ -14872,7 +14872,7 @@ pub fn _mm_cvt_roundsh_u32<const SAE: i32>(a: __m128h) -> u32 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epi32(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi32(_mm_undefined_si128(), 0xff, a)
 }
@@ -14884,7 +14884,7 @@ pub fn _mm_cvttph_epi32(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epi32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2dq_128(a, src.as_i32x4(), k)) }
 }
@@ -14896,7 +14896,7 @@ pub fn _mm_mask_cvttph_epi32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epi32(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi32(_mm_setzero_si128(), k, a)
 }
@@ -14908,7 +14908,7 @@ pub fn _mm_maskz_cvttph_epi32(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epi32(a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epi32(_mm256_undefined_si256(), 0xff, a)
 }
@@ -14920,7 +14920,7 @@ pub fn _mm256_cvttph_epi32(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epi32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvttph2dq_256(a, src.as_i32x8(), k)) }
 }
@@ -14932,7 +14932,7 @@ pub fn _mm256_mask_cvttph_epi32(src: __m256i, k: __mmask8, a: __m128h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epi32(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epi32(_mm256_setzero_si256(), k, a)
 }
@@ -14944,7 +14944,7 @@ pub fn _mm256_maskz_cvttph_epi32(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epi32(a: __m256h) -> __m512i {
     _mm512_mask_cvttph_epi32(_mm512_undefined_epi32(), 0xffff, a)
 }
@@ -14956,7 +14956,7 @@ pub fn _mm512_cvttph_epi32(a: __m256h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epi32(src: __m512i, k: __mmask16, a: __m256h) -> __m512i {
     unsafe {
         transmute(vcvttph2dq_512(
@@ -14975,7 +14975,7 @@ pub fn _mm512_mask_cvttph_epi32(src: __m512i, k: __mmask16, a: __m256h) -> __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epi32(k: __mmask16, a: __m256h) -> __m512i {
     _mm512_mask_cvttph_epi32(_mm512_setzero_si512(), k, a)
 }
@@ -14990,7 +14990,7 @@ pub fn _mm512_maskz_cvttph_epi32(k: __mmask16, a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epi32<const SAE: i32>(a: __m256h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi32::<SAE>(_mm512_undefined_epi32(), 0xffff, a)
@@ -15006,7 +15006,7 @@ pub fn _mm512_cvtt_roundph_epi32<const SAE: i32>(a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epi32<const SAE: i32>(
     src: __m512i,
     k: __mmask16,
@@ -15028,7 +15028,7 @@ pub fn _mm512_mask_cvtt_roundph_epi32<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2dq, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epi32<const SAE: i32>(k: __mmask16, a: __m256h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi32::<SAE>(_mm512_setzero_si512(), k, a)
@@ -15041,7 +15041,7 @@ pub fn _mm512_maskz_cvtt_roundph_epi32<const SAE: i32>(k: __mmask16, a: __m256h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2si))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttsh_i32(a: __m128h) -> i32 {
     unsafe { vcvttsh2si32(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -15056,7 +15056,7 @@ pub fn _mm_cvttsh_i32(a: __m128h) -> i32 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2si, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtt_roundsh_i32<const SAE: i32>(a: __m128h) -> i32 {
     unsafe {
         static_assert_sae!(SAE);
@@ -15071,7 +15071,7 @@ pub fn _mm_cvtt_roundsh_i32<const SAE: i32>(a: __m128h) -> i32 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epu32(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu32(_mm_undefined_si128(), 0xff, a)
 }
@@ -15083,7 +15083,7 @@ pub fn _mm_cvttph_epu32(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epu32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2udq_128(a, src.as_u32x4(), k)) }
 }
@@ -15095,7 +15095,7 @@ pub fn _mm_mask_cvttph_epu32(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epu32(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu32(_mm_setzero_si128(), k, a)
 }
@@ -15107,7 +15107,7 @@ pub fn _mm_maskz_cvttph_epu32(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epu32(a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epu32(_mm256_undefined_si256(), 0xff, a)
 }
@@ -15119,7 +15119,7 @@ pub fn _mm256_cvttph_epu32(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epu32(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvttph2udq_256(a, src.as_u32x8(), k)) }
 }
@@ -15131,7 +15131,7 @@ pub fn _mm256_mask_cvttph_epu32(src: __m256i, k: __mmask8, a: __m128h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epu32(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epu32(_mm256_setzero_si256(), k, a)
 }
@@ -15143,7 +15143,7 @@ pub fn _mm256_maskz_cvttph_epu32(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epu32(a: __m256h) -> __m512i {
     _mm512_mask_cvttph_epu32(_mm512_undefined_epi32(), 0xffff, a)
 }
@@ -15155,7 +15155,7 @@ pub fn _mm512_cvttph_epu32(a: __m256h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epu32(src: __m512i, k: __mmask16, a: __m256h) -> __m512i {
     unsafe {
         transmute(vcvttph2udq_512(
@@ -15174,7 +15174,7 @@ pub fn _mm512_mask_cvttph_epu32(src: __m512i, k: __mmask16, a: __m256h) -> __m51
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epu32(k: __mmask16, a: __m256h) -> __m512i {
     _mm512_mask_cvttph_epu32(_mm512_setzero_si512(), k, a)
 }
@@ -15189,7 +15189,7 @@ pub fn _mm512_maskz_cvttph_epu32(k: __mmask16, a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epu32<const SAE: i32>(a: __m256h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu32::<SAE>(_mm512_undefined_epi32(), 0xffff, a)
@@ -15205,7 +15205,7 @@ pub fn _mm512_cvtt_roundph_epu32<const SAE: i32>(a: __m256h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epu32<const SAE: i32>(
     src: __m512i,
     k: __mmask16,
@@ -15227,7 +15227,7 @@ pub fn _mm512_mask_cvtt_roundph_epu32<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2udq, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epu32<const SAE: i32>(k: __mmask16, a: __m256h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu32::<SAE>(_mm512_setzero_si512(), k, a)
@@ -15240,7 +15240,7 @@ pub fn _mm512_maskz_cvtt_roundph_epu32<const SAE: i32>(k: __mmask16, a: __m256h)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2usi))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttsh_u32(a: __m128h) -> u32 {
     unsafe { vcvttsh2usi32(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -15255,7 +15255,7 @@ pub fn _mm_cvttsh_u32(a: __m128h) -> u32 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2usi, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtt_roundsh_u32<const SAE: i32>(a: __m128h) -> u32 {
     unsafe {
         static_assert_sae!(SAE);
@@ -15270,7 +15270,7 @@ pub fn _mm_cvtt_roundsh_u32<const SAE: i32>(a: __m128h) -> u32 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epi64(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi64(_mm_undefined_si128(), 0xff, a)
 }
@@ -15282,7 +15282,7 @@ pub fn _mm_cvtph_epi64(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epi64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2qq_128(a, src.as_i64x2(), k)) }
 }
@@ -15294,7 +15294,7 @@ pub fn _mm_mask_cvtph_epi64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epi64(_mm_setzero_si128(), k, a)
 }
@@ -15306,7 +15306,7 @@ pub fn _mm_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epi64(a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epi64(_mm256_undefined_si256(), 0xff, a)
 }
@@ -15318,7 +15318,7 @@ pub fn _mm256_cvtph_epi64(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epi64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvtph2qq_256(a, src.as_i64x4(), k)) }
 }
@@ -15330,7 +15330,7 @@ pub fn _mm256_mask_cvtph_epi64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epi64(_mm256_setzero_si256(), k, a)
 }
@@ -15342,7 +15342,7 @@ pub fn _mm256_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epi64(a: __m128h) -> __m512i {
     _mm512_mask_cvtph_epi64(_mm512_undefined_epi32(), 0xff, a)
 }
@@ -15354,7 +15354,7 @@ pub fn _mm512_cvtph_epi64(a: __m128h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epi64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i {
     unsafe {
         transmute(vcvtph2qq_512(
@@ -15373,7 +15373,7 @@ pub fn _mm512_mask_cvtph_epi64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m512i {
     _mm512_mask_cvtph_epi64(_mm512_setzero_si512(), k, a)
 }
@@ -15394,7 +15394,7 @@ pub fn _mm512_maskz_cvtph_epi64(k: __mmask8, a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epi64<const ROUNDING: i32>(a: __m128h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi64::<ROUNDING>(_mm512_undefined_epi32(), 0xff, a)
@@ -15416,7 +15416,7 @@ pub fn _mm512_cvt_roundph_epi64<const ROUNDING: i32>(a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epi64<const ROUNDING: i32>(
     src: __m512i,
     k: __mmask8,
@@ -15444,7 +15444,7 @@ pub fn _mm512_mask_cvt_roundph_epi64<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2qq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epi64<const ROUNDING: i32>(k: __mmask8, a: __m128h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epi64::<ROUNDING>(_mm512_setzero_si512(), k, a)
@@ -15457,7 +15457,7 @@ pub fn _mm512_maskz_cvt_roundph_epi64<const ROUNDING: i32>(k: __mmask8, a: __m12
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_epu64(a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu64(_mm_undefined_si128(), 0xff, a)
 }
@@ -15469,7 +15469,7 @@ pub fn _mm_cvtph_epu64(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_epu64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvtph2uqq_128(a, src.as_u64x2(), k)) }
 }
@@ -15481,7 +15481,7 @@ pub fn _mm_mask_cvtph_epu64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvtph_epu64(_mm_setzero_si128(), k, a)
 }
@@ -15493,7 +15493,7 @@ pub fn _mm_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_epu64(a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epu64(_mm256_undefined_si256(), 0xff, a)
 }
@@ -15505,7 +15505,7 @@ pub fn _mm256_cvtph_epu64(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_epu64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvtph2uqq_256(a, src.as_u64x4(), k)) }
 }
@@ -15517,7 +15517,7 @@ pub fn _mm256_mask_cvtph_epu64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvtph_epu64(_mm256_setzero_si256(), k, a)
 }
@@ -15529,7 +15529,7 @@ pub fn _mm256_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_epu64(a: __m128h) -> __m512i {
     _mm512_mask_cvtph_epu64(_mm512_undefined_epi32(), 0xff, a)
 }
@@ -15541,7 +15541,7 @@ pub fn _mm512_cvtph_epu64(a: __m128h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_epu64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i {
     unsafe {
         transmute(vcvtph2uqq_512(
@@ -15560,7 +15560,7 @@ pub fn _mm512_mask_cvtph_epu64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m512i {
     _mm512_mask_cvtph_epu64(_mm512_setzero_si512(), k, a)
 }
@@ -15581,7 +15581,7 @@ pub fn _mm512_maskz_cvtph_epu64(k: __mmask8, a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_epu64<const ROUNDING: i32>(a: __m128h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epu64::<ROUNDING>(_mm512_undefined_epi32(), 0xff, a)
@@ -15603,7 +15603,7 @@ pub fn _mm512_cvt_roundph_epu64<const ROUNDING: i32>(a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_epu64<const ROUNDING: i32>(
     src: __m512i,
     k: __mmask8,
@@ -15631,7 +15631,7 @@ pub fn _mm512_mask_cvt_roundph_epu64<const ROUNDING: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2uqq, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_epu64<const ROUNDING: i32>(k: __mmask8, a: __m128h) -> __m512i {
     static_assert_rounding!(ROUNDING);
     _mm512_mask_cvt_roundph_epu64::<ROUNDING>(_mm512_setzero_si512(), k, a)
@@ -15644,7 +15644,7 @@ pub fn _mm512_maskz_cvt_roundph_epu64<const ROUNDING: i32>(k: __mmask8, a: __m12
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epi64(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi64(_mm_undefined_si128(), 0xff, a)
 }
@@ -15656,7 +15656,7 @@ pub fn _mm_cvttph_epi64(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epi64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2qq_128(a, src.as_i64x2(), k)) }
 }
@@ -15668,7 +15668,7 @@ pub fn _mm_mask_cvttph_epi64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epi64(_mm_setzero_si128(), k, a)
 }
@@ -15680,7 +15680,7 @@ pub fn _mm_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epi64(a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epi64(_mm256_undefined_si256(), 0xff, a)
 }
@@ -15692,7 +15692,7 @@ pub fn _mm256_cvttph_epi64(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epi64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvttph2qq_256(a, src.as_i64x4(), k)) }
 }
@@ -15704,7 +15704,7 @@ pub fn _mm256_mask_cvttph_epi64(src: __m256i, k: __mmask8, a: __m128h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epi64(_mm256_setzero_si256(), k, a)
 }
@@ -15716,7 +15716,7 @@ pub fn _mm256_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epi64(a: __m128h) -> __m512i {
     _mm512_mask_cvttph_epi64(_mm512_undefined_epi32(), 0xff, a)
 }
@@ -15728,7 +15728,7 @@ pub fn _mm512_cvttph_epi64(a: __m128h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epi64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i {
     unsafe {
         transmute(vcvttph2qq_512(
@@ -15747,7 +15747,7 @@ pub fn _mm512_mask_cvttph_epi64(src: __m512i, k: __mmask8, a: __m128h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m512i {
     _mm512_mask_cvttph_epi64(_mm512_setzero_si512(), k, a)
 }
@@ -15762,7 +15762,7 @@ pub fn _mm512_maskz_cvttph_epi64(k: __mmask8, a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epi64<const SAE: i32>(a: __m128h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi64::<SAE>(_mm512_undefined_epi32(), 0xff, a)
@@ -15778,7 +15778,7 @@ pub fn _mm512_cvtt_roundph_epi64<const SAE: i32>(a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epi64<const SAE: i32>(
     src: __m512i,
     k: __mmask8,
@@ -15800,7 +15800,7 @@ pub fn _mm512_mask_cvtt_roundph_epi64<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2qq, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epi64<const SAE: i32>(k: __mmask8, a: __m128h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epi64::<SAE>(_mm512_setzero_si512(), k, a)
@@ -15813,7 +15813,7 @@ pub fn _mm512_maskz_cvtt_roundph_epi64<const SAE: i32>(k: __mmask8, a: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttph_epu64(a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu64(_mm_undefined_si128(), 0xff, a)
 }
@@ -15825,7 +15825,7 @@ pub fn _mm_cvttph_epu64(a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvttph_epu64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
     unsafe { transmute(vcvttph2uqq_128(a, src.as_u64x2(), k)) }
 }
@@ -15837,7 +15837,7 @@ pub fn _mm_mask_cvttph_epu64(src: __m128i, k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m128i {
     _mm_mask_cvttph_epu64(_mm_setzero_si128(), k, a)
 }
@@ -15849,7 +15849,7 @@ pub fn _mm_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m128i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvttph_epu64(a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epu64(_mm256_undefined_si256(), 0xff, a)
 }
@@ -15861,7 +15861,7 @@ pub fn _mm256_cvttph_epu64(a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvttph_epu64(src: __m256i, k: __mmask8, a: __m128h) -> __m256i {
     unsafe { transmute(vcvttph2uqq_256(a, src.as_u64x4(), k)) }
 }
@@ -15873,7 +15873,7 @@ pub fn _mm256_mask_cvttph_epu64(src: __m256i, k: __mmask8, a: __m128h) -> __m256
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m256i {
     _mm256_mask_cvttph_epu64(_mm256_setzero_si256(), k, a)
 }
@@ -15885,7 +15885,7 @@ pub fn _mm256_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m256i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvttph_epu64(a: __m128h) -> __m512i {
     _mm512_mask_cvttph_epu64(_mm512_undefined_epi32(), 0xff, a)
 }
@@ -15897,7 +15897,7 @@ pub fn _mm512_cvttph_epu64(a: __m128h) -> __m512i {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvttph_epu64(src: __m512i, k: __mmask8, a: __m128h) -> __m512i {
     unsafe {
         transmute(vcvttph2uqq_512(
@@ -15916,7 +15916,7 @@ pub fn _mm512_mask_cvttph_epu64(src: __m512i, k: __mmask8, a: __m128h) -> __m512
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m512i {
     _mm512_mask_cvttph_epu64(_mm512_setzero_si512(), k, a)
 }
@@ -15931,7 +15931,7 @@ pub fn _mm512_maskz_cvttph_epu64(k: __mmask8, a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtt_roundph_epu64<const SAE: i32>(a: __m128h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu64::<SAE>(_mm512_undefined_epi32(), 0xff, a)
@@ -15947,7 +15947,7 @@ pub fn _mm512_cvtt_roundph_epu64<const SAE: i32>(a: __m128h) -> __m512i {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtt_roundph_epu64<const SAE: i32>(
     src: __m512i,
     k: __mmask8,
@@ -15969,7 +15969,7 @@ pub fn _mm512_mask_cvtt_roundph_epu64<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttph2uqq, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtt_roundph_epu64<const SAE: i32>(k: __mmask8, a: __m128h) -> __m512i {
     static_assert_sae!(SAE);
     _mm512_mask_cvtt_roundph_epu64::<SAE>(_mm512_setzero_si512(), k, a)
@@ -15982,7 +15982,7 @@ pub fn _mm512_maskz_cvtt_roundph_epu64<const SAE: i32>(k: __mmask8, a: __m128h)
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtxph_ps(a: __m128h) -> __m128 {
     _mm_mask_cvtxph_ps(_mm_setzero_ps(), 0xff, a)
 }
@@ -15995,7 +15995,7 @@ pub fn _mm_cvtxph_ps(a: __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtxph_ps(src: __m128, k: __mmask8, a: __m128h) -> __m128 {
     unsafe { vcvtph2psx_128(a, src, k) }
 }
@@ -16008,7 +16008,7 @@ pub fn _mm_mask_cvtxph_ps(src: __m128, k: __mmask8, a: __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtxph_ps(k: __mmask8, a: __m128h) -> __m128 {
     _mm_mask_cvtxph_ps(_mm_setzero_ps(), k, a)
 }
@@ -16020,7 +16020,7 @@ pub fn _mm_maskz_cvtxph_ps(k: __mmask8, a: __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtxph_ps(a: __m128h) -> __m256 {
     _mm256_mask_cvtxph_ps(_mm256_setzero_ps(), 0xff, a)
 }
@@ -16033,7 +16033,7 @@ pub fn _mm256_cvtxph_ps(a: __m128h) -> __m256 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtxph_ps(src: __m256, k: __mmask8, a: __m128h) -> __m256 {
     unsafe { vcvtph2psx_256(a, src, k) }
 }
@@ -16046,7 +16046,7 @@ pub fn _mm256_mask_cvtxph_ps(src: __m256, k: __mmask8, a: __m128h) -> __m256 {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtxph_ps(k: __mmask8, a: __m128h) -> __m256 {
     _mm256_mask_cvtxph_ps(_mm256_setzero_ps(), k, a)
 }
@@ -16058,7 +16058,7 @@ pub fn _mm256_maskz_cvtxph_ps(k: __mmask8, a: __m128h) -> __m256 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtxph_ps(a: __m256h) -> __m512 {
     _mm512_mask_cvtxph_ps(_mm512_setzero_ps(), 0xffff, a)
 }
@@ -16071,7 +16071,7 @@ pub fn _mm512_cvtxph_ps(a: __m256h) -> __m512 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtxph_ps(src: __m512, k: __mmask16, a: __m256h) -> __m512 {
     unsafe { vcvtph2psx_512(a, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -16084,7 +16084,7 @@ pub fn _mm512_mask_cvtxph_ps(src: __m512, k: __mmask16, a: __m256h) -> __m512 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtxph_ps(k: __mmask16, a: __m256h) -> __m512 {
     _mm512_mask_cvtxph_ps(_mm512_setzero_ps(), k, a)
 }
@@ -16099,7 +16099,7 @@ pub fn _mm512_maskz_cvtxph_ps(k: __mmask16, a: __m256h) -> __m512 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtx_roundph_ps<const SAE: i32>(a: __m256h) -> __m512 {
     static_assert_sae!(SAE);
     _mm512_mask_cvtx_roundph_ps::<SAE>(_mm512_setzero_ps(), 0xffff, a)
@@ -16116,7 +16116,7 @@ pub fn _mm512_cvtx_roundph_ps<const SAE: i32>(a: __m256h) -> __m512 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtx_roundph_ps<const SAE: i32>(
     src: __m512,
     k: __mmask16,
@@ -16139,7 +16139,7 @@ pub fn _mm512_mask_cvtx_roundph_ps<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2psx, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtx_roundph_ps<const SAE: i32>(k: __mmask16, a: __m256h) -> __m512 {
     static_assert_sae!(SAE);
     _mm512_mask_cvtx_roundph_ps::<SAE>(_mm512_setzero_ps(), k, a)
@@ -16153,7 +16153,7 @@ pub fn _mm512_maskz_cvtx_roundph_ps<const SAE: i32>(k: __mmask16, a: __m256h) ->
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_ss(a: __m128, b: __m128h) -> __m128 {
     _mm_mask_cvtsh_ss(a, 0xff, a, b)
 }
@@ -16167,7 +16167,7 @@ pub fn _mm_cvtsh_ss(a: __m128, b: __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtsh_ss(src: __m128, k: __mmask8, a: __m128, b: __m128h) -> __m128 {
     unsafe { vcvtsh2ss(a, b, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -16181,7 +16181,7 @@ pub fn _mm_mask_cvtsh_ss(src: __m128, k: __mmask8, a: __m128, b: __m128h) -> __m
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtsh_ss(k: __mmask8, a: __m128, b: __m128h) -> __m128 {
     _mm_mask_cvtsh_ss(_mm_set_ss(0.0), k, a, b)
 }
@@ -16197,7 +16197,7 @@ pub fn _mm_maskz_cvtsh_ss(k: __mmask8, a: __m128, b: __m128h) -> __m128 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_ss<const SAE: i32>(a: __m128, b: __m128h) -> __m128 {
     static_assert_sae!(SAE);
     _mm_mask_cvt_roundsh_ss::<SAE>(_mm_undefined_ps(), 0xff, a, b)
@@ -16215,7 +16215,7 @@ pub fn _mm_cvt_roundsh_ss<const SAE: i32>(a: __m128, b: __m128h) -> __m128 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvt_roundsh_ss<const SAE: i32>(
     src: __m128,
     k: __mmask8,
@@ -16240,7 +16240,7 @@ pub fn _mm_mask_cvt_roundsh_ss<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2ss, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvt_roundsh_ss<const SAE: i32>(k: __mmask8, a: __m128, b: __m128h) -> __m128 {
     static_assert_sae!(SAE);
     _mm_mask_cvt_roundsh_ss::<SAE>(_mm_set_ss(0.0), k, a, b)
@@ -16253,7 +16253,7 @@ pub fn _mm_maskz_cvt_roundsh_ss<const SAE: i32>(k: __mmask8, a: __m128, b: __m12
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtph_pd(a: __m128h) -> __m128d {
     _mm_mask_cvtph_pd(_mm_setzero_pd(), 0xff, a)
 }
@@ -16266,7 +16266,7 @@ pub fn _mm_cvtph_pd(a: __m128h) -> __m128d {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtph_pd(src: __m128d, k: __mmask8, a: __m128h) -> __m128d {
     unsafe { vcvtph2pd_128(a, src, k) }
 }
@@ -16279,7 +16279,7 @@ pub fn _mm_mask_cvtph_pd(src: __m128d, k: __mmask8, a: __m128h) -> __m128d {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m128d {
     _mm_mask_cvtph_pd(_mm_setzero_pd(), k, a)
 }
@@ -16291,7 +16291,7 @@ pub fn _mm_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m128d {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_cvtph_pd(a: __m128h) -> __m256d {
     _mm256_mask_cvtph_pd(_mm256_setzero_pd(), 0xff, a)
 }
@@ -16304,7 +16304,7 @@ pub fn _mm256_cvtph_pd(a: __m128h) -> __m256d {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_mask_cvtph_pd(src: __m256d, k: __mmask8, a: __m128h) -> __m256d {
     unsafe { vcvtph2pd_256(a, src, k) }
 }
@@ -16317,7 +16317,7 @@ pub fn _mm256_mask_cvtph_pd(src: __m256d, k: __mmask8, a: __m128h) -> __m256d {
 #[inline]
 #[target_feature(enable = "avx512fp16,avx512vl")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm256_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m256d {
     _mm256_mask_cvtph_pd(_mm256_setzero_pd(), k, a)
 }
@@ -16329,7 +16329,7 @@ pub fn _mm256_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m256d {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvtph_pd(a: __m128h) -> __m512d {
     _mm512_mask_cvtph_pd(_mm512_setzero_pd(), 0xff, a)
 }
@@ -16342,7 +16342,7 @@ pub fn _mm512_cvtph_pd(a: __m128h) -> __m512d {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvtph_pd(src: __m512d, k: __mmask8, a: __m128h) -> __m512d {
     unsafe { vcvtph2pd_512(a, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -16355,7 +16355,7 @@ pub fn _mm512_mask_cvtph_pd(src: __m512d, k: __mmask8, a: __m128h) -> __m512d {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m512d {
     _mm512_mask_cvtph_pd(_mm512_setzero_pd(), k, a)
 }
@@ -16370,7 +16370,7 @@ pub fn _mm512_maskz_cvtph_pd(k: __mmask8, a: __m128h) -> __m512d {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_cvt_roundph_pd<const SAE: i32>(a: __m128h) -> __m512d {
     static_assert_sae!(SAE);
     _mm512_mask_cvt_roundph_pd::<SAE>(_mm512_setzero_pd(), 0xff, a)
@@ -16387,7 +16387,7 @@ pub fn _mm512_cvt_roundph_pd<const SAE: i32>(a: __m128h) -> __m512d {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_mask_cvt_roundph_pd<const SAE: i32>(
     src: __m512d,
     k: __mmask8,
@@ -16410,7 +16410,7 @@ pub fn _mm512_mask_cvt_roundph_pd<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtph2pd, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm512_maskz_cvt_roundph_pd<const SAE: i32>(k: __mmask8, a: __m128h) -> __m512d {
     static_assert_sae!(SAE);
     _mm512_mask_cvt_roundph_pd::<SAE>(_mm512_setzero_pd(), k, a)
@@ -16424,7 +16424,7 @@ pub fn _mm512_maskz_cvt_roundph_pd<const SAE: i32>(k: __mmask8, a: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_sd(a: __m128d, b: __m128h) -> __m128d {
     _mm_mask_cvtsh_sd(a, 0xff, a, b)
 }
@@ -16438,7 +16438,7 @@ pub fn _mm_cvtsh_sd(a: __m128d, b: __m128h) -> __m128d {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvtsh_sd(src: __m128d, k: __mmask8, a: __m128d, b: __m128h) -> __m128d {
     unsafe { vcvtsh2sd(a, b, src, k, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -16451,7 +16451,7 @@ pub fn _mm_mask_cvtsh_sd(src: __m128d, k: __mmask8, a: __m128d, b: __m128h) -> _
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvtsh_sd(k: __mmask8, a: __m128d, b: __m128h) -> __m128d {
     _mm_mask_cvtsh_sd(_mm_set_sd(0.0), k, a, b)
 }
@@ -16467,7 +16467,7 @@ pub fn _mm_maskz_cvtsh_sd(k: __mmask8, a: __m128d, b: __m128h) -> __m128d {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd, SAE = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_sd<const SAE: i32>(a: __m128d, b: __m128h) -> __m128d {
     static_assert_sae!(SAE);
     _mm_mask_cvt_roundsh_sd::<SAE>(a, 0xff, a, b)
@@ -16485,7 +16485,7 @@ pub fn _mm_cvt_roundsh_sd<const SAE: i32>(a: __m128d, b: __m128h) -> __m128d {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd, SAE = 8))]
 #[rustc_legacy_const_generics(4)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_mask_cvt_roundsh_sd<const SAE: i32>(
     src: __m128d,
     k: __mmask8,
@@ -16509,7 +16509,7 @@ pub fn _mm_mask_cvt_roundsh_sd<const SAE: i32>(
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2sd, SAE = 8))]
 #[rustc_legacy_const_generics(3)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_maskz_cvt_roundsh_sd<const SAE: i32>(k: __mmask8, a: __m128d, b: __m128h) -> __m128d {
     static_assert_sae!(SAE);
     _mm_mask_cvt_roundsh_sd::<SAE>(_mm_set_sd(0.0), k, a, b)
@@ -16553,7 +16553,7 @@ pub const fn _mm512_cvtsh_h(a: __m512h) -> f16 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi128_si16)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_cvtsi128_si16(a: __m128i) -> i16 {
     unsafe { simd_extract!(a.as_i16x8(), 0) }
@@ -16564,7 +16564,7 @@ pub const fn _mm_cvtsi128_si16(a: __m128i) -> i16 {
 /// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi16_si128)
 #[inline]
 #[target_feature(enable = "avx512fp16")]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
 pub const fn _mm_cvtsi16_si128(a: i16) -> __m128i {
     unsafe { transmute(simd_insert!(i16x8::ZERO, 0, a)) }
@@ -16960,14 +16960,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_set_ph() {
+    const fn test_mm_set_ph() {
         let r = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let e = _mm_setr_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         assert_eq_m128h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_set_ph() {
+    const fn test_mm256_set_ph() {
         let r = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -16978,7 +16978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_set_ph() {
+    const fn test_mm512_set_ph() {
         let r = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -16993,21 +16993,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_set_sh() {
+    const fn test_mm_set_sh() {
         let r = _mm_set_sh(1.0);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
         assert_eq_m128h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_set1_ph() {
+    const fn test_mm_set1_ph() {
         let r = _mm_set1_ph(1.0);
         let e = _mm_set_ph(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0);
         assert_eq_m128h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_set1_ph() {
+    const fn test_mm256_set1_ph() {
         let r = _mm256_set1_ph(1.0);
         let e = _mm256_set_ph(
             1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
@@ -17016,7 +17016,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_set1_ph() {
+    const fn test_mm512_set1_ph() {
         let r = _mm512_set1_ph(1.0);
         let e = _mm512_set_ph(
             1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
@@ -17026,14 +17026,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_setr_ph() {
+    const fn test_mm_setr_ph() {
         let r = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let e = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         assert_eq_m128h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_setr_ph() {
+    const fn test_mm256_setr_ph() {
         let r = _mm256_setr_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17044,7 +17044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_setr_ph() {
+    const fn test_mm512_setr_ph() {
         let r = _mm512_setr_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17059,28 +17059,28 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_setzero_ph() {
+    const fn test_mm_setzero_ph() {
         let r = _mm_setzero_ph();
         let e = _mm_set1_ph(0.0);
         assert_eq_m128h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_setzero_ph() {
+    const fn test_mm256_setzero_ph() {
         let r = _mm256_setzero_ph();
         let e = _mm256_set1_ph(0.0);
         assert_eq_m256h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_setzero_ph() {
+    const fn test_mm512_setzero_ph() {
         let r = _mm512_setzero_ph();
         let e = _mm512_set1_ph(0.0);
         assert_eq_m512h(r, e);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_castsi128_ph() {
+    const fn test_mm_castsi128_ph() {
         let a = _mm_set1_epi16(0x3c00);
         let r = _mm_castsi128_ph(a);
         let e = _mm_set1_ph(1.0);
@@ -17088,7 +17088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_castsi256_ph() {
+    const fn test_mm256_castsi256_ph() {
         let a = _mm256_set1_epi16(0x3c00);
         let r = _mm256_castsi256_ph(a);
         let e = _mm256_set1_ph(1.0);
@@ -17096,7 +17096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castsi512_ph() {
+    const fn test_mm512_castsi512_ph() {
         let a = _mm512_set1_epi16(0x3c00);
         let r = _mm512_castsi512_ph(a);
         let e = _mm512_set1_ph(1.0);
@@ -17104,7 +17104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_castph_si128() {
+    const fn test_mm_castph_si128() {
         let a = _mm_set1_ph(1.0);
         let r = _mm_castph_si128(a);
         let e = _mm_set1_epi16(0x3c00);
@@ -17112,7 +17112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm256_castph_si256() {
+    const fn test_mm256_castph_si256() {
         let a = _mm256_set1_ph(1.0);
         let r = _mm256_castph_si256(a);
         let e = _mm256_set1_epi16(0x3c00);
@@ -17120,7 +17120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castph_si512() {
+    const fn test_mm512_castph_si512() {
         let a = _mm512_set1_ph(1.0);
         let r = _mm512_castph_si512(a);
         let e = _mm512_set1_epi16(0x3c00);
@@ -17128,7 +17128,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_castps_ph() {
+    const fn test_mm_castps_ph() {
         let a = _mm_castsi128_ps(_mm_set1_epi16(0x3c00));
         let r = _mm_castps_ph(a);
         let e = _mm_set1_ph(1.0);
@@ -17136,7 +17136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_castps_ph() {
+    const fn test_mm256_castps_ph() {
         let a = _mm256_castsi256_ps(_mm256_set1_epi16(0x3c00));
         let r = _mm256_castps_ph(a);
         let e = _mm256_set1_ph(1.0);
@@ -17144,7 +17144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castps_ph() {
+    const fn test_mm512_castps_ph() {
         let a = _mm512_castsi512_ps(_mm512_set1_epi16(0x3c00));
         let r = _mm512_castps_ph(a);
         let e = _mm512_set1_ph(1.0);
@@ -17152,7 +17152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_castph_ps() {
+    const fn test_mm_castph_ps() {
         let a = _mm_castsi128_ph(_mm_set1_epi32(0x3f800000));
         let r = _mm_castph_ps(a);
         let e = _mm_set1_ps(1.0);
@@ -17160,7 +17160,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm256_castph_ps() {
+    const fn test_mm256_castph_ps() {
         let a = _mm256_castsi256_ph(_mm256_set1_epi32(0x3f800000));
         let r = _mm256_castph_ps(a);
         let e = _mm256_set1_ps(1.0);
@@ -17168,7 +17168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castph_ps() {
+    const fn test_mm512_castph_ps() {
         let a = _mm512_castsi512_ph(_mm512_set1_epi32(0x3f800000));
         let r = _mm512_castph_ps(a);
         let e = _mm512_set1_ps(1.0);
@@ -17176,7 +17176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_castpd_ph() {
+    const fn test_mm_castpd_ph() {
         let a = _mm_castsi128_pd(_mm_set1_epi16(0x3c00));
         let r = _mm_castpd_ph(a);
         let e = _mm_set1_ph(1.0);
@@ -17184,7 +17184,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_castpd_ph() {
+    const fn test_mm256_castpd_ph() {
         let a = _mm256_castsi256_pd(_mm256_set1_epi16(0x3c00));
         let r = _mm256_castpd_ph(a);
         let e = _mm256_set1_ph(1.0);
@@ -17192,7 +17192,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castpd_ph() {
+    const fn test_mm512_castpd_ph() {
         let a = _mm512_castsi512_pd(_mm512_set1_epi16(0x3c00));
         let r = _mm512_castpd_ph(a);
         let e = _mm512_set1_ph(1.0);
@@ -17200,7 +17200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_castph_pd() {
+    const fn test_mm_castph_pd() {
         let a = _mm_castsi128_ph(_mm_set1_epi64x(0x3ff0000000000000));
         let r = _mm_castph_pd(a);
         let e = _mm_set1_pd(1.0);
@@ -17208,7 +17208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm256_castph_pd() {
+    const fn test_mm256_castph_pd() {
         let a = _mm256_castsi256_ph(_mm256_set1_epi64x(0x3ff0000000000000));
         let r = _mm256_castph_pd(a);
         let e = _mm256_set1_pd(1.0);
@@ -17216,7 +17216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_castph_pd() {
+    const fn test_mm512_castph_pd() {
         let a = _mm512_castsi512_ph(_mm512_set1_epi64(0x3ff0000000000000));
         let r = _mm512_castph_pd(a);
         let e = _mm512_set1_pd(1.0);
@@ -17224,7 +17224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_castph256_ph128() {
+    const fn test_mm256_castph256_ph128() {
         let a = _mm256_setr_ph(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -17234,7 +17234,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm512_castph512_ph128() {
+    const fn test_mm512_castph512_ph128() {
         let a = _mm512_setr_ph(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
             20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32.,
@@ -17245,7 +17245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm512_castph512_ph256() {
+    const fn test_mm512_castph512_ph256() {
         let a = _mm512_setr_ph(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
             20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32.,
@@ -17258,21 +17258,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_castph128_ph256() {
+    const fn test_mm256_castph128_ph256() {
         let a = _mm_setr_ph(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_castph128_ph256(a);
         assert_eq_m128h(_mm256_castph256_ph128(r), a);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm512_castph128_ph512() {
+    const fn test_mm512_castph128_ph512() {
         let a = _mm_setr_ph(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_castph128_ph512(a);
         assert_eq_m128h(_mm512_castph512_ph128(r), a);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm512_castph256_ph512() {
+    const fn test_mm512_castph256_ph512() {
         let a = _mm256_setr_ph(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -17281,7 +17281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_zextph128_ph256() {
+    const fn test_mm256_zextph128_ph256() {
         let a = _mm_setr_ph(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm256_zextph128_ph256(a);
         let e = _mm256_setr_ph(
@@ -17291,7 +17291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_zextph128_ph512() {
+    const fn test_mm512_zextph128_ph512() {
         let a = _mm_setr_ph(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_zextph128_ph512(a);
         let e = _mm512_setr_ph(
@@ -17302,7 +17302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_zextph256_ph512() {
+    const fn test_mm512_zextph256_ph512() {
         let a = _mm256_setr_ph(
             1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.,
         );
@@ -17315,7 +17315,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cmp_ph_mask() {
+    fn test_mm_cmp_ph_mask() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(1.0, 2.0, 3.0, 4.0, -5.0, -6.0, -7.0, -8.0);
         let r = _mm_cmp_ph_mask::<_CMP_EQ_OQ>(a, b);
@@ -17323,7 +17323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cmp_ph_mask() {
+    fn test_mm_mask_cmp_ph_mask() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(1.0, 2.0, 3.0, 4.0, -5.0, -6.0, -7.0, -8.0);
         let r = _mm_mask_cmp_ph_mask::<_CMP_EQ_OQ>(0b01010101, a, b);
@@ -17331,7 +17331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cmp_ph_mask() {
+    fn test_mm256_cmp_ph_mask() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17344,7 +17344,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cmp_ph_mask() {
+    fn test_mm256_mask_cmp_ph_mask() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17357,7 +17357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cmp_ph_mask() {
+    fn test_mm512_cmp_ph_mask() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17373,7 +17373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cmp_ph_mask() {
+    fn test_mm512_mask_cmp_ph_mask() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17389,7 +17389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cmp_round_ph_mask() {
+    fn test_mm512_cmp_round_ph_mask() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17405,7 +17405,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cmp_round_ph_mask() {
+    fn test_mm512_mask_cmp_round_ph_mask() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17425,7 +17425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cmp_round_sh_mask() {
+    fn test_mm_cmp_round_sh_mask() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_cmp_round_sh_mask::<_CMP_EQ_OQ, _MM_FROUND_NO_EXC>(a, b);
@@ -17433,7 +17433,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cmp_round_sh_mask() {
+    fn test_mm_mask_cmp_round_sh_mask() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_mask_cmp_round_sh_mask::<_CMP_EQ_OQ, _MM_FROUND_NO_EXC>(0, a, b);
@@ -17441,7 +17441,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cmp_sh_mask() {
+    fn test_mm_cmp_sh_mask() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_cmp_sh_mask::<_CMP_EQ_OQ>(a, b);
@@ -17449,7 +17449,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cmp_sh_mask() {
+    fn test_mm_mask_cmp_sh_mask() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_mask_cmp_sh_mask::<_CMP_EQ_OQ>(0, a, b);
@@ -17457,7 +17457,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comi_round_sh() {
+    fn test_mm_comi_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_comi_round_sh::<_CMP_EQ_OQ, _MM_FROUND_NO_EXC>(a, b);
@@ -17465,7 +17465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comi_sh() {
+    fn test_mm_comi_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_comi_sh::<_CMP_EQ_OQ>(a, b);
@@ -17473,7 +17473,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comieq_sh() {
+    fn test_mm_comieq_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_comieq_sh(a, b);
@@ -17481,7 +17481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comige_sh() {
+    fn test_mm_comige_sh() {
         let a = _mm_set_sh(2.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_comige_sh(a, b);
@@ -17489,7 +17489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comigt_sh() {
+    fn test_mm_comigt_sh() {
         let a = _mm_set_sh(2.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_comigt_sh(a, b);
@@ -17497,7 +17497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comile_sh() {
+    fn test_mm_comile_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_comile_sh(a, b);
@@ -17505,7 +17505,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comilt_sh() {
+    fn test_mm_comilt_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_comilt_sh(a, b);
@@ -17513,7 +17513,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_comineq_sh() {
+    fn test_mm_comineq_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_comineq_sh(a, b);
@@ -17521,7 +17521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomieq_sh() {
+    fn test_mm_ucomieq_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_ucomieq_sh(a, b);
@@ -17529,7 +17529,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomige_sh() {
+    fn test_mm_ucomige_sh() {
         let a = _mm_set_sh(2.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_ucomige_sh(a, b);
@@ -17537,7 +17537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomigt_sh() {
+    fn test_mm_ucomigt_sh() {
         let a = _mm_set_sh(2.0);
         let b = _mm_set_sh(1.0);
         let r = _mm_ucomigt_sh(a, b);
@@ -17545,7 +17545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomile_sh() {
+    fn test_mm_ucomile_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_ucomile_sh(a, b);
@@ -17553,7 +17553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomilt_sh() {
+    fn test_mm_ucomilt_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_ucomilt_sh(a, b);
@@ -17561,7 +17561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_ucomineq_sh() {
+    fn test_mm_ucomineq_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_ucomineq_sh(a, b);
@@ -17658,7 +17658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_move_sh() {
+    const fn test_mm_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
         let r = _mm_move_sh(a, b);
@@ -17667,7 +17667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_move_sh() {
+    const fn test_mm_mask_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
         let src = _mm_set_sh(10.0);
@@ -17677,7 +17677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_move_sh() {
+    const fn test_mm_maskz_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
         let r = _mm_maskz_move_sh(0, a, b);
@@ -17764,7 +17764,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_add_ph() {
+    const fn test_mm_add_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_add_ph(a, b);
@@ -17773,7 +17773,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_add_ph() {
+    const fn test_mm_mask_add_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -17783,7 +17783,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_add_ph() {
+    const fn test_mm_maskz_add_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_maskz_add_ph(0b01010101, a, b);
@@ -17792,7 +17792,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_add_ph() {
+    const fn test_mm256_add_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17805,7 +17805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_add_ph() {
+    const fn test_mm256_mask_add_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17823,7 +17823,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_ph() {
+    const fn test_mm256_maskz_add_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -17838,7 +17838,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_add_ph() {
+    const fn test_mm512_add_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17855,7 +17855,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_add_ph() {
+    const fn test_mm512_mask_add_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17879,7 +17879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_add_ph() {
+    const fn test_mm512_maskz_add_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17899,7 +17899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_add_round_ph() {
+    fn test_mm512_add_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17916,7 +17916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_add_round_ph() {
+    fn test_mm512_mask_add_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17945,7 +17945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_add_round_ph() {
+    fn test_mm512_maskz_add_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -17969,7 +17969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_add_round_sh() {
+    fn test_mm_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_add_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -17978,7 +17978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_add_round_sh() {
+    fn test_mm_mask_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -17995,7 +17995,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_add_round_sh() {
+    fn test_mm_maskz_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r =
@@ -18009,7 +18009,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_add_sh() {
+    const fn test_mm_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_add_sh(a, b);
@@ -18018,7 +18018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_add_sh() {
+    const fn test_mm_mask_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18031,7 +18031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_add_sh() {
+    const fn test_mm_maskz_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_maskz_add_sh(0, a, b);
@@ -18043,7 +18043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_sub_ph() {
+    const fn test_mm_sub_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_sub_ph(a, b);
@@ -18052,7 +18052,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_sub_ph() {
+    const fn test_mm_mask_sub_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -18062,7 +18062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_ph() {
+    const fn test_mm_maskz_sub_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_maskz_sub_ph(0b01010101, a, b);
@@ -18071,7 +18071,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_sub_ph() {
+    const fn test_mm256_sub_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18087,7 +18087,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_ph() {
+    const fn test_mm256_mask_sub_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18105,7 +18105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_ph() {
+    const fn test_mm256_maskz_sub_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18120,7 +18120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_sub_ph() {
+    const fn test_mm512_sub_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18141,7 +18141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_sub_ph() {
+    const fn test_mm512_mask_sub_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18165,7 +18165,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_sub_ph() {
+    const fn test_mm512_maskz_sub_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18185,7 +18185,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_sub_round_ph() {
+    fn test_mm512_sub_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18206,7 +18206,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_sub_round_ph() {
+    fn test_mm512_mask_sub_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18235,7 +18235,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_sub_round_ph() {
+    fn test_mm512_maskz_sub_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18259,7 +18259,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_sub_round_sh() {
+    fn test_mm_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_sub_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -18268,7 +18268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_sub_round_sh() {
+    fn test_mm_mask_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18285,7 +18285,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_sub_round_sh() {
+    fn test_mm_maskz_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r =
@@ -18299,7 +18299,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_sub_sh() {
+    const fn test_mm_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_sub_sh(a, b);
@@ -18308,7 +18308,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_sub_sh() {
+    const fn test_mm_mask_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18321,7 +18321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_sh() {
+    const fn test_mm_maskz_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_maskz_sub_sh(0, a, b);
@@ -18333,7 +18333,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mul_ph() {
+    const fn test_mm_mul_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_mul_ph(a, b);
@@ -18342,7 +18342,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_mul_ph() {
+    const fn test_mm_mask_mul_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -18352,7 +18352,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_ph() {
+    const fn test_mm_maskz_mul_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
         let r = _mm_maskz_mul_ph(0b01010101, a, b);
@@ -18361,7 +18361,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mul_ph() {
+    const fn test_mm256_mul_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18377,7 +18377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_mul_ph() {
+    const fn test_mm256_mask_mul_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18395,7 +18395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_mul_ph() {
+    const fn test_mm256_maskz_mul_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -18410,7 +18410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mul_ph() {
+    const fn test_mm512_mul_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18431,7 +18431,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_mul_ph() {
+    const fn test_mm512_mask_mul_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18455,7 +18455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_mul_ph() {
+    const fn test_mm512_maskz_mul_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18475,7 +18475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mul_round_ph() {
+    fn test_mm512_mul_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18496,7 +18496,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_mul_round_ph() {
+    fn test_mm512_mask_mul_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18525,7 +18525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_mul_round_ph() {
+    fn test_mm512_maskz_mul_round_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -18549,7 +18549,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mul_round_sh() {
+    fn test_mm_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_mul_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -18558,7 +18558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_mul_round_sh() {
+    fn test_mm_mask_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18575,7 +18575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_mul_round_sh() {
+    fn test_mm_maskz_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r =
@@ -18589,7 +18589,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mul_sh() {
+    const fn test_mm_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_mul_sh(a, b);
@@ -18598,7 +18598,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_mul_sh() {
+    const fn test_mm_mask_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18611,7 +18611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_sh() {
+    const fn test_mm_maskz_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_maskz_mul_sh(0, a, b);
@@ -18623,7 +18623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_div_ph() {
+    const fn test_mm_div_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let r = _mm_div_ph(a, b);
@@ -18632,7 +18632,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_div_ph() {
+    const fn test_mm_mask_div_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let src = _mm_set_ph(4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0);
@@ -18642,7 +18642,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_div_ph() {
+    const fn test_mm_maskz_div_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let r = _mm_maskz_div_ph(0b01010101, a, b);
@@ -18651,7 +18651,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_div_ph() {
+    const fn test_mm256_div_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let r = _mm256_div_ph(a, b);
@@ -18660,7 +18660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_div_ph() {
+    const fn test_mm256_mask_div_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let src = _mm256_set_ph(
@@ -18675,7 +18675,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_div_ph() {
+    const fn test_mm256_maskz_div_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let r = _mm256_maskz_div_ph(0b0101010101010101, a, b);
@@ -18686,7 +18686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_div_ph() {
+    const fn test_mm512_div_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let r = _mm512_div_ph(a, b);
@@ -18695,7 +18695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_div_ph() {
+    const fn test_mm512_mask_div_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let src = _mm512_set_ph(
@@ -18712,7 +18712,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_div_ph() {
+    const fn test_mm512_maskz_div_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let r = _mm512_maskz_div_ph(0b01010101010101010101010101010101, a, b);
@@ -18724,7 +18724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_div_round_ph() {
+    fn test_mm512_div_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let r = _mm512_div_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -18733,7 +18733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_div_round_ph() {
+    fn test_mm512_mask_div_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let src = _mm512_set_ph(
@@ -18755,7 +18755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_div_round_ph() {
+    fn test_mm512_maskz_div_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let r = _mm512_maskz_div_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -18771,7 +18771,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_div_round_sh() {
+    fn test_mm_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_div_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -18780,7 +18780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_div_round_sh() {
+    fn test_mm_mask_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18797,7 +18797,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_div_round_sh() {
+    fn test_mm_maskz_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r =
@@ -18811,7 +18811,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_div_sh() {
+    const fn test_mm_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_div_sh(a, b);
@@ -18820,7 +18820,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_div_sh() {
+    const fn test_mm_mask_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let src = _mm_set_sh(4.0);
@@ -18833,7 +18833,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_div_sh() {
+    const fn test_mm_maskz_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
         let r = _mm_maskz_div_sh(0, a, b);
@@ -18845,7 +18845,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mul_pch() {
+    fn test_mm_mul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let r = _mm_mul_pch(a, b);
@@ -18854,7 +18854,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_mul_pch() {
+    fn test_mm_mask_mul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let src = _mm_setr_ph(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
@@ -18864,7 +18864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_mul_pch() {
+    fn test_mm_maskz_mul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let r = _mm_maskz_mul_pch(0b0101, a, b);
@@ -18873,7 +18873,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mul_pch() {
+    fn test_mm256_mul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_mul_pch(a, b);
@@ -18882,7 +18882,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_mul_pch() {
+    fn test_mm256_mask_mul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let src = _mm256_setr_ph(
@@ -18896,7 +18896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_mul_pch() {
+    fn test_mm256_maskz_mul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_maskz_mul_pch(0b01010101, a, b);
@@ -18907,7 +18907,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mul_pch() {
+    fn test_mm512_mul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_mul_pch(a, b);
@@ -18916,7 +18916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_mul_pch() {
+    fn test_mm512_mask_mul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let src = _mm512_setr_ph(
@@ -18934,7 +18934,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_mul_pch() {
+    fn test_mm512_maskz_mul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_maskz_mul_pch(0b0101010101010101, a, b);
@@ -18946,7 +18946,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mul_round_pch() {
+    fn test_mm512_mul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_mul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -18955,7 +18955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_mul_round_pch() {
+    fn test_mm512_mask_mul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let src = _mm512_setr_ph(
@@ -18978,7 +18978,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_mul_round_pch() {
+    fn test_mm512_maskz_mul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_maskz_mul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -18994,7 +18994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mul_round_sch() {
+    fn test_mm_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_mul_round_sch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19003,7 +19003,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_mul_round_sch() {
+    fn test_mm_mask_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19015,7 +19015,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_mul_round_sch() {
+    fn test_mm_maskz_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r =
@@ -19025,7 +19025,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mul_sch() {
+    fn test_mm_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_mul_sch(a, b);
@@ -19034,7 +19034,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_mul_sch() {
+    fn test_mm_mask_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19044,7 +19044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_mul_sch() {
+    fn test_mm_maskz_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_maskz_mul_sch(0, a, b);
@@ -19053,7 +19053,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmul_pch() {
+    fn test_mm_fmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let r = _mm_fmul_pch(a, b);
@@ -19062,7 +19062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmul_pch() {
+    fn test_mm_mask_fmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let src = _mm_setr_ph(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
@@ -19072,7 +19072,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmul_pch() {
+    fn test_mm_maskz_fmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 1.0);
         let r = _mm_maskz_fmul_pch(0b0101, a, b);
@@ -19081,7 +19081,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_fmul_pch() {
+    fn test_mm256_fmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_fmul_pch(a, b);
@@ -19090,7 +19090,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_fmul_pch() {
+    fn test_mm256_mask_fmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let src = _mm256_setr_ph(
@@ -19104,7 +19104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_fmul_pch() {
+    fn test_mm256_maskz_fmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_maskz_fmul_pch(0b01010101, a, b);
@@ -19115,7 +19115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmul_pch() {
+    fn test_mm512_fmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_fmul_pch(a, b);
@@ -19124,7 +19124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmul_pch() {
+    fn test_mm512_mask_fmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let src = _mm512_setr_ph(
@@ -19142,7 +19142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmul_pch() {
+    fn test_mm512_maskz_fmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_maskz_fmul_pch(0b0101010101010101, a, b);
@@ -19154,7 +19154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmul_round_pch() {
+    fn test_mm512_fmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_fmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19163,7 +19163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmul_round_pch() {
+    fn test_mm512_mask_fmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let src = _mm512_setr_ph(
@@ -19186,7 +19186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmul_round_pch() {
+    fn test_mm512_maskz_fmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_maskz_fmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -19202,7 +19202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmul_round_sch() {
+    fn test_mm_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_fmul_round_sch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19211,7 +19211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmul_round_sch() {
+    fn test_mm_mask_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19223,7 +19223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmul_round_sch() {
+    fn test_mm_maskz_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r =
@@ -19233,7 +19233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmul_sch() {
+    fn test_mm_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_fmul_sch(a, b);
@@ -19242,7 +19242,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmul_sch() {
+    fn test_mm_mask_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19252,7 +19252,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmul_sch() {
+    fn test_mm_maskz_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let r = _mm_maskz_fmul_sch(0, a, b);
@@ -19261,7 +19261,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cmul_pch() {
+    fn test_mm_cmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let r = _mm_cmul_pch(a, b);
@@ -19270,7 +19270,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cmul_pch() {
+    fn test_mm_mask_cmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let src = _mm_setr_ph(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
@@ -19280,7 +19280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cmul_pch() {
+    fn test_mm_maskz_cmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let r = _mm_maskz_cmul_pch(0b0101, a, b);
@@ -19289,7 +19289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cmul_pch() {
+    fn test_mm256_cmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let r = _mm256_cmul_pch(a, b);
@@ -19298,7 +19298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cmul_pch() {
+    fn test_mm256_mask_cmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let src = _mm256_setr_ph(
@@ -19312,7 +19312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cmul_pch() {
+    fn test_mm256_maskz_cmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let r = _mm256_maskz_cmul_pch(0b01010101, a, b);
@@ -19323,7 +19323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cmul_pch() {
+    fn test_mm512_cmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_cmul_pch(a, b);
@@ -19332,7 +19332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cmul_pch() {
+    fn test_mm512_mask_cmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let src = _mm512_setr_ph(
@@ -19350,7 +19350,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cmul_pch() {
+    fn test_mm512_maskz_cmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_maskz_cmul_pch(0b0101010101010101, a, b);
@@ -19362,7 +19362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cmul_round_pch() {
+    fn test_mm512_cmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_cmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19371,7 +19371,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cmul_round_pch() {
+    fn test_mm512_mask_cmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let src = _mm512_setr_ph(
@@ -19394,7 +19394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cmul_round_pch() {
+    fn test_mm512_maskz_cmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_maskz_cmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -19410,7 +19410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cmul_sch() {
+    fn test_mm_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_cmul_sch(a, b);
@@ -19419,7 +19419,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cmul_sch() {
+    fn test_mm_mask_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19429,7 +19429,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cmul_sch() {
+    fn test_mm_maskz_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_maskz_cmul_sch(0, a, b);
@@ -19438,7 +19438,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cmul_round_sch() {
+    fn test_mm_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_cmul_round_sch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19447,7 +19447,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cmul_round_sch() {
+    fn test_mm_mask_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19459,7 +19459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cmul_round_sch() {
+    fn test_mm_maskz_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r =
@@ -19469,7 +19469,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmul_pch() {
+    fn test_mm_fcmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let r = _mm_fcmul_pch(a, b);
@@ -19478,7 +19478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmul_pch() {
+    fn test_mm_mask_fcmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let src = _mm_setr_ph(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
@@ -19488,7 +19488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmul_pch() {
+    fn test_mm_maskz_fcmul_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, -1.0);
         let r = _mm_maskz_fcmul_pch(0b0101, a, b);
@@ -19497,7 +19497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_fcmul_pch() {
+    fn test_mm256_fcmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let r = _mm256_fcmul_pch(a, b);
@@ -19506,7 +19506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_fcmul_pch() {
+    fn test_mm256_mask_fcmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let src = _mm256_setr_ph(
@@ -19520,7 +19520,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_fcmul_pch() {
+    fn test_mm256_maskz_fcmul_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, -1.0);
         let r = _mm256_maskz_fcmul_pch(0b01010101, a, b);
@@ -19531,7 +19531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fcmul_pch() {
+    fn test_mm512_fcmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_fcmul_pch(a, b);
@@ -19540,7 +19540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fcmul_pch() {
+    fn test_mm512_mask_fcmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let src = _mm512_setr_ph(
@@ -19558,7 +19558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fcmul_pch() {
+    fn test_mm512_maskz_fcmul_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_maskz_fcmul_pch(0b0101010101010101, a, b);
@@ -19570,7 +19570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fcmul_round_pch() {
+    fn test_mm512_fcmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_fcmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19579,7 +19579,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fcmul_round_pch() {
+    fn test_mm512_mask_fcmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let src = _mm512_setr_ph(
@@ -19602,7 +19602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fcmul_round_pch() {
+    fn test_mm512_maskz_fcmul_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, -1.0);
         let r = _mm512_maskz_fcmul_round_pch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -19618,7 +19618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmul_sch() {
+    fn test_mm_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_fcmul_sch(a, b);
@@ -19627,7 +19627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmul_sch() {
+    fn test_mm_mask_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19637,7 +19637,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmul_sch() {
+    fn test_mm_maskz_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_maskz_fcmul_sch(0, a, b);
@@ -19646,7 +19646,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmul_round_sch() {
+    fn test_mm_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r = _mm_fcmul_round_sch::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -19655,7 +19655,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmul_round_sch() {
+    fn test_mm_mask_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let src = _mm_setr_ph(14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0);
@@ -19667,7 +19667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmul_round_sch() {
+    fn test_mm_maskz_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
         let r =
@@ -19677,7 +19677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_abs_ph() {
+    const fn test_mm_abs_ph() {
         let a = _mm_set_ph(-1.0, 0.0, 1.0, -2.0, 3.0, -4.0, 5.0, -6.0);
         let r = _mm_abs_ph(a);
         let e = _mm_set_ph(1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
@@ -19685,7 +19685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_abs_ph() {
+    const fn test_mm256_abs_ph() {
         let a = _mm256_set_ph(
             -1.0, 0.0, 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0, 9.0, -10.0, 11.0, -12.0, 13.0,
             -14.0,
@@ -19698,7 +19698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_abs_ph() {
+    const fn test_mm512_abs_ph() {
         let a = _mm512_set_ph(
             -1.0, 0.0, 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0, 9.0, -10.0, 11.0, -12.0, 13.0,
             -14.0, 15.0, -16.0, 17.0, -18.0, 19.0, -20.0, 21.0, -22.0, 23.0, -24.0, 25.0, -26.0,
@@ -19714,7 +19714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_conj_pch() {
+    const fn test_mm_conj_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let r = _mm_conj_pch(a);
         let e = _mm_set1_pch(0.0, -1.0);
@@ -19722,7 +19722,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_conj_pch() {
+    const fn test_mm_mask_conj_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let src = _mm_setr_ph(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
         let r = _mm_mask_conj_pch(src, 0b0101, a);
@@ -19731,7 +19731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_conj_pch() {
+    const fn test_mm_maskz_conj_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let r = _mm_maskz_conj_pch(0b0101, a);
         let e = _mm_setr_ph(0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0);
@@ -19739,7 +19739,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_conj_pch() {
+    const fn test_mm256_conj_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_conj_pch(a);
         let e = _mm256_set1_pch(0.0, -1.0);
@@ -19747,7 +19747,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_conj_pch() {
+    const fn test_mm256_mask_conj_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let src = _mm256_setr_ph(
             2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0,
@@ -19760,7 +19760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_conj_pch() {
+    const fn test_mm256_maskz_conj_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let r = _mm256_maskz_conj_pch(0b01010101, a);
         let e = _mm256_setr_ph(
@@ -19770,7 +19770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_conj_pch() {
+    const fn test_mm512_conj_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_conj_pch(a);
         let e = _mm512_set1_pch(0.0, -1.0);
@@ -19778,7 +19778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_conj_pch() {
+    const fn test_mm512_mask_conj_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let src = _mm512_setr_ph(
             2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0,
@@ -19795,7 +19795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_conj_pch() {
+    const fn test_mm512_maskz_conj_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let r = _mm512_maskz_conj_pch(0b0101010101010101, a);
         let e = _mm512_setr_ph(
@@ -19806,7 +19806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmadd_pch() {
+    fn test_mm_fmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -19816,7 +19816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmadd_pch() {
+    fn test_mm_mask_fmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -19826,7 +19826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fmadd_pch() {
+    fn test_mm_mask3_fmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -19836,7 +19836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmadd_pch() {
+    fn test_mm_maskz_fmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -19846,7 +19846,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_fmadd_pch() {
+    fn test_mm256_fmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -19856,7 +19856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_fmadd_pch() {
+    fn test_mm256_mask_fmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -19868,7 +19868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask3_fmadd_pch() {
+    fn test_mm256_mask3_fmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -19880,7 +19880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_fmadd_pch() {
+    fn test_mm256_maskz_fmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -19892,7 +19892,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmadd_pch() {
+    fn test_mm512_fmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19902,7 +19902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmadd_pch() {
+    fn test_mm512_mask_fmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19915,7 +19915,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmadd_pch() {
+    fn test_mm512_mask3_fmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19928,7 +19928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmadd_pch() {
+    fn test_mm512_maskz_fmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19941,7 +19941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmadd_round_pch() {
+    fn test_mm512_fmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19952,7 +19952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmadd_round_pch() {
+    fn test_mm512_mask_fmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19970,7 +19970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmadd_round_pch() {
+    fn test_mm512_mask3_fmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -19988,7 +19988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmadd_round_pch() {
+    fn test_mm512_maskz_fmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20006,7 +20006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmadd_sch() {
+    fn test_mm_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20016,7 +20016,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmadd_sch() {
+    fn test_mm_mask_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20029,7 +20029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fmadd_sch() {
+    fn test_mm_mask3_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20042,7 +20042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmadd_sch() {
+    fn test_mm_maskz_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20055,7 +20055,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmadd_round_sch() {
+    fn test_mm_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20065,7 +20065,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmadd_round_sch() {
+    fn test_mm_mask_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20082,7 +20082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fmadd_round_sch() {
+    fn test_mm_mask3_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20099,7 +20099,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmadd_round_sch() {
+    fn test_mm_maskz_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20116,7 +20116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmadd_pch() {
+    fn test_mm_fcmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -20126,7 +20126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmadd_pch() {
+    fn test_mm_mask_fcmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -20136,7 +20136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fcmadd_pch() {
+    fn test_mm_mask3_fcmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -20146,7 +20146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmadd_pch() {
+    fn test_mm_maskz_fcmadd_pch() {
         let a = _mm_set1_pch(0.0, 1.0);
         let b = _mm_set1_pch(0.0, 2.0);
         let c = _mm_set1_pch(0.0, 3.0);
@@ -20156,7 +20156,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_fcmadd_pch() {
+    fn test_mm256_fcmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -20166,7 +20166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_fcmadd_pch() {
+    fn test_mm256_mask_fcmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -20178,7 +20178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask3_fcmadd_pch() {
+    fn test_mm256_mask3_fcmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -20190,7 +20190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_fcmadd_pch() {
+    fn test_mm256_maskz_fcmadd_pch() {
         let a = _mm256_set1_pch(0.0, 1.0);
         let b = _mm256_set1_pch(0.0, 2.0);
         let c = _mm256_set1_pch(0.0, 3.0);
@@ -20202,7 +20202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fcmadd_pch() {
+    fn test_mm512_fcmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20212,7 +20212,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fcmadd_pch() {
+    fn test_mm512_mask_fcmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20225,7 +20225,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fcmadd_pch() {
+    fn test_mm512_mask3_fcmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20238,7 +20238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fcmadd_pch() {
+    fn test_mm512_maskz_fcmadd_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20251,7 +20251,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fcmadd_round_pch() {
+    fn test_mm512_fcmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20262,7 +20262,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fcmadd_round_pch() {
+    fn test_mm512_mask_fcmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20280,7 +20280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fcmadd_round_pch() {
+    fn test_mm512_mask3_fcmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20298,7 +20298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fcmadd_round_pch() {
+    fn test_mm512_maskz_fcmadd_round_pch() {
         let a = _mm512_set1_pch(0.0, 1.0);
         let b = _mm512_set1_pch(0.0, 2.0);
         let c = _mm512_set1_pch(0.0, 3.0);
@@ -20316,7 +20316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmadd_sch() {
+    fn test_mm_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20326,7 +20326,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmadd_sch() {
+    fn test_mm_mask_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20339,7 +20339,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fcmadd_sch() {
+    fn test_mm_mask3_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20352,7 +20352,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmadd_sch() {
+    fn test_mm_maskz_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20365,7 +20365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fcmadd_round_sch() {
+    fn test_mm_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20375,7 +20375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fcmadd_round_sch() {
+    fn test_mm_mask_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20392,7 +20392,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fcmadd_round_sch() {
+    fn test_mm_mask3_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20409,7 +20409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fcmadd_round_sch() {
+    fn test_mm_maskz_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
         let c = _mm_setr_ph(0.0, 3.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0);
@@ -20426,7 +20426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmadd_ph() {
+    const fn test_mm_fmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20436,7 +20436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmadd_ph() {
+    const fn test_mm_mask_fmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20446,7 +20446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmadd_ph() {
+    const fn test_mm_mask3_fmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20456,7 +20456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmadd_ph() {
+    const fn test_mm_maskz_fmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20466,7 +20466,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fmadd_ph() {
+    const fn test_mm256_fmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20476,7 +20476,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fmadd_ph() {
+    const fn test_mm256_mask_fmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20488,7 +20488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmadd_ph() {
+    const fn test_mm256_mask3_fmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20500,7 +20500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmadd_ph() {
+    const fn test_mm256_maskz_fmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20512,7 +20512,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fmadd_ph() {
+    const fn test_mm512_fmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20522,7 +20522,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fmadd_ph() {
+    const fn test_mm512_mask_fmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20535,7 +20535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fmadd_ph() {
+    const fn test_mm512_mask3_fmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20548,7 +20548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fmadd_ph() {
+    const fn test_mm512_maskz_fmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20561,7 +20561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmadd_round_ph() {
+    fn test_mm512_fmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20571,7 +20571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmadd_round_ph() {
+    fn test_mm512_mask_fmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20589,7 +20589,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmadd_round_ph() {
+    fn test_mm512_mask3_fmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20607,7 +20607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmadd_round_ph() {
+    fn test_mm512_maskz_fmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20625,7 +20625,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmadd_sh() {
+    const fn test_mm_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20635,7 +20635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmadd_sh() {
+    const fn test_mm_mask_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20648,7 +20648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmadd_sh() {
+    const fn test_mm_mask3_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20661,7 +20661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmadd_sh() {
+    const fn test_mm_maskz_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20674,7 +20674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmadd_round_sh() {
+    fn test_mm_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20684,7 +20684,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmadd_round_sh() {
+    fn test_mm_mask_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20701,7 +20701,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fmadd_round_sh() {
+    fn test_mm_mask3_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20718,7 +20718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmadd_round_sh() {
+    fn test_mm_maskz_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20735,7 +20735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmsub_ph() {
+    const fn test_mm_fmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20745,7 +20745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmsub_ph() {
+    const fn test_mm_mask_fmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20755,7 +20755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsub_ph() {
+    const fn test_mm_mask3_fmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20765,7 +20765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsub_ph() {
+    const fn test_mm_maskz_fmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -20775,7 +20775,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fmsub_ph() {
+    const fn test_mm256_fmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20785,7 +20785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsub_ph() {
+    const fn test_mm256_mask_fmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20797,7 +20797,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsub_ph() {
+    const fn test_mm256_mask3_fmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20809,7 +20809,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsub_ph() {
+    const fn test_mm256_maskz_fmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -20821,7 +20821,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fmsub_ph() {
+    const fn test_mm512_fmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20831,7 +20831,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fmsub_ph() {
+    const fn test_mm512_mask_fmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20844,7 +20844,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fmsub_ph() {
+    const fn test_mm512_mask3_fmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20857,7 +20857,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fmsub_ph() {
+    const fn test_mm512_maskz_fmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20870,7 +20870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmsub_round_ph() {
+    fn test_mm512_fmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20880,7 +20880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmsub_round_ph() {
+    fn test_mm512_mask_fmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20898,7 +20898,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmsub_round_ph() {
+    fn test_mm512_mask3_fmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20916,7 +20916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmsub_round_ph() {
+    fn test_mm512_maskz_fmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -20934,7 +20934,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmsub_sh() {
+    const fn test_mm_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20944,7 +20944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmsub_sh() {
+    const fn test_mm_mask_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20957,7 +20957,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsub_sh() {
+    const fn test_mm_mask3_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20970,7 +20970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsub_sh() {
+    const fn test_mm_maskz_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20983,7 +20983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fmsub_round_sh() {
+    fn test_mm_fmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -20993,7 +20993,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fmsub_round_sh() {
+    fn test_mm_mask_fmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21010,7 +21010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fmsub_round_sh() {
+    fn test_mm_mask3_fmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21027,7 +21027,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fmsub_round_sh() {
+    fn test_mm_maskz_fmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21044,7 +21044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fnmadd_ph() {
+    const fn test_mm_fnmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21054,7 +21054,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fnmadd_ph() {
+    const fn test_mm_mask_fnmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21064,7 +21064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmadd_ph() {
+    const fn test_mm_mask3_fnmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21074,7 +21074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmadd_ph() {
+    const fn test_mm_maskz_fnmadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21084,7 +21084,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fnmadd_ph() {
+    const fn test_mm256_fnmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21094,7 +21094,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmadd_ph() {
+    const fn test_mm256_mask_fnmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21106,7 +21106,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmadd_ph() {
+    const fn test_mm256_mask3_fnmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21118,7 +21118,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmadd_ph() {
+    const fn test_mm256_maskz_fnmadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21130,7 +21130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fnmadd_ph() {
+    const fn test_mm512_fnmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21140,7 +21140,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fnmadd_ph() {
+    const fn test_mm512_mask_fnmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21153,7 +21153,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fnmadd_ph() {
+    const fn test_mm512_mask3_fnmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21166,7 +21166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fnmadd_ph() {
+    const fn test_mm512_maskz_fnmadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21179,7 +21179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fnmadd_round_ph() {
+    fn test_mm512_fnmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21190,7 +21190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fnmadd_round_ph() {
+    fn test_mm512_mask_fnmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21208,7 +21208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fnmadd_round_ph() {
+    fn test_mm512_mask3_fnmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21226,7 +21226,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fnmadd_round_ph() {
+    fn test_mm512_maskz_fnmadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21244,7 +21244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fnmadd_sh() {
+    const fn test_mm_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21254,7 +21254,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fnmadd_sh() {
+    const fn test_mm_mask_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21267,7 +21267,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmadd_sh() {
+    const fn test_mm_mask3_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21280,7 +21280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmadd_sh() {
+    const fn test_mm_maskz_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21293,7 +21293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fnmadd_round_sh() {
+    fn test_mm_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21303,7 +21303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fnmadd_round_sh() {
+    fn test_mm_mask_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21320,7 +21320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fnmadd_round_sh() {
+    fn test_mm_mask3_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21337,7 +21337,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fnmadd_round_sh() {
+    fn test_mm_maskz_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21354,7 +21354,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fnmsub_ph() {
+    const fn test_mm_fnmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21364,7 +21364,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fnmsub_ph() {
+    const fn test_mm_mask_fnmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21374,7 +21374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmsub_ph() {
+    const fn test_mm_mask3_fnmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21384,7 +21384,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmsub_ph() {
+    const fn test_mm_maskz_fnmsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21394,7 +21394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fnmsub_ph() {
+    const fn test_mm256_fnmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21404,7 +21404,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmsub_ph() {
+    const fn test_mm256_mask_fnmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21416,7 +21416,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmsub_ph() {
+    const fn test_mm256_mask3_fnmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21428,7 +21428,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmsub_ph() {
+    const fn test_mm256_maskz_fnmsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21440,7 +21440,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fnmsub_ph() {
+    const fn test_mm512_fnmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21450,7 +21450,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fnmsub_ph() {
+    const fn test_mm512_mask_fnmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21463,7 +21463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fnmsub_ph() {
+    const fn test_mm512_mask3_fnmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21476,7 +21476,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fnmsub_ph() {
+    const fn test_mm512_maskz_fnmsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21489,7 +21489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fnmsub_round_ph() {
+    fn test_mm512_fnmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21500,7 +21500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fnmsub_round_ph() {
+    fn test_mm512_mask_fnmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21518,7 +21518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fnmsub_round_ph() {
+    fn test_mm512_mask3_fnmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21536,7 +21536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fnmsub_round_ph() {
+    fn test_mm512_maskz_fnmsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21554,7 +21554,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fnmsub_sh() {
+    const fn test_mm_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21564,7 +21564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fnmsub_sh() {
+    const fn test_mm_mask_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21577,7 +21577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmsub_sh() {
+    const fn test_mm_mask3_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21590,7 +21590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmsub_sh() {
+    const fn test_mm_maskz_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21603,7 +21603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fnmsub_round_sh() {
+    fn test_mm_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21613,7 +21613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fnmsub_round_sh() {
+    fn test_mm_mask_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21630,7 +21630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask3_fnmsub_round_sh() {
+    fn test_mm_mask3_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21647,7 +21647,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_fnmsub_round_sh() {
+    fn test_mm_maskz_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
         let c = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -21664,7 +21664,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmaddsub_ph() {
+    const fn test_mm_fmaddsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21674,7 +21674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmaddsub_ph() {
+    const fn test_mm_mask_fmaddsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21684,7 +21684,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmaddsub_ph() {
+    const fn test_mm_mask3_fmaddsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21694,7 +21694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmaddsub_ph() {
+    const fn test_mm_maskz_fmaddsub_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21704,7 +21704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fmaddsub_ph() {
+    const fn test_mm256_fmaddsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21716,7 +21716,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fmaddsub_ph() {
+    const fn test_mm256_mask_fmaddsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21728,7 +21728,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmaddsub_ph() {
+    const fn test_mm256_mask3_fmaddsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21740,7 +21740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmaddsub_ph() {
+    const fn test_mm256_maskz_fmaddsub_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21752,7 +21752,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fmaddsub_ph() {
+    const fn test_mm512_fmaddsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21765,7 +21765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fmaddsub_ph() {
+    const fn test_mm512_mask_fmaddsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21778,7 +21778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fmaddsub_ph() {
+    const fn test_mm512_mask3_fmaddsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21791,7 +21791,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fmaddsub_ph() {
+    const fn test_mm512_maskz_fmaddsub_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21804,7 +21804,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmaddsub_round_ph() {
+    fn test_mm512_fmaddsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21818,7 +21818,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmaddsub_round_ph() {
+    fn test_mm512_mask_fmaddsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21836,7 +21836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmaddsub_round_ph() {
+    fn test_mm512_mask3_fmaddsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21854,7 +21854,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmaddsub_round_ph() {
+    fn test_mm512_maskz_fmaddsub_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21872,7 +21872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_fmsubadd_ph() {
+    const fn test_mm_fmsubadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21882,7 +21882,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_fmsubadd_ph() {
+    const fn test_mm_mask_fmsubadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21892,7 +21892,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsubadd_ph() {
+    const fn test_mm_mask3_fmsubadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21902,7 +21902,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsubadd_ph() {
+    const fn test_mm_maskz_fmsubadd_ph() {
         let a = _mm_set1_ph(1.0);
         let b = _mm_set1_ph(2.0);
         let c = _mm_set1_ph(3.0);
@@ -21912,7 +21912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_fmsubadd_ph() {
+    const fn test_mm256_fmsubadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21924,7 +21924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsubadd_ph() {
+    const fn test_mm256_mask_fmsubadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21936,7 +21936,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsubadd_ph() {
+    const fn test_mm256_mask3_fmsubadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21948,7 +21948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsubadd_ph() {
+    const fn test_mm256_maskz_fmsubadd_ph() {
         let a = _mm256_set1_ph(1.0);
         let b = _mm256_set1_ph(2.0);
         let c = _mm256_set1_ph(3.0);
@@ -21960,7 +21960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_fmsubadd_ph() {
+    const fn test_mm512_fmsubadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21973,7 +21973,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_fmsubadd_ph() {
+    const fn test_mm512_mask_fmsubadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21986,7 +21986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask3_fmsubadd_ph() {
+    const fn test_mm512_mask3_fmsubadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -21999,7 +21999,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_maskz_fmsubadd_ph() {
+    const fn test_mm512_maskz_fmsubadd_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -22012,7 +22012,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fmsubadd_round_ph() {
+    fn test_mm512_fmsubadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -22026,7 +22026,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fmsubadd_round_ph() {
+    fn test_mm512_mask_fmsubadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -22044,7 +22044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask3_fmsubadd_round_ph() {
+    fn test_mm512_mask3_fmsubadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -22062,7 +22062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_fmsubadd_round_ph() {
+    fn test_mm512_maskz_fmsubadd_round_ph() {
         let a = _mm512_set1_ph(1.0);
         let b = _mm512_set1_ph(2.0);
         let c = _mm512_set1_ph(3.0);
@@ -22080,7 +22080,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_rcp_ph() {
+    fn test_mm_rcp_ph() {
         let a = _mm_set1_ph(2.0);
         let r = _mm_rcp_ph(a);
         let e = _mm_set1_ph(0.5);
@@ -22088,7 +22088,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_rcp_ph() {
+    fn test_mm_mask_rcp_ph() {
         let a = _mm_set1_ph(2.0);
         let src = _mm_set1_ph(1.0);
         let r = _mm_mask_rcp_ph(src, 0b01010101, a);
@@ -22097,7 +22097,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_rcp_ph() {
+    fn test_mm_maskz_rcp_ph() {
         let a = _mm_set1_ph(2.0);
         let r = _mm_maskz_rcp_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5);
@@ -22105,7 +22105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_rcp_ph() {
+    fn test_mm256_rcp_ph() {
         let a = _mm256_set1_ph(2.0);
         let r = _mm256_rcp_ph(a);
         let e = _mm256_set1_ph(0.5);
@@ -22113,7 +22113,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_rcp_ph() {
+    fn test_mm256_mask_rcp_ph() {
         let a = _mm256_set1_ph(2.0);
         let src = _mm256_set1_ph(1.0);
         let r = _mm256_mask_rcp_ph(src, 0b0101010101010101, a);
@@ -22124,7 +22124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_rcp_ph() {
+    fn test_mm256_maskz_rcp_ph() {
         let a = _mm256_set1_ph(2.0);
         let r = _mm256_maskz_rcp_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -22134,7 +22134,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_rcp_ph() {
+    fn test_mm512_rcp_ph() {
         let a = _mm512_set1_ph(2.0);
         let r = _mm512_rcp_ph(a);
         let e = _mm512_set1_ph(0.5);
@@ -22142,7 +22142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_rcp_ph() {
+    fn test_mm512_mask_rcp_ph() {
         let a = _mm512_set1_ph(2.0);
         let src = _mm512_set1_ph(1.0);
         let r = _mm512_mask_rcp_ph(src, 0b01010101010101010101010101010101, a);
@@ -22154,7 +22154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_rcp_ph() {
+    fn test_mm512_maskz_rcp_ph() {
         let a = _mm512_set1_ph(2.0);
         let r = _mm512_maskz_rcp_ph(0b01010101010101010101010101010101, a);
         let e = _mm512_set_ph(
@@ -22165,7 +22165,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_rcp_sh() {
+    fn test_mm_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_rcp_sh(a, b);
@@ -22174,7 +22174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_rcp_sh() {
+    fn test_mm_mask_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22187,7 +22187,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_rcp_sh() {
+    fn test_mm_maskz_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_maskz_rcp_sh(0, a, b);
@@ -22199,7 +22199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_rsqrt_ph() {
+    fn test_mm_rsqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let r = _mm_rsqrt_ph(a);
         let e = _mm_set1_ph(0.5);
@@ -22207,7 +22207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_rsqrt_ph() {
+    fn test_mm_mask_rsqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let src = _mm_set1_ph(1.0);
         let r = _mm_mask_rsqrt_ph(src, 0b01010101, a);
@@ -22216,7 +22216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_rsqrt_ph() {
+    fn test_mm_maskz_rsqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let r = _mm_maskz_rsqrt_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5);
@@ -22224,7 +22224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_rsqrt_ph() {
+    fn test_mm256_rsqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let r = _mm256_rsqrt_ph(a);
         let e = _mm256_set1_ph(0.5);
@@ -22232,7 +22232,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_rsqrt_ph() {
+    fn test_mm256_mask_rsqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let src = _mm256_set1_ph(1.0);
         let r = _mm256_mask_rsqrt_ph(src, 0b0101010101010101, a);
@@ -22243,7 +22243,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_rsqrt_ph() {
+    fn test_mm256_maskz_rsqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let r = _mm256_maskz_rsqrt_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -22253,7 +22253,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_rsqrt_ph() {
+    fn test_mm512_rsqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_rsqrt_ph(a);
         let e = _mm512_set1_ph(0.5);
@@ -22261,7 +22261,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_rsqrt_ph() {
+    fn test_mm512_mask_rsqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let src = _mm512_set1_ph(1.0);
         let r = _mm512_mask_rsqrt_ph(src, 0b01010101010101010101010101010101, a);
@@ -22273,7 +22273,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_rsqrt_ph() {
+    fn test_mm512_maskz_rsqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_maskz_rsqrt_ph(0b01010101010101010101010101010101, a);
         let e = _mm512_set_ph(
@@ -22284,7 +22284,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_rsqrt_sh() {
+    fn test_mm_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r = _mm_rsqrt_sh(a, b);
@@ -22293,7 +22293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_rsqrt_sh() {
+    fn test_mm_mask_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22306,7 +22306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_rsqrt_sh() {
+    fn test_mm_maskz_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r = _mm_maskz_rsqrt_sh(0, a, b);
@@ -22318,7 +22318,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_sqrt_ph() {
+    fn test_mm_sqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let r = _mm_sqrt_ph(a);
         let e = _mm_set1_ph(2.0);
@@ -22326,7 +22326,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_sqrt_ph() {
+    fn test_mm_mask_sqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let src = _mm_set1_ph(1.0);
         let r = _mm_mask_sqrt_ph(src, 0b01010101, a);
@@ -22335,7 +22335,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_sqrt_ph() {
+    fn test_mm_maskz_sqrt_ph() {
         let a = _mm_set1_ph(4.0);
         let r = _mm_maskz_sqrt_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2.0, 0.0, 2.0, 0.0, 2.0, 0.0, 2.0);
@@ -22343,7 +22343,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_sqrt_ph() {
+    fn test_mm256_sqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let r = _mm256_sqrt_ph(a);
         let e = _mm256_set1_ph(2.0);
@@ -22351,7 +22351,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_sqrt_ph() {
+    fn test_mm256_mask_sqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let src = _mm256_set1_ph(1.0);
         let r = _mm256_mask_sqrt_ph(src, 0b0101010101010101, a);
@@ -22362,7 +22362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_sqrt_ph() {
+    fn test_mm256_maskz_sqrt_ph() {
         let a = _mm256_set1_ph(4.0);
         let r = _mm256_maskz_sqrt_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -22372,7 +22372,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_sqrt_ph() {
+    fn test_mm512_sqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_sqrt_ph(a);
         let e = _mm512_set1_ph(2.0);
@@ -22380,7 +22380,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_sqrt_ph() {
+    fn test_mm512_mask_sqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let src = _mm512_set1_ph(1.0);
         let r = _mm512_mask_sqrt_ph(src, 0b01010101010101010101010101010101, a);
@@ -22392,7 +22392,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_sqrt_ph() {
+    fn test_mm512_maskz_sqrt_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_maskz_sqrt_ph(0b01010101010101010101010101010101, a);
         let e = _mm512_set_ph(
@@ -22403,7 +22403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_sqrt_round_ph() {
+    fn test_mm512_sqrt_round_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_sqrt_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set1_ph(2.0);
@@ -22411,7 +22411,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_sqrt_round_ph() {
+    fn test_mm512_mask_sqrt_round_ph() {
         let a = _mm512_set1_ph(4.0);
         let src = _mm512_set1_ph(1.0);
         let r = _mm512_mask_sqrt_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -22427,7 +22427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_sqrt_round_ph() {
+    fn test_mm512_maskz_sqrt_round_ph() {
         let a = _mm512_set1_ph(4.0);
         let r = _mm512_maskz_sqrt_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101010101010101010101010101,
@@ -22441,7 +22441,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_sqrt_sh() {
+    fn test_mm_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r = _mm_sqrt_sh(a, b);
@@ -22450,7 +22450,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_sqrt_sh() {
+    fn test_mm_mask_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22463,7 +22463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_sqrt_sh() {
+    fn test_mm_maskz_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r = _mm_maskz_sqrt_sh(0, a, b);
@@ -22475,7 +22475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_sqrt_round_sh() {
+    fn test_mm_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r = _mm_sqrt_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -22484,7 +22484,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_sqrt_round_sh() {
+    fn test_mm_mask_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22501,7 +22501,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_sqrt_round_sh() {
+    fn test_mm_maskz_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
         let r =
@@ -22515,7 +22515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_max_ph() {
+    fn test_mm_max_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let r = _mm_max_ph(a, b);
@@ -22524,7 +22524,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_max_ph() {
+    fn test_mm_mask_max_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let src = _mm_set1_ph(3.0);
@@ -22534,7 +22534,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_max_ph() {
+    fn test_mm_maskz_max_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let r = _mm_maskz_max_ph(0b01010101, a, b);
@@ -22543,7 +22543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_max_ph() {
+    fn test_mm256_max_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let r = _mm256_max_ph(a, b);
@@ -22552,7 +22552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_max_ph() {
+    fn test_mm256_mask_max_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let src = _mm256_set1_ph(3.0);
@@ -22564,7 +22564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_max_ph() {
+    fn test_mm256_maskz_max_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let r = _mm256_maskz_max_ph(0b0101010101010101, a, b);
@@ -22575,7 +22575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_max_ph() {
+    fn test_mm512_max_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_max_ph(a, b);
@@ -22584,7 +22584,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_max_ph() {
+    fn test_mm512_mask_max_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let src = _mm512_set1_ph(3.0);
@@ -22597,7 +22597,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_max_ph() {
+    fn test_mm512_maskz_max_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_maskz_max_ph(0b01010101010101010101010101010101, a, b);
@@ -22609,7 +22609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_max_round_ph() {
+    fn test_mm512_max_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_max_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -22618,7 +22618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_max_round_ph() {
+    fn test_mm512_mask_max_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let src = _mm512_set1_ph(3.0);
@@ -22636,7 +22636,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_max_round_ph() {
+    fn test_mm512_maskz_max_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_maskz_max_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -22652,7 +22652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_max_sh() {
+    fn test_mm_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_max_sh(a, b);
@@ -22661,7 +22661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_max_sh() {
+    fn test_mm_mask_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22674,7 +22674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_max_sh() {
+    fn test_mm_maskz_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_maskz_max_sh(0, a, b);
@@ -22686,7 +22686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_max_round_sh() {
+    fn test_mm_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_max_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -22695,7 +22695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_max_round_sh() {
+    fn test_mm_mask_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22712,7 +22712,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_max_round_sh() {
+    fn test_mm_maskz_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r =
@@ -22726,7 +22726,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_min_ph() {
+    fn test_mm_min_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let r = _mm_min_ph(a, b);
@@ -22735,7 +22735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_min_ph() {
+    fn test_mm_mask_min_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let src = _mm_set1_ph(3.0);
@@ -22745,7 +22745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_min_ph() {
+    fn test_mm_maskz_min_ph() {
         let a = _mm_set1_ph(2.0);
         let b = _mm_set1_ph(1.0);
         let r = _mm_maskz_min_ph(0b01010101, a, b);
@@ -22754,7 +22754,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_min_ph() {
+    fn test_mm256_min_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let r = _mm256_min_ph(a, b);
@@ -22763,7 +22763,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_min_ph() {
+    fn test_mm256_mask_min_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let src = _mm256_set1_ph(3.0);
@@ -22775,7 +22775,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_min_ph() {
+    fn test_mm256_maskz_min_ph() {
         let a = _mm256_set1_ph(2.0);
         let b = _mm256_set1_ph(1.0);
         let r = _mm256_maskz_min_ph(0b0101010101010101, a, b);
@@ -22786,7 +22786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_min_ph() {
+    fn test_mm512_min_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_min_ph(a, b);
@@ -22795,7 +22795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_min_ph() {
+    fn test_mm512_mask_min_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let src = _mm512_set1_ph(3.0);
@@ -22808,7 +22808,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_min_ph() {
+    fn test_mm512_maskz_min_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_maskz_min_ph(0b01010101010101010101010101010101, a, b);
@@ -22820,7 +22820,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_min_round_ph() {
+    fn test_mm512_min_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_min_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -22829,7 +22829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_min_round_ph() {
+    fn test_mm512_mask_min_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let src = _mm512_set1_ph(3.0);
@@ -22847,7 +22847,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_min_round_ph() {
+    fn test_mm512_maskz_min_round_ph() {
         let a = _mm512_set1_ph(2.0);
         let b = _mm512_set1_ph(1.0);
         let r = _mm512_maskz_min_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -22863,7 +22863,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_min_sh() {
+    fn test_mm_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_min_sh(a, b);
@@ -22872,7 +22872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_min_sh() {
+    fn test_mm_mask_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22885,7 +22885,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_min_sh() {
+    fn test_mm_maskz_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_maskz_min_sh(0, a, b);
@@ -22897,7 +22897,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_min_round_sh() {
+    fn test_mm_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r = _mm_min_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -22906,7 +22906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_min_round_sh() {
+    fn test_mm_mask_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let src = _mm_setr_ph(3.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0);
@@ -22923,7 +22923,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_min_round_sh() {
+    fn test_mm_maskz_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
         let r =
@@ -22937,7 +22937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getexp_ph() {
+    fn test_mm_getexp_ph() {
         let a = _mm_set1_ph(3.0);
         let r = _mm_getexp_ph(a);
         let e = _mm_set1_ph(1.0);
@@ -22945,7 +22945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getexp_ph() {
+    fn test_mm_mask_getexp_ph() {
         let a = _mm_set1_ph(3.0);
         let src = _mm_set1_ph(4.0);
         let r = _mm_mask_getexp_ph(src, 0b01010101, a);
@@ -22954,7 +22954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getexp_ph() {
+    fn test_mm_maskz_getexp_ph() {
         let a = _mm_set1_ph(3.0);
         let r = _mm_maskz_getexp_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
@@ -22962,7 +22962,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_getexp_ph() {
+    fn test_mm256_getexp_ph() {
         let a = _mm256_set1_ph(3.0);
         let r = _mm256_getexp_ph(a);
         let e = _mm256_set1_ph(1.0);
@@ -22970,7 +22970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_getexp_ph() {
+    fn test_mm256_mask_getexp_ph() {
         let a = _mm256_set1_ph(3.0);
         let src = _mm256_set1_ph(4.0);
         let r = _mm256_mask_getexp_ph(src, 0b0101010101010101, a);
@@ -22981,7 +22981,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_getexp_ph() {
+    fn test_mm256_maskz_getexp_ph() {
         let a = _mm256_set1_ph(3.0);
         let r = _mm256_maskz_getexp_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -22991,7 +22991,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_getexp_ph() {
+    fn test_mm512_getexp_ph() {
         let a = _mm512_set1_ph(3.0);
         let r = _mm512_getexp_ph(a);
         let e = _mm512_set1_ph(1.0);
@@ -22999,7 +22999,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_getexp_ph() {
+    fn test_mm512_mask_getexp_ph() {
         let a = _mm512_set1_ph(3.0);
         let src = _mm512_set1_ph(4.0);
         let r = _mm512_mask_getexp_ph(src, 0b01010101010101010101010101010101, a);
@@ -23011,7 +23011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_getexp_ph() {
+    fn test_mm512_maskz_getexp_ph() {
         let a = _mm512_set1_ph(3.0);
         let r = _mm512_maskz_getexp_ph(0b01010101010101010101010101010101, a);
         let e = _mm512_set_ph(
@@ -23022,7 +23022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_getexp_round_ph() {
+    fn test_mm512_getexp_round_ph() {
         let a = _mm512_set1_ph(3.0);
         let r = _mm512_getexp_round_ph::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set1_ph(1.0);
@@ -23030,7 +23030,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_getexp_round_ph() {
+    fn test_mm512_mask_getexp_round_ph() {
         let a = _mm512_set1_ph(3.0);
         let src = _mm512_set1_ph(4.0);
         let r = _mm512_mask_getexp_round_ph::<_MM_FROUND_NO_EXC>(
@@ -23046,7 +23046,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_getexp_round_ph() {
+    fn test_mm512_maskz_getexp_round_ph() {
         let a = _mm512_set1_ph(3.0);
         let r = _mm512_maskz_getexp_round_ph::<_MM_FROUND_NO_EXC>(
             0b01010101010101010101010101010101,
@@ -23060,7 +23060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getexp_sh() {
+    fn test_mm_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_getexp_sh(a, b);
@@ -23069,7 +23069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getexp_sh() {
+    fn test_mm_mask_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(4.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23082,7 +23082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getexp_sh() {
+    fn test_mm_maskz_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_getexp_sh(0, a, b);
@@ -23094,7 +23094,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getexp_round_sh() {
+    fn test_mm_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_getexp_round_sh::<_MM_FROUND_NO_EXC>(a, b);
@@ -23103,7 +23103,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getexp_round_sh() {
+    fn test_mm_mask_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(4.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23116,7 +23116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getexp_round_sh() {
+    fn test_mm_maskz_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_getexp_round_sh::<_MM_FROUND_NO_EXC>(0, a, b);
@@ -23128,7 +23128,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getmant_ph() {
+    fn test_mm_getmant_ph() {
         let a = _mm_set1_ph(10.0);
         let r = _mm_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm_set1_ph(1.25);
@@ -23136,7 +23136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getmant_ph() {
+    fn test_mm_mask_getmant_ph() {
         let a = _mm_set1_ph(10.0);
         let src = _mm_set1_ph(20.0);
         let r = _mm_mask_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(src, 0b01010101, a);
@@ -23145,7 +23145,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getmant_ph() {
+    fn test_mm_maskz_getmant_ph() {
         let a = _mm_set1_ph(10.0);
         let r = _mm_maskz_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(0b01010101, a);
         let e = _mm_set_ph(0.0, 1.25, 0.0, 1.25, 0.0, 1.25, 0.0, 1.25);
@@ -23153,7 +23153,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_getmant_ph() {
+    fn test_mm256_getmant_ph() {
         let a = _mm256_set1_ph(10.0);
         let r = _mm256_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm256_set1_ph(1.25);
@@ -23161,7 +23161,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_getmant_ph() {
+    fn test_mm256_mask_getmant_ph() {
         let a = _mm256_set1_ph(10.0);
         let src = _mm256_set1_ph(20.0);
         let r = _mm256_mask_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(
@@ -23177,7 +23177,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_getmant_ph() {
+    fn test_mm256_maskz_getmant_ph() {
         let a = _mm256_set1_ph(10.0);
         let r = _mm256_maskz_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(
             0b0101010101010101,
@@ -23190,7 +23190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_getmant_ph() {
+    fn test_mm512_getmant_ph() {
         let a = _mm512_set1_ph(10.0);
         let r = _mm512_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a);
         let e = _mm512_set1_ph(1.25);
@@ -23198,7 +23198,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_getmant_ph() {
+    fn test_mm512_mask_getmant_ph() {
         let a = _mm512_set1_ph(10.0);
         let src = _mm512_set1_ph(20.0);
         let r = _mm512_mask_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(
@@ -23215,7 +23215,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_getmant_ph() {
+    fn test_mm512_maskz_getmant_ph() {
         let a = _mm512_set1_ph(10.0);
         let r = _mm512_maskz_getmant_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(
             0b01010101010101010101010101010101,
@@ -23229,7 +23229,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_getmant_round_ph() {
+    fn test_mm512_getmant_round_ph() {
         let a = _mm512_set1_ph(10.0);
         let r =
             _mm512_getmant_round_ph::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN, _MM_FROUND_NO_EXC>(
@@ -23240,7 +23240,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_getmant_round_ph() {
+    fn test_mm512_mask_getmant_round_ph() {
         let a = _mm512_set1_ph(10.0);
         let src = _mm512_set1_ph(20.0);
         let r = _mm512_mask_getmant_round_ph::<
@@ -23257,7 +23257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_getmant_round_ph() {
+    fn test_mm512_maskz_getmant_round_ph() {
         let a = _mm512_set1_ph(10.0);
         let r = _mm512_maskz_getmant_round_ph::<
             _MM_MANT_NORM_P75_1P5,
@@ -23272,7 +23272,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getmant_sh() {
+    fn test_mm_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_getmant_sh::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(a, b);
@@ -23281,7 +23281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getmant_sh() {
+    fn test_mm_mask_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(20.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23294,7 +23294,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getmant_sh() {
+    fn test_mm_maskz_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_getmant_sh::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN>(0, a, b);
@@ -23306,7 +23306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_getmant_round_sh() {
+    fn test_mm_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_getmant_round_sh::<_MM_MANT_NORM_P75_1P5, _MM_MANT_SIGN_NAN, _MM_FROUND_NO_EXC>(
@@ -23317,7 +23317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_getmant_round_sh() {
+    fn test_mm_mask_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(20.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23338,7 +23338,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_getmant_round_sh() {
+    fn test_mm_maskz_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_getmant_round_sh::<
@@ -23358,7 +23358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_roundscale_ph() {
+    fn test_mm_roundscale_ph() {
         let a = _mm_set1_ph(1.1);
         let r = _mm_roundscale_ph::<0>(a);
         let e = _mm_set1_ph(1.0);
@@ -23366,7 +23366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_roundscale_ph() {
+    fn test_mm_mask_roundscale_ph() {
         let a = _mm_set1_ph(1.1);
         let src = _mm_set1_ph(2.0);
         let r = _mm_mask_roundscale_ph::<0>(src, 0b01010101, a);
@@ -23375,7 +23375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_roundscale_ph() {
+    fn test_mm_maskz_roundscale_ph() {
         let a = _mm_set1_ph(1.1);
         let r = _mm_maskz_roundscale_ph::<0>(0b01010101, a);
         let e = _mm_set_ph(0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
@@ -23383,7 +23383,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_roundscale_ph() {
+    fn test_mm256_roundscale_ph() {
         let a = _mm256_set1_ph(1.1);
         let r = _mm256_roundscale_ph::<0>(a);
         let e = _mm256_set1_ph(1.0);
@@ -23391,7 +23391,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_roundscale_ph() {
+    fn test_mm256_mask_roundscale_ph() {
         let a = _mm256_set1_ph(1.1);
         let src = _mm256_set1_ph(2.0);
         let r = _mm256_mask_roundscale_ph::<0>(src, 0b0101010101010101, a);
@@ -23402,7 +23402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_roundscale_ph() {
+    fn test_mm256_maskz_roundscale_ph() {
         let a = _mm256_set1_ph(1.1);
         let r = _mm256_maskz_roundscale_ph::<0>(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -23412,7 +23412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_roundscale_ph() {
+    fn test_mm512_roundscale_ph() {
         let a = _mm512_set1_ph(1.1);
         let r = _mm512_roundscale_ph::<0>(a);
         let e = _mm512_set1_ph(1.0);
@@ -23420,7 +23420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_roundscale_ph() {
+    fn test_mm512_mask_roundscale_ph() {
         let a = _mm512_set1_ph(1.1);
         let src = _mm512_set1_ph(2.0);
         let r = _mm512_mask_roundscale_ph::<0>(src, 0b01010101010101010101010101010101, a);
@@ -23432,7 +23432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_roundscale_ph() {
+    fn test_mm512_maskz_roundscale_ph() {
         let a = _mm512_set1_ph(1.1);
         let r = _mm512_maskz_roundscale_ph::<0>(0b01010101010101010101010101010101, a);
         let e = _mm512_set_ph(
@@ -23443,7 +23443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_roundscale_round_ph() {
+    fn test_mm512_roundscale_round_ph() {
         let a = _mm512_set1_ph(1.1);
         let r = _mm512_roundscale_round_ph::<0, _MM_FROUND_NO_EXC>(a);
         let e = _mm512_set1_ph(1.0);
@@ -23451,7 +23451,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_roundscale_round_ph() {
+    fn test_mm512_mask_roundscale_round_ph() {
         let a = _mm512_set1_ph(1.1);
         let src = _mm512_set1_ph(2.0);
         let r = _mm512_mask_roundscale_round_ph::<0, _MM_FROUND_NO_EXC>(
@@ -23467,7 +23467,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_roundscale_round_ph() {
+    fn test_mm512_maskz_roundscale_round_ph() {
         let a = _mm512_set1_ph(1.1);
         let r = _mm512_maskz_roundscale_round_ph::<0, _MM_FROUND_NO_EXC>(
             0b01010101010101010101010101010101,
@@ -23481,7 +23481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_roundscale_sh() {
+    fn test_mm_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_roundscale_sh::<0>(a, b);
@@ -23490,7 +23490,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_roundscale_sh() {
+    fn test_mm_mask_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23503,7 +23503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_roundscale_sh() {
+    fn test_mm_maskz_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_roundscale_sh::<0>(0, a, b);
@@ -23515,7 +23515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_roundscale_round_sh() {
+    fn test_mm_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_roundscale_round_sh::<0, _MM_FROUND_NO_EXC>(a, b);
@@ -23524,7 +23524,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_roundscale_round_sh() {
+    fn test_mm_mask_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(3.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23537,7 +23537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_roundscale_round_sh() {
+    fn test_mm_maskz_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_roundscale_round_sh::<0, _MM_FROUND_NO_EXC>(0, a, b);
@@ -23549,7 +23549,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_scalef_ph() {
+    fn test_mm_scalef_ph() {
         let a = _mm_set1_ph(1.);
         let b = _mm_set1_ph(3.);
         let r = _mm_scalef_ph(a, b);
@@ -23558,7 +23558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_scalef_ph() {
+    fn test_mm_mask_scalef_ph() {
         let a = _mm_set1_ph(1.);
         let b = _mm_set1_ph(3.);
         let src = _mm_set1_ph(2.);
@@ -23568,7 +23568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_scalef_ph() {
+    fn test_mm_maskz_scalef_ph() {
         let a = _mm_set1_ph(1.);
         let b = _mm_set1_ph(3.);
         let r = _mm_maskz_scalef_ph(0b01010101, a, b);
@@ -23577,7 +23577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_scalef_ph() {
+    fn test_mm256_scalef_ph() {
         let a = _mm256_set1_ph(1.);
         let b = _mm256_set1_ph(3.);
         let r = _mm256_scalef_ph(a, b);
@@ -23586,7 +23586,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_scalef_ph() {
+    fn test_mm256_mask_scalef_ph() {
         let a = _mm256_set1_ph(1.);
         let b = _mm256_set1_ph(3.);
         let src = _mm256_set1_ph(2.);
@@ -23598,7 +23598,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_scalef_ph() {
+    fn test_mm256_maskz_scalef_ph() {
         let a = _mm256_set1_ph(1.);
         let b = _mm256_set1_ph(3.);
         let r = _mm256_maskz_scalef_ph(0b0101010101010101, a, b);
@@ -23609,7 +23609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_scalef_ph() {
+    fn test_mm512_scalef_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let r = _mm512_scalef_ph(a, b);
@@ -23618,7 +23618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_scalef_ph() {
+    fn test_mm512_mask_scalef_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let src = _mm512_set1_ph(2.);
@@ -23631,7 +23631,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_scalef_ph() {
+    fn test_mm512_maskz_scalef_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let r = _mm512_maskz_scalef_ph(0b01010101010101010101010101010101, a, b);
@@ -23643,7 +23643,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_scalef_round_ph() {
+    fn test_mm512_scalef_round_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let r = _mm512_scalef_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -23652,7 +23652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_scalef_round_ph() {
+    fn test_mm512_mask_scalef_round_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let src = _mm512_set1_ph(2.);
@@ -23670,7 +23670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_scalef_round_ph() {
+    fn test_mm512_maskz_scalef_round_ph() {
         let a = _mm512_set1_ph(1.);
         let b = _mm512_set1_ph(3.);
         let r = _mm512_maskz_scalef_round_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -23686,7 +23686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_scalef_sh() {
+    fn test_mm_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_scalef_sh(a, b);
@@ -23695,7 +23695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_scalef_sh() {
+    fn test_mm_mask_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(2.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23708,7 +23708,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_scalef_sh() {
+    fn test_mm_maskz_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_scalef_sh(0, a, b);
@@ -23720,7 +23720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_scalef_round_sh() {
+    fn test_mm_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_scalef_round_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -23729,7 +23729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_scalef_round_sh() {
+    fn test_mm_mask_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(2.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23746,7 +23746,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_scalef_round_sh() {
+    fn test_mm_maskz_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
         let r =
@@ -23760,7 +23760,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_reduce_ph() {
+    fn test_mm_reduce_ph() {
         let a = _mm_set1_ph(1.25);
         let r = _mm_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm_set1_ph(0.25);
@@ -23768,7 +23768,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_reduce_ph() {
+    fn test_mm_mask_reduce_ph() {
         let a = _mm_set1_ph(1.25);
         let src = _mm_set1_ph(2.0);
         let r = _mm_mask_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b01010101, a);
@@ -23777,7 +23777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_reduce_ph() {
+    fn test_mm_maskz_reduce_ph() {
         let a = _mm_set1_ph(1.25);
         let r = _mm_maskz_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(0b01010101, a);
         let e = _mm_set_ph(0.0, 0.25, 0.0, 0.25, 0.0, 0.25, 0.0, 0.25);
@@ -23785,7 +23785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_reduce_ph() {
+    fn test_mm256_reduce_ph() {
         let a = _mm256_set1_ph(1.25);
         let r = _mm256_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm256_set1_ph(0.25);
@@ -23793,7 +23793,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_reduce_ph() {
+    fn test_mm256_mask_reduce_ph() {
         let a = _mm256_set1_ph(1.25);
         let src = _mm256_set1_ph(2.0);
         let r = _mm256_mask_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(src, 0b0101010101010101, a);
@@ -23804,7 +23804,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_reduce_ph() {
+    fn test_mm256_maskz_reduce_ph() {
         let a = _mm256_set1_ph(1.25);
         let r = _mm256_maskz_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -23814,7 +23814,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_reduce_ph() {
+    fn test_mm512_reduce_ph() {
         let a = _mm512_set1_ph(1.25);
         let r = _mm512_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(a);
         let e = _mm512_set1_ph(0.25);
@@ -23822,7 +23822,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_reduce_ph() {
+    fn test_mm512_mask_reduce_ph() {
         let a = _mm512_set1_ph(1.25);
         let src = _mm512_set1_ph(2.0);
         let r = _mm512_mask_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(
@@ -23838,7 +23838,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_reduce_ph() {
+    fn test_mm512_maskz_reduce_ph() {
         let a = _mm512_set1_ph(1.25);
         let r = _mm512_maskz_reduce_ph::<{ 16 | _MM_FROUND_TO_ZERO }>(
             0b01010101010101010101010101010101,
@@ -23852,7 +23852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_reduce_round_ph() {
+    fn test_mm512_reduce_round_ph() {
         let a = _mm512_set1_ph(1.25);
         let r = _mm512_reduce_round_ph::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(a);
         let e = _mm512_set1_ph(0.25);
@@ -23860,7 +23860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_reduce_round_ph() {
+    fn test_mm512_mask_reduce_round_ph() {
         let a = _mm512_set1_ph(1.25);
         let src = _mm512_set1_ph(2.0);
         let r = _mm512_mask_reduce_round_ph::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(
@@ -23876,7 +23876,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_reduce_round_ph() {
+    fn test_mm512_maskz_reduce_round_ph() {
         let a = _mm512_set1_ph(1.25);
         let r = _mm512_maskz_reduce_round_ph::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(
             0b01010101010101010101010101010101,
@@ -23890,7 +23890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_reduce_sh() {
+    fn test_mm_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_reduce_sh::<{ 16 | _MM_FROUND_TO_ZERO }>(a, b);
@@ -23899,7 +23899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_reduce_sh() {
+    fn test_mm_mask_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(2.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23912,7 +23912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_reduce_sh() {
+    fn test_mm_maskz_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_maskz_reduce_sh::<{ 16 | _MM_FROUND_TO_ZERO }>(0, a, b);
@@ -23924,7 +23924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_reduce_round_sh() {
+    fn test_mm_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let r = _mm_reduce_round_sh::<{ 16 | _MM_FROUND_TO_ZERO }, _MM_FROUND_NO_EXC>(a, b);
@@ -23933,7 +23933,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_reduce_round_sh() {
+    fn test_mm_mask_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let src = _mm_setr_ph(2.0, 30., 31., 32., 33., 34., 35., 36.);
@@ -23950,7 +23950,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_reduce_round_sh() {
+    fn test_mm_maskz_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
         let r =
@@ -23964,56 +23964,56 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_reduce_add_ph() {
+    const fn test_mm_reduce_add_ph() {
         let a = _mm_set1_ph(2.0);
         let r = _mm_reduce_add_ph(a);
         assert_eq!(r, 16.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_reduce_add_ph() {
+    const fn test_mm256_reduce_add_ph() {
         let a = _mm256_set1_ph(2.0);
         let r = _mm256_reduce_add_ph(a);
         assert_eq!(r, 32.0);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_reduce_add_ph() {
+    const fn test_mm512_reduce_add_ph() {
         let a = _mm512_set1_ph(2.0);
         let r = _mm512_reduce_add_ph(a);
         assert_eq!(r, 64.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_reduce_mul_ph() {
+    const fn test_mm_reduce_mul_ph() {
         let a = _mm_set1_ph(2.0);
         let r = _mm_reduce_mul_ph(a);
         assert_eq!(r, 256.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_reduce_mul_ph() {
+    const fn test_mm256_reduce_mul_ph() {
         let a = _mm256_set1_ph(2.0);
         let r = _mm256_reduce_mul_ph(a);
         assert_eq!(r, 65536.0);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_reduce_mul_ph() {
+    const fn test_mm512_reduce_mul_ph() {
         let a = _mm512_set1_ph(2.0);
         let r = _mm512_reduce_mul_ph(a);
         assert_eq!(r, 16777216.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_reduce_max_ph() {
+    fn test_mm_reduce_max_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_reduce_max_ph(a);
         assert_eq!(r, 8.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_reduce_max_ph() {
+    fn test_mm256_reduce_max_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -24022,7 +24022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_reduce_max_ph() {
+    fn test_mm512_reduce_max_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -24033,14 +24033,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_reduce_min_ph() {
+    fn test_mm_reduce_min_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_reduce_min_ph(a);
         assert_eq!(r, 1.0);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_reduce_min_ph() {
+    fn test_mm256_reduce_min_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -24049,7 +24049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_reduce_min_ph() {
+    fn test_mm512_reduce_min_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -24060,7 +24060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_fpclass_ph_mask() {
+    fn test_mm_fpclass_ph_mask() {
         let a = _mm_set_ph(
             1.,
             f16::INFINITY,
@@ -24076,7 +24076,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_fpclass_ph_mask() {
+    fn test_mm_mask_fpclass_ph_mask() {
         let a = _mm_set_ph(
             1.,
             f16::INFINITY,
@@ -24092,7 +24092,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_fpclass_ph_mask() {
+    fn test_mm256_fpclass_ph_mask() {
         let a = _mm256_set_ph(
             1.,
             f16::INFINITY,
@@ -24116,7 +24116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_fpclass_ph_mask() {
+    fn test_mm256_mask_fpclass_ph_mask() {
         let a = _mm256_set_ph(
             1.,
             f16::INFINITY,
@@ -24140,7 +24140,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_fpclass_ph_mask() {
+    fn test_mm512_fpclass_ph_mask() {
         let a = _mm512_set_ph(
             1.,
             f16::INFINITY,
@@ -24180,7 +24180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_fpclass_ph_mask() {
+    fn test_mm512_mask_fpclass_ph_mask() {
         let a = _mm512_set_ph(
             1.,
             f16::INFINITY,
@@ -24220,14 +24220,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_fpclass_sh_mask() {
+    fn test_mm_fpclass_sh_mask() {
         let a = _mm_set_sh(f16::INFINITY);
         let r = _mm_fpclass_sh_mask::<0x18>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_fpclass_sh_mask() {
+    fn test_mm_mask_fpclass_sh_mask() {
         let a = _mm_set_sh(f16::INFINITY);
         let r = _mm_mask_fpclass_sh_mask::<0x18>(0, a);
         assert_eq!(r, 0);
@@ -24236,7 +24236,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm_mask_blend_ph() {
+    const fn test_mm_mask_blend_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_ph(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0);
         let r = _mm_mask_blend_ph(0b01010101, a, b);
@@ -24245,7 +24245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_ph() {
+    const fn test_mm256_mask_blend_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -24262,7 +24262,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_mask_blend_ph() {
+    const fn test_mm512_mask_blend_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -24283,7 +24283,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_permutex2var_ph() {
+    fn test_mm_permutex2var_ph() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_setr_ph(9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let idx = _mm_setr_epi16(0, 2, 4, 6, 8, 10, 12, 14);
@@ -24293,7 +24293,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_permutex2var_ph() {
+    fn test_mm256_permutex2var_ph() {
         let a = _mm256_setr_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -24311,7 +24311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_permutex2var_ph() {
+    fn test_mm512_permutex2var_ph() {
         let a = _mm512_setr_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -24336,7 +24336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_permutexvar_ph() {
+    fn test_mm_permutexvar_ph() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let idx = _mm_set_epi16(0, 2, 4, 6, 1, 3, 5, 7);
         let r = _mm_permutexvar_ph(idx, a);
@@ -24345,7 +24345,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_permutexvar_ph() {
+    fn test_mm256_permutexvar_ph() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -24358,7 +24358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_permutexvar_ph() {
+    fn test_mm512_permutexvar_ph() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -24378,7 +24378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepi16_ph() {
+    fn test_mm_cvtepi16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm_cvtepi16_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24386,7 +24386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi16_ph() {
+    fn test_mm_mask_cvtepi16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepi16_ph(src, 0b01010101, a);
@@ -24395,7 +24395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi16_ph() {
+    fn test_mm_maskz_cvtepi16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm_maskz_cvtepi16_ph(0b01010101, a);
         let e = _mm_set_ph(0., 2., 0., 4., 0., 6., 0., 8.);
@@ -24403,7 +24403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepi16_ph() {
+    fn test_mm256_cvtepi16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_cvtepi16_ph(a);
         let e = _mm256_set_ph(
@@ -24413,7 +24413,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi16_ph() {
+    fn test_mm256_mask_cvtepi16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24426,7 +24426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi16_ph() {
+    fn test_mm256_maskz_cvtepi16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_maskz_cvtepi16_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -24436,7 +24436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtepi16_ph() {
+    fn test_mm512_cvtepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24451,7 +24451,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtepi16_ph() {
+    fn test_mm512_mask_cvtepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24469,7 +24469,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtepi16_ph() {
+    fn test_mm512_maskz_cvtepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24483,7 +24483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundepi16_ph() {
+    fn test_mm512_cvt_roundepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24498,7 +24498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundepi16_ph() {
+    fn test_mm512_mask_cvt_roundepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24520,7 +24520,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundepi16_ph() {
+    fn test_mm512_maskz_cvt_roundepi16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24537,7 +24537,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepu16_ph() {
+    fn test_mm_cvtepu16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm_cvtepu16_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24545,7 +24545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepu16_ph() {
+    fn test_mm_mask_cvtepu16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepu16_ph(src, 0b01010101, a);
@@ -24554,7 +24554,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepu16_ph() {
+    fn test_mm_maskz_cvtepu16_ph() {
         let a = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm_maskz_cvtepu16_ph(0b01010101, a);
         let e = _mm_set_ph(0., 2., 0., 4., 0., 6., 0., 8.);
@@ -24562,7 +24562,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepu16_ph() {
+    fn test_mm256_cvtepu16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_cvtepu16_ph(a);
         let e = _mm256_set_ph(
@@ -24572,7 +24572,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepu16_ph() {
+    fn test_mm256_mask_cvtepu16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24585,7 +24585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepu16_ph() {
+    fn test_mm256_maskz_cvtepu16_ph() {
         let a = _mm256_set_epi16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm256_maskz_cvtepu16_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -24595,7 +24595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtepu16_ph() {
+    fn test_mm512_cvtepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24610,7 +24610,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtepu16_ph() {
+    fn test_mm512_mask_cvtepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24628,7 +24628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtepu16_ph() {
+    fn test_mm512_maskz_cvtepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24642,7 +24642,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundepu16_ph() {
+    fn test_mm512_cvt_roundepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24657,7 +24657,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundepu16_ph() {
+    fn test_mm512_mask_cvt_roundepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24679,7 +24679,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundepu16_ph() {
+    fn test_mm512_maskz_cvt_roundepu16_ph() {
         let a = _mm512_set_epi16(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32,
@@ -24696,7 +24696,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepi32_ph() {
+    fn test_mm_cvtepi32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_cvtepi32_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -24704,7 +24704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi32_ph() {
+    fn test_mm_mask_cvtepi32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepi32_ph(src, 0b0101, a);
@@ -24713,7 +24713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi32_ph() {
+    fn test_mm_maskz_cvtepi32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_cvtepi32_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2., 0.0, 4.);
@@ -24721,7 +24721,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepi32_ph() {
+    fn test_mm256_cvtepi32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_cvtepi32_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24729,7 +24729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi32_ph() {
+    fn test_mm256_mask_cvtepi32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtepi32_ph(src, 0b01010101, a);
@@ -24738,7 +24738,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi32_ph() {
+    fn test_mm256_maskz_cvtepi32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_cvtepi32_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -24746,7 +24746,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtepi32_ph() {
+    fn test_mm512_cvtepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_cvtepi32_ph(a);
         let e = _mm256_set_ph(
@@ -24756,7 +24756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtepi32_ph() {
+    fn test_mm512_mask_cvtepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24769,7 +24769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtepi32_ph() {
+    fn test_mm512_maskz_cvtepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_cvtepi32_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -24779,7 +24779,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvt_roundepi32_ph() {
+    fn test_mm512_cvt_roundepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_cvt_roundepi32_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm256_set_ph(
@@ -24789,7 +24789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvt_roundepi32_ph() {
+    fn test_mm512_mask_cvt_roundepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24806,7 +24806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvt_roundepi32_ph() {
+    fn test_mm512_maskz_cvt_roundepi32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_cvt_roundepi32_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b0101010101010101,
@@ -24819,7 +24819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvti32_sh() {
+    fn test_mm_cvti32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvti32_sh(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24827,7 +24827,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundi32_sh() {
+    fn test_mm_cvt_roundi32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundi32_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24835,7 +24835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepu32_ph() {
+    fn test_mm_cvtepu32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_cvtepu32_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -24843,7 +24843,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepu32_ph() {
+    fn test_mm_mask_cvtepu32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepu32_ph(src, 0b0101, a);
@@ -24852,7 +24852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepu32_ph() {
+    fn test_mm_maskz_cvtepu32_ph() {
         let a = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_cvtepu32_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2., 0.0, 4.);
@@ -24860,7 +24860,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepu32_ph() {
+    fn test_mm256_cvtepu32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_cvtepu32_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24868,7 +24868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepu32_ph() {
+    fn test_mm256_mask_cvtepu32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtepu32_ph(src, 0b01010101, a);
@@ -24877,7 +24877,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepu32_ph() {
+    fn test_mm256_maskz_cvtepu32_ph() {
         let a = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_cvtepu32_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -24885,7 +24885,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtepu32_ph() {
+    fn test_mm512_cvtepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_cvtepu32_ph(a);
         let e = _mm256_set_ph(
@@ -24895,7 +24895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtepu32_ph() {
+    fn test_mm512_mask_cvtepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24908,7 +24908,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtepu32_ph() {
+    fn test_mm512_maskz_cvtepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_cvtepu32_ph(0b0101010101010101, a);
         let e = _mm256_set_ph(
@@ -24918,7 +24918,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvt_roundepu32_ph() {
+    fn test_mm512_cvt_roundepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_cvt_roundepu32_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm256_set_ph(
@@ -24928,7 +24928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvt_roundepu32_ph() {
+    fn test_mm512_mask_cvt_roundepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let src = _mm256_set_ph(
             10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
@@ -24946,7 +24946,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvt_roundepu32_ph() {
+    fn test_mm512_maskz_cvt_roundepu32_ph() {
         let a = _mm512_set_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_cvt_roundepu32_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b0101010101010101,
@@ -24959,7 +24959,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtu32_sh() {
+    fn test_mm_cvtu32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtu32_sh(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24967,7 +24967,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundu32_sh() {
+    fn test_mm_cvt_roundu32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundu32_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -24975,7 +24975,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepi64_ph() {
+    fn test_mm_cvtepi64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepi64_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
@@ -24983,7 +24983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_ph() {
+    fn test_mm_mask_cvtepi64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepi64_ph(src, 0b01, a);
@@ -24992,7 +24992,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_ph() {
+    fn test_mm_maskz_cvtepi64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepi64_ph(0b01, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.);
@@ -25000,7 +25000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepi64_ph() {
+    fn test_mm256_cvtepi64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepi64_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -25008,7 +25008,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi64_ph() {
+    fn test_mm256_mask_cvtepi64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtepi64_ph(src, 0b0101, a);
@@ -25017,7 +25017,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi64_ph() {
+    fn test_mm256_maskz_cvtepi64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepi64_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 4.0);
@@ -25025,7 +25025,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtepi64_ph() {
+    fn test_mm512_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepi64_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25033,7 +25033,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtepi64_ph() {
+    fn test_mm512_mask_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvtepi64_ph(src, 0b01010101, a);
@@ -25042,7 +25042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtepi64_ph() {
+    fn test_mm512_maskz_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepi64_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2., 0.0, 4., 0.0, 6., 0.0, 8.);
@@ -25050,7 +25050,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvt_roundepi64_ph() {
+    fn test_mm512_cvt_roundepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepi64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25058,7 +25058,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundepi64_ph() {
+    fn test_mm512_mask_cvt_roundepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvt_roundepi64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -25069,7 +25069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvt_roundepi64_ph() {
+    fn test_mm512_maskz_cvt_roundepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepi64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101, a,
@@ -25079,7 +25079,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtepu64_ph() {
+    fn test_mm_cvtepu64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_cvtepu64_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
@@ -25087,7 +25087,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtepu64_ph() {
+    fn test_mm_mask_cvtepu64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtepu64_ph(src, 0b01, a);
@@ -25096,7 +25096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepu64_ph() {
+    fn test_mm_maskz_cvtepu64_ph() {
         let a = _mm_set_epi64x(1, 2);
         let r = _mm_maskz_cvtepu64_ph(0b01, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0);
@@ -25104,7 +25104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtepu64_ph() {
+    fn test_mm256_cvtepu64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepu64_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -25112,7 +25112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepu64_ph() {
+    fn test_mm256_mask_cvtepu64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtepu64_ph(src, 0b0101, a);
@@ -25121,7 +25121,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepu64_ph() {
+    fn test_mm256_maskz_cvtepu64_ph() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepu64_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 4.0);
@@ -25129,7 +25129,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtepu64_ph() {
+    fn test_mm512_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepu64_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25137,7 +25137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtepu64_ph() {
+    fn test_mm512_mask_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvtepu64_ph(src, 0b01010101, a);
@@ -25146,7 +25146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtepu64_ph() {
+    fn test_mm512_maskz_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepu64_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2., 0.0, 4., 0.0, 6., 0.0, 8.);
@@ -25154,7 +25154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvt_roundepu64_ph() {
+    fn test_mm512_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepu64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25162,7 +25162,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvt_roundepu64_ph() {
+    fn test_mm512_mask_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvt_roundepu64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -25173,7 +25173,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvt_roundepu64_ph() {
+    fn test_mm512_maskz_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepu64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101, a,
@@ -25183,7 +25183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtxps_ph() {
+    fn test_mm_cvtxps_ph() {
         let a = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtxps_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -25191,7 +25191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtxps_ph() {
+    fn test_mm_mask_cvtxps_ph() {
         let a = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtxps_ph(src, 0b0101, a);
@@ -25200,7 +25200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtxps_ph() {
+    fn test_mm_maskz_cvtxps_ph() {
         let a = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvtxps_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 4.0);
@@ -25208,7 +25208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtxps_ph() {
+    fn test_mm256_cvtxps_ph() {
         let a = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvtxps_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25216,7 +25216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtxps_ph() {
+    fn test_mm256_mask_cvtxps_ph() {
         let a = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtxps_ph(src, 0b01010101, a);
@@ -25225,7 +25225,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtxps_ph() {
+    fn test_mm256_maskz_cvtxps_ph() {
         let a = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvtxps_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -25233,7 +25233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtxps_ph() {
+    fn test_mm512_cvtxps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25245,7 +25245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtxps_ph() {
+    fn test_mm512_mask_cvtxps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25260,7 +25260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtxps_ph() {
+    fn test_mm512_maskz_cvtxps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25272,7 +25272,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtx_roundps_ph() {
+    fn test_mm512_cvtx_roundps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25284,7 +25284,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtx_roundps_ph() {
+    fn test_mm512_mask_cvtx_roundps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25304,7 +25304,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtx_roundps_ph() {
+    fn test_mm512_maskz_cvtx_roundps_ph() {
         let a = _mm512_set_ps(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25319,7 +25319,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtss_sh() {
+    fn test_mm_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtss_sh(a, b);
@@ -25328,7 +25328,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtss_sh() {
+    fn test_mm_mask_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let src = _mm_setr_ph(20., 21., 22., 23., 24., 25., 26., 27.);
@@ -25341,7 +25341,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtss_sh() {
+    fn test_mm_maskz_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvtss_sh(0, a, b);
@@ -25353,7 +25353,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundss_sh() {
+    fn test_mm_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvt_roundss_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -25362,7 +25362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvt_roundss_sh() {
+    fn test_mm_mask_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let src = _mm_setr_ph(20., 21., 22., 23., 24., 25., 26., 27.);
@@ -25379,7 +25379,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvt_roundss_sh() {
+    fn test_mm_maskz_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let r =
@@ -25393,7 +25393,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtpd_ph() {
+    fn test_mm_cvtpd_ph() {
         let a = _mm_set_pd(1.0, 2.0);
         let r = _mm_cvtpd_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
@@ -25401,7 +25401,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_ph() {
+    fn test_mm_mask_cvtpd_ph() {
         let a = _mm_set_pd(1.0, 2.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm_mask_cvtpd_ph(src, 0b01, a);
@@ -25410,7 +25410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_ph() {
+    fn test_mm_maskz_cvtpd_ph() {
         let a = _mm_set_pd(1.0, 2.0);
         let r = _mm_maskz_cvtpd_ph(0b01, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0);
@@ -25418,7 +25418,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtpd_ph() {
+    fn test_mm256_cvtpd_ph() {
         let a = _mm256_set_pd(1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvtpd_ph(a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
@@ -25426,7 +25426,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_ph() {
+    fn test_mm256_mask_cvtpd_ph() {
         let a = _mm256_set_pd(1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm256_mask_cvtpd_ph(src, 0b0101, a);
@@ -25435,7 +25435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_ph() {
+    fn test_mm256_maskz_cvtpd_ph() {
         let a = _mm256_set_pd(1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvtpd_ph(0b0101, a);
         let e = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 4.0);
@@ -25443,7 +25443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvtpd_ph() {
+    fn test_mm512_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtpd_ph(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25451,7 +25451,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvtpd_ph() {
+    fn test_mm512_mask_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvtpd_ph(src, 0b01010101, a);
@@ -25460,7 +25460,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvtpd_ph() {
+    fn test_mm512_maskz_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtpd_ph(0b01010101, a);
         let e = _mm_set_ph(0.0, 2., 0.0, 4., 0.0, 6., 0.0, 8.);
@@ -25468,7 +25468,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_cvt_roundpd_ph() {
+    fn test_mm512_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvt_roundpd_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -25476,7 +25476,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_mask_cvt_roundpd_ph() {
+    fn test_mm512_mask_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let r = _mm512_mask_cvt_roundpd_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -25487,7 +25487,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_ph() {
+    fn test_mm512_maskz_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvt_roundpd_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101, a,
@@ -25497,7 +25497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtsd_sh() {
+    fn test_mm_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let r = _mm_cvtsd_sh(a, b);
@@ -25506,7 +25506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtsd_sh() {
+    fn test_mm_mask_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let src = _mm_setr_ph(20., 21., 22., 23., 24., 25., 26., 27.);
@@ -25519,7 +25519,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsd_sh() {
+    fn test_mm_maskz_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let r = _mm_maskz_cvtsd_sh(0, a, b);
@@ -25531,7 +25531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundsd_sh() {
+    fn test_mm_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let r = _mm_cvt_roundsd_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -25540,7 +25540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvt_roundsd_sh() {
+    fn test_mm_mask_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let src = _mm_setr_ph(20., 21., 22., 23., 24., 25., 26., 27.);
@@ -25557,7 +25557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvt_roundsd_sh() {
+    fn test_mm_maskz_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
         let r =
@@ -25571,7 +25571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epi16() {
+    fn test_mm_cvtph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttph_epi16(a);
         let e = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
@@ -25579,7 +25579,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epi16() {
+    fn test_mm_mask_cvtph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_epi16(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm_mask_cvttph_epi16(src, 0b01010101, a);
@@ -25588,7 +25588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epi16() {
+    fn test_mm_maskz_cvtph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_maskz_cvttph_epi16(0b01010101, a);
         let e = _mm_set_epi16(0, 2, 0, 4, 0, 6, 0, 8);
@@ -25596,7 +25596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epi16() {
+    fn test_mm256_cvtph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25606,7 +25606,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epi16() {
+    fn test_mm256_mask_cvtph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25619,7 +25619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epi16() {
+    fn test_mm256_maskz_cvtph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25629,7 +25629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epi16() {
+    fn test_mm512_cvtph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25644,7 +25644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epi16() {
+    fn test_mm512_mask_cvtph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25663,7 +25663,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epi16() {
+    fn test_mm512_maskz_cvtph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25678,7 +25678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epi16() {
+    fn test_mm512_cvt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25693,7 +25693,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epi16() {
+    fn test_mm512_mask_cvt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25716,7 +25716,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epi16() {
+    fn test_mm512_maskz_cvt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25734,7 +25734,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epu16() {
+    fn test_mm_cvtph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttph_epu16(a);
         let e = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
@@ -25742,7 +25742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epu16() {
+    fn test_mm_mask_cvtph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_epi16(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm_mask_cvttph_epu16(src, 0b01010101, a);
@@ -25751,7 +25751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epu16() {
+    fn test_mm_maskz_cvtph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_maskz_cvttph_epu16(0b01010101, a);
         let e = _mm_set_epi16(0, 2, 0, 4, 0, 6, 0, 8);
@@ -25759,7 +25759,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epu16() {
+    fn test_mm256_cvtph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25769,7 +25769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epu16() {
+    fn test_mm256_mask_cvtph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25782,7 +25782,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epu16() {
+    fn test_mm256_maskz_cvtph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25792,7 +25792,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epu16() {
+    fn test_mm512_cvtph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25807,7 +25807,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epu16() {
+    fn test_mm512_mask_cvtph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25826,7 +25826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epu16() {
+    fn test_mm512_maskz_cvtph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25841,7 +25841,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epu16() {
+    fn test_mm512_cvt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25856,7 +25856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epu16() {
+    fn test_mm512_mask_cvt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25879,7 +25879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epu16() {
+    fn test_mm512_maskz_cvt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25897,7 +25897,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epi16() {
+    fn test_mm_cvttph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttph_epi16(a);
         let e = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
@@ -25905,7 +25905,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epi16() {
+    fn test_mm_mask_cvttph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_epi16(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm_mask_cvttph_epi16(src, 0b01010101, a);
@@ -25914,7 +25914,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epi16() {
+    fn test_mm_maskz_cvttph_epi16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_maskz_cvttph_epi16(0b01010101, a);
         let e = _mm_set_epi16(0, 2, 0, 4, 0, 6, 0, 8);
@@ -25922,7 +25922,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epi16() {
+    fn test_mm256_cvttph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25932,7 +25932,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epi16() {
+    fn test_mm256_mask_cvttph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25945,7 +25945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epi16() {
+    fn test_mm256_maskz_cvttph_epi16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -25955,7 +25955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epi16() {
+    fn test_mm512_cvttph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25970,7 +25970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epi16() {
+    fn test_mm512_mask_cvttph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -25989,7 +25989,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epi16() {
+    fn test_mm512_maskz_cvttph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26004,7 +26004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epi16() {
+    fn test_mm512_cvtt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26019,7 +26019,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epi16() {
+    fn test_mm512_mask_cvtt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26042,7 +26042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epi16() {
+    fn test_mm512_maskz_cvtt_roundph_epi16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26060,7 +26060,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epu16() {
+    fn test_mm_cvttph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttph_epu16(a);
         let e = _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26068,7 +26068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epu16() {
+    fn test_mm_mask_cvttph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_epi16(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm_mask_cvttph_epu16(src, 0b01010101, a);
@@ -26077,7 +26077,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epu16() {
+    fn test_mm_maskz_cvttph_epu16() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_maskz_cvttph_epu16(0b01010101, a);
         let e = _mm_set_epi16(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26085,7 +26085,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epu16() {
+    fn test_mm256_cvttph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26095,7 +26095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epu16() {
+    fn test_mm256_mask_cvttph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26108,7 +26108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epu16() {
+    fn test_mm256_maskz_cvttph_epu16() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26118,7 +26118,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epu16() {
+    fn test_mm512_cvttph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26133,7 +26133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epu16() {
+    fn test_mm512_mask_cvttph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26152,7 +26152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epu16() {
+    fn test_mm512_maskz_cvttph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26167,7 +26167,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epu16() {
+    fn test_mm512_cvtt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26182,7 +26182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epu16() {
+    fn test_mm512_mask_cvtt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26205,7 +26205,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epu16() {
+    fn test_mm512_maskz_cvtt_roundph_epu16() {
         let a = _mm512_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -26223,7 +26223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epi32() {
+    fn test_mm_cvtph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtph_epi32(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -26231,7 +26231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epi32() {
+    fn test_mm_mask_cvtph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_epi32(10, 11, 12, 13);
         let r = _mm_mask_cvtph_epi32(src, 0b0101, a);
@@ -26240,7 +26240,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epi32() {
+    fn test_mm_maskz_cvtph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvtph_epi32(0b0101, a);
         let e = _mm_set_epi32(0, 2, 0, 4);
@@ -26248,7 +26248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epi32() {
+    fn test_mm256_cvtph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvtph_epi32(a);
         let e = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26256,7 +26256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epi32() {
+    fn test_mm256_mask_cvtph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm256_set_epi32(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm256_mask_cvtph_epi32(src, 0b01010101, a);
@@ -26265,7 +26265,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epi32() {
+    fn test_mm256_maskz_cvtph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvtph_epi32(0b01010101, a);
         let e = _mm256_set_epi32(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26273,7 +26273,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epi32() {
+    fn test_mm512_cvtph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26283,7 +26283,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epi32() {
+    fn test_mm512_mask_cvtph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26296,7 +26296,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epi32() {
+    fn test_mm512_maskz_cvtph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26306,7 +26306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epi32() {
+    fn test_mm512_cvt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26316,7 +26316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epi32() {
+    fn test_mm512_mask_cvt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26333,7 +26333,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epi32() {
+    fn test_mm512_maskz_cvt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26346,21 +26346,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_i32() {
+    fn test_mm_cvtsh_i32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtsh_i32(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_i32() {
+    fn test_mm_cvt_roundsh_i32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundsh_i32::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epu32() {
+    fn test_mm_cvtph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtph_epu32(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -26368,7 +26368,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epu32() {
+    fn test_mm_mask_cvtph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_epi32(10, 11, 12, 13);
         let r = _mm_mask_cvtph_epu32(src, 0b0101, a);
@@ -26377,7 +26377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epu32() {
+    fn test_mm_maskz_cvtph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvtph_epu32(0b0101, a);
         let e = _mm_set_epi32(0, 2, 0, 4);
@@ -26385,7 +26385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epu32() {
+    fn test_mm256_cvtph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvtph_epu32(a);
         let e = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26393,7 +26393,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epu32() {
+    fn test_mm256_mask_cvtph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm256_set_epi32(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm256_mask_cvtph_epu32(src, 0b01010101, a);
@@ -26402,7 +26402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epu32() {
+    fn test_mm256_maskz_cvtph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvtph_epu32(0b01010101, a);
         let e = _mm256_set_epi32(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26410,7 +26410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epu32() {
+    fn test_mm512_cvtph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26420,7 +26420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epu32() {
+    fn test_mm512_mask_cvtph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26433,7 +26433,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epu32() {
+    fn test_mm512_maskz_cvtph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26443,7 +26443,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epu32() {
+    fn test_mm512_cvt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26453,7 +26453,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epu32() {
+    fn test_mm512_mask_cvt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26470,7 +26470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epu32() {
+    fn test_mm512_maskz_cvt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26483,21 +26483,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_u32() {
+    fn test_mm_cvtsh_u32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtsh_u32(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_u32() {
+    fn test_mm_cvt_roundsh_u32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundsh_u32::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epi32() {
+    fn test_mm_cvttph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvttph_epi32(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -26505,7 +26505,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epi32() {
+    fn test_mm_mask_cvttph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_epi32(10, 11, 12, 13);
         let r = _mm_mask_cvttph_epi32(src, 0b0101, a);
@@ -26514,7 +26514,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epi32() {
+    fn test_mm_maskz_cvttph_epi32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvttph_epi32(0b0101, a);
         let e = _mm_set_epi32(0, 2, 0, 4);
@@ -26522,7 +26522,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epi32() {
+    fn test_mm256_cvttph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvttph_epi32(a);
         let e = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26530,7 +26530,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epi32() {
+    fn test_mm256_mask_cvttph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm256_set_epi32(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm256_mask_cvttph_epi32(src, 0b01010101, a);
@@ -26539,7 +26539,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epi32() {
+    fn test_mm256_maskz_cvttph_epi32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvttph_epi32(0b01010101, a);
         let e = _mm256_set_epi32(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26547,7 +26547,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epi32() {
+    fn test_mm512_cvttph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26557,7 +26557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epi32() {
+    fn test_mm512_mask_cvttph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26570,7 +26570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epi32() {
+    fn test_mm512_maskz_cvttph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26580,7 +26580,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epi32() {
+    fn test_mm512_cvtt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26590,7 +26590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epi32() {
+    fn test_mm512_mask_cvtt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26603,7 +26603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epi32() {
+    fn test_mm512_maskz_cvtt_roundph_epi32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26613,21 +26613,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvttsh_i32() {
+    fn test_mm_cvttsh_i32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttsh_i32(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtt_roundsh_i32() {
+    fn test_mm_cvtt_roundsh_i32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtt_roundsh_i32::<_MM_FROUND_NO_EXC>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epu32() {
+    fn test_mm_cvttph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvttph_epu32(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -26635,7 +26635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epu32() {
+    fn test_mm_mask_cvttph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let src = _mm_set_epi32(10, 11, 12, 13);
         let r = _mm_mask_cvttph_epu32(src, 0b0101, a);
@@ -26644,7 +26644,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epu32() {
+    fn test_mm_maskz_cvttph_epu32() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvttph_epu32(0b0101, a);
         let e = _mm_set_epi32(0, 2, 0, 4);
@@ -26652,7 +26652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epu32() {
+    fn test_mm256_cvttph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvttph_epu32(a);
         let e = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26660,7 +26660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epu32() {
+    fn test_mm256_mask_cvttph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm256_set_epi32(10, 11, 12, 13, 14, 15, 16, 17);
         let r = _mm256_mask_cvttph_epu32(src, 0b01010101, a);
@@ -26669,7 +26669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epu32() {
+    fn test_mm256_maskz_cvttph_epu32() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvttph_epu32(0b01010101, a);
         let e = _mm256_set_epi32(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26677,7 +26677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epu32() {
+    fn test_mm512_cvttph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26687,7 +26687,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epu32() {
+    fn test_mm512_mask_cvttph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26700,7 +26700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epu32() {
+    fn test_mm512_maskz_cvttph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26710,7 +26710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epu32() {
+    fn test_mm512_cvtt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26720,7 +26720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epu32() {
+    fn test_mm512_mask_cvtt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26733,7 +26733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epu32() {
+    fn test_mm512_maskz_cvtt_roundph_epu32() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -26743,21 +26743,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvttsh_u32() {
+    fn test_mm_cvttsh_u32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttsh_u32(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtt_roundsh_u32() {
+    fn test_mm_cvtt_roundsh_u32() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtt_roundsh_u32::<_MM_FROUND_NO_EXC>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epi64() {
+    fn test_mm_cvtph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_cvtph_epi64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -26765,7 +26765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epi64() {
+    fn test_mm_mask_cvtph_epi64() {
         let src = _mm_set_epi64x(3, 4);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_mask_cvtph_epi64(src, 0b01, a);
@@ -26774,7 +26774,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epi64() {
+    fn test_mm_maskz_cvtph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_maskz_cvtph_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -26782,7 +26782,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epi64() {
+    fn test_mm256_cvtph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvtph_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -26790,7 +26790,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epi64() {
+    fn test_mm256_mask_cvtph_epi64() {
         let src = _mm256_set_epi64x(5, 6, 7, 8);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_mask_cvtph_epi64(src, 0b0101, a);
@@ -26799,7 +26799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epi64() {
+    fn test_mm256_maskz_cvtph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvtph_epi64(0b0101, a);
         let e = _mm256_set_epi64x(0, 2, 0, 4);
@@ -26807,7 +26807,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epi64() {
+    fn test_mm512_cvtph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtph_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26815,7 +26815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epi64() {
+    fn test_mm512_mask_cvtph_epi64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvtph_epi64(src, 0b01010101, a);
@@ -26824,7 +26824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epi64() {
+    fn test_mm512_maskz_cvtph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtph_epi64(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26832,7 +26832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epi64() {
+    fn test_mm512_cvt_roundph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvt_roundph_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26840,7 +26840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epi64() {
+    fn test_mm512_mask_cvt_roundph_epi64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvt_roundph_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -26851,7 +26851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epi64() {
+    fn test_mm512_maskz_cvt_roundph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvt_roundph_epi64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101, a,
@@ -26861,7 +26861,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_epu64() {
+    fn test_mm_cvtph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_cvtph_epu64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -26869,7 +26869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_epu64() {
+    fn test_mm_mask_cvtph_epu64() {
         let src = _mm_set_epi64x(3, 4);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_mask_cvtph_epu64(src, 0b01, a);
@@ -26878,7 +26878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_epu64() {
+    fn test_mm_maskz_cvtph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_maskz_cvtph_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -26886,7 +26886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_epu64() {
+    fn test_mm256_cvtph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvtph_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -26894,7 +26894,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_epu64() {
+    fn test_mm256_mask_cvtph_epu64() {
         let src = _mm256_set_epi64x(5, 6, 7, 8);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_mask_cvtph_epu64(src, 0b0101, a);
@@ -26903,7 +26903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_epu64() {
+    fn test_mm256_maskz_cvtph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvtph_epu64(0b0101, a);
         let e = _mm256_set_epi64x(0, 2, 0, 4);
@@ -26911,7 +26911,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_epu64() {
+    fn test_mm512_cvtph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtph_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26919,7 +26919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_epu64() {
+    fn test_mm512_mask_cvtph_epu64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvtph_epu64(src, 0b01010101, a);
@@ -26928,7 +26928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_epu64() {
+    fn test_mm512_maskz_cvtph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtph_epu64(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -26936,7 +26936,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_epu64() {
+    fn test_mm512_cvt_roundph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvt_roundph_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -26944,7 +26944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_epu64() {
+    fn test_mm512_mask_cvt_roundph_epu64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvt_roundph_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -26955,7 +26955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_epu64() {
+    fn test_mm512_maskz_cvt_roundph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvt_roundph_epu64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
             0b01010101, a,
@@ -26965,7 +26965,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epi64() {
+    fn test_mm_cvttph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_cvttph_epi64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -26973,7 +26973,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epi64() {
+    fn test_mm_mask_cvttph_epi64() {
         let src = _mm_set_epi64x(3, 4);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_mask_cvttph_epi64(src, 0b01, a);
@@ -26982,7 +26982,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epi64() {
+    fn test_mm_maskz_cvttph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_maskz_cvttph_epi64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -26990,7 +26990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epi64() {
+    fn test_mm256_cvttph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvttph_epi64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -26998,7 +26998,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epi64() {
+    fn test_mm256_mask_cvttph_epi64() {
         let src = _mm256_set_epi64x(5, 6, 7, 8);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_mask_cvttph_epi64(src, 0b0101, a);
@@ -27007,7 +27007,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epi64() {
+    fn test_mm256_maskz_cvttph_epi64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvttph_epi64(0b0101, a);
         let e = _mm256_set_epi64x(0, 2, 0, 4);
@@ -27015,7 +27015,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epi64() {
+    fn test_mm512_cvttph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvttph_epi64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -27023,7 +27023,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epi64() {
+    fn test_mm512_mask_cvttph_epi64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvttph_epi64(src, 0b01010101, a);
@@ -27032,7 +27032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epi64() {
+    fn test_mm512_maskz_cvttph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvttph_epi64(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -27040,7 +27040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epi64() {
+    fn test_mm512_cvtt_roundph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtt_roundph_epi64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -27048,7 +27048,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epi64() {
+    fn test_mm512_mask_cvtt_roundph_epi64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvtt_roundph_epi64::<_MM_FROUND_NO_EXC>(src, 0b01010101, a);
@@ -27057,7 +27057,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epi64() {
+    fn test_mm512_maskz_cvtt_roundph_epi64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtt_roundph_epi64::<_MM_FROUND_NO_EXC>(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -27065,7 +27065,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvttph_epu64() {
+    fn test_mm_cvttph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_cvttph_epu64(a);
         let e = _mm_set_epi64x(1, 2);
@@ -27073,7 +27073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvttph_epu64() {
+    fn test_mm_mask_cvttph_epu64() {
         let src = _mm_set_epi64x(3, 4);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_mask_cvttph_epu64(src, 0b01, a);
@@ -27082,7 +27082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvttph_epu64() {
+    fn test_mm_maskz_cvttph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_maskz_cvttph_epu64(0b01, a);
         let e = _mm_set_epi64x(0, 2);
@@ -27090,7 +27090,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvttph_epu64() {
+    fn test_mm256_cvttph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvttph_epu64(a);
         let e = _mm256_set_epi64x(1, 2, 3, 4);
@@ -27098,7 +27098,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvttph_epu64() {
+    fn test_mm256_mask_cvttph_epu64() {
         let src = _mm256_set_epi64x(5, 6, 7, 8);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_mask_cvttph_epu64(src, 0b0101, a);
@@ -27107,7 +27107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttph_epu64() {
+    fn test_mm256_maskz_cvttph_epu64() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvttph_epu64(0b0101, a);
         let e = _mm256_set_epi64x(0, 2, 0, 4);
@@ -27115,7 +27115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvttph_epu64() {
+    fn test_mm512_cvttph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvttph_epu64(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -27123,7 +27123,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvttph_epu64() {
+    fn test_mm512_mask_cvttph_epu64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvttph_epu64(src, 0b01010101, a);
@@ -27132,7 +27132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvttph_epu64() {
+    fn test_mm512_maskz_cvttph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvttph_epu64(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -27140,7 +27140,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtt_roundph_epu64() {
+    fn test_mm512_cvtt_roundph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtt_roundph_epu64::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
@@ -27148,7 +27148,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtt_roundph_epu64() {
+    fn test_mm512_mask_cvtt_roundph_epu64() {
         let src = _mm512_set_epi64(9, 10, 11, 12, 13, 14, 15, 16);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvtt_roundph_epu64::<_MM_FROUND_NO_EXC>(src, 0b01010101, a);
@@ -27157,7 +27157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtt_roundph_epu64() {
+    fn test_mm512_maskz_cvtt_roundph_epu64() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtt_roundph_epu64::<_MM_FROUND_NO_EXC>(0b01010101, a);
         let e = _mm512_set_epi64(0, 2, 0, 4, 0, 6, 0, 8);
@@ -27165,7 +27165,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtxph_ps() {
+    fn test_mm_cvtxph_ps() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtxph_ps(a);
         let e = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
@@ -27173,7 +27173,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtxph_ps() {
+    fn test_mm_mask_cvtxph_ps() {
         let src = _mm_set_ps(10.0, 11.0, 12.0, 13.0);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_mask_cvtxph_ps(src, 0b0101, a);
@@ -27182,7 +27182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtxph_ps() {
+    fn test_mm_maskz_cvtxph_ps() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm_maskz_cvtxph_ps(0b0101, a);
         let e = _mm_set_ps(0.0, 2.0, 0.0, 4.0);
@@ -27190,7 +27190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtxph_ps() {
+    fn test_mm256_cvtxph_ps() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvtxph_ps(a);
         let e = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -27198,7 +27198,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtxph_ps() {
+    fn test_mm256_mask_cvtxph_ps() {
         let src = _mm256_set_ps(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_mask_cvtxph_ps(src, 0b01010101, a);
@@ -27207,7 +27207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtxph_ps() {
+    fn test_mm256_maskz_cvtxph_ps() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_maskz_cvtxph_ps(0b01010101, a);
         let e = _mm256_set_ps(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -27215,7 +27215,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtxph_ps() {
+    fn test_mm512_cvtxph_ps() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -27227,7 +27227,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtxph_ps() {
+    fn test_mm512_mask_cvtxph_ps() {
         let src = _mm512_set_ps(
             10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0,
             24.0, 25.0,
@@ -27244,7 +27244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtxph_ps() {
+    fn test_mm512_maskz_cvtxph_ps() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -27256,7 +27256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtx_roundph_ps() {
+    fn test_mm512_cvtx_roundph_ps() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -27268,7 +27268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtx_roundph_ps() {
+    fn test_mm512_mask_cvtx_roundph_ps() {
         let src = _mm512_set_ps(
             10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0,
             24.0, 25.0,
@@ -27285,7 +27285,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtx_roundph_ps() {
+    fn test_mm512_maskz_cvtx_roundph_ps() {
         let a = _mm256_set_ph(
             1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -27297,7 +27297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_ss() {
+    fn test_mm_cvtsh_ss() {
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_cvtsh_ss(a, b);
@@ -27306,7 +27306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cvtsh_ss() {
+    fn test_mm_mask_cvtsh_ss() {
         let src = _mm_setr_ps(3.0, 11.0, 12.0, 13.0);
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
@@ -27319,7 +27319,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_maskz_cvtsh_ss() {
+    fn test_mm_maskz_cvtsh_ss() {
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_maskz_cvtsh_ss(0, a, b);
@@ -27331,7 +27331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_ss() {
+    fn test_mm_cvt_roundsh_ss() {
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_cvt_roundsh_ss::<_MM_FROUND_NO_EXC>(a, b);
@@ -27340,7 +27340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cvt_roundsh_ss() {
+    fn test_mm_mask_cvt_roundsh_ss() {
         let src = _mm_setr_ps(3.0, 11.0, 12.0, 13.0);
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
@@ -27353,7 +27353,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_maskz_cvt_roundsh_ss() {
+    fn test_mm_maskz_cvt_roundsh_ss() {
         let a = _mm_setr_ps(2.0, 20.0, 21.0, 22.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_maskz_cvt_roundsh_ss::<_MM_FROUND_NO_EXC>(0, a, b);
@@ -27365,7 +27365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtph_pd() {
+    fn test_mm_cvtph_pd() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_cvtph_pd(a);
         let e = _mm_set_pd(1.0, 2.0);
@@ -27373,7 +27373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_mask_cvtph_pd() {
+    fn test_mm_mask_cvtph_pd() {
         let src = _mm_set_pd(10.0, 11.0);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_mask_cvtph_pd(src, 0b01, a);
@@ -27382,7 +27382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_maskz_cvtph_pd() {
+    fn test_mm_maskz_cvtph_pd() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0);
         let r = _mm_maskz_cvtph_pd(0b01, a);
         let e = _mm_set_pd(0.0, 2.0);
@@ -27390,7 +27390,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_cvtph_pd() {
+    fn test_mm256_cvtph_pd() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_cvtph_pd(a);
         let e = _mm256_set_pd(1.0, 2.0, 3.0, 4.0);
@@ -27398,7 +27398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_mask_cvtph_pd() {
+    fn test_mm256_mask_cvtph_pd() {
         let src = _mm256_set_pd(10.0, 11.0, 12.0, 13.0);
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_mask_cvtph_pd(src, 0b0101, a);
@@ -27407,7 +27407,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtph_pd() {
+    fn test_mm256_maskz_cvtph_pd() {
         let a = _mm_set_ph(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0);
         let r = _mm256_maskz_cvtph_pd(0b0101, a);
         let e = _mm256_set_pd(0.0, 2.0, 0.0, 4.0);
@@ -27415,7 +27415,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvtph_pd() {
+    fn test_mm512_cvtph_pd() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtph_pd(a);
         let e = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -27423,7 +27423,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvtph_pd() {
+    fn test_mm512_mask_cvtph_pd() {
         let src = _mm512_set_pd(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvtph_pd(src, 0b01010101, a);
@@ -27432,7 +27432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvtph_pd() {
+    fn test_mm512_maskz_cvtph_pd() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtph_pd(0b01010101, a);
         let e = _mm512_set_pd(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -27440,7 +27440,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_cvt_roundph_pd() {
+    fn test_mm512_cvt_roundph_pd() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvt_roundph_pd::<_MM_FROUND_NO_EXC>(a);
         let e = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -27448,7 +27448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_mask_cvt_roundph_pd() {
+    fn test_mm512_mask_cvt_roundph_pd() {
         let src = _mm512_set_pd(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0);
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_mask_cvt_roundph_pd::<_MM_FROUND_NO_EXC>(src, 0b01010101, a);
@@ -27457,7 +27457,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm512_maskz_cvt_roundph_pd() {
+    fn test_mm512_maskz_cvt_roundph_pd() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvt_roundph_pd::<_MM_FROUND_NO_EXC>(0b01010101, a);
         let e = _mm512_set_pd(0.0, 2.0, 0.0, 4.0, 0.0, 6.0, 0.0, 8.0);
@@ -27465,7 +27465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_sd() {
+    fn test_mm_cvtsh_sd() {
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_cvtsh_sd(a, b);
@@ -27474,7 +27474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cvtsh_sd() {
+    fn test_mm_mask_cvtsh_sd() {
         let src = _mm_setr_pd(3.0, 11.0);
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
@@ -27487,7 +27487,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_maskz_cvtsh_sd() {
+    fn test_mm_maskz_cvtsh_sd() {
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_maskz_cvtsh_sd(0, a, b);
@@ -27499,7 +27499,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_sd() {
+    fn test_mm_cvt_roundsh_sd() {
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_cvt_roundsh_sd::<_MM_FROUND_NO_EXC>(a, b);
@@ -27508,7 +27508,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_mask_cvt_roundsh_sd() {
+    fn test_mm_mask_cvt_roundsh_sd() {
         let src = _mm_setr_pd(3.0, 11.0);
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
@@ -27521,7 +27521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_maskz_cvt_roundsh_sd() {
+    fn test_mm_maskz_cvt_roundsh_sd() {
         let a = _mm_setr_pd(2.0, 20.0);
         let b = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let r = _mm_maskz_cvt_roundsh_sd::<_MM_FROUND_NO_EXC>(0, a, b);
@@ -27533,14 +27533,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_cvtsh_h() {
+    const fn test_mm_cvtsh_h() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 42.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtsh_h(a);
         assert_eq!(r, 1.0);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm256_cvtsh_h() {
+    const fn test_mm256_cvtsh_h() {
         let a = _mm256_setr_ph(
             1.0, 2.0, 3.0, 42.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
         );
@@ -27549,7 +27549,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm512_cvtsh_h() {
+    const fn test_mm512_cvtsh_h() {
         let a = _mm512_setr_ph(
             1.0, 2.0, 3.0, 42.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
             17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0,
@@ -27560,14 +27560,14 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_cvtsi128_si16() {
+    const fn test_mm_cvtsi128_si16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm_cvtsi128_si16(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    const unsafe fn test_mm_cvtsi16_si128() {
+    const fn test_mm_cvtsi16_si128() {
         let a = 1;
         let r = _mm_cvtsi16_si128(a);
         let e = _mm_setr_epi16(1, 0, 0, 0, 0, 0, 0, 0);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512ifma.rs b/library/stdarch/crates/core_arch/src/x86/avx512ifma.rs
index 7c9d07f69095..5ce28565d108 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512ifma.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512ifma.rs
@@ -372,7 +372,7 @@ mod tests {
     const K: __mmask8 = 0b01101101;
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_madd52hi_epu64() {
+    fn test_mm512_madd52hi_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -386,7 +386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_mask_madd52hi_epu64() {
+    fn test_mm512_mask_madd52hi_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -401,7 +401,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_maskz_madd52hi_epu64() {
+    fn test_mm512_maskz_madd52hi_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -416,7 +416,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_madd52lo_epu64() {
+    fn test_mm512_madd52lo_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -430,7 +430,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_mask_madd52lo_epu64() {
+    fn test_mm512_mask_madd52lo_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -445,7 +445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma")]
-    unsafe fn test_mm512_maskz_madd52lo_epu64() {
+    fn test_mm512_maskz_madd52lo_epu64() {
         let a = _mm512_set1_epi64(10 << 40);
         let b = _mm512_set1_epi64((11 << 40) + 4);
         let c = _mm512_set1_epi64((12 << 40) + 3);
@@ -460,7 +460,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxifma")]
-    unsafe fn test_mm256_madd52hi_avx_epu64() {
+    fn test_mm256_madd52hi_avx_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -474,7 +474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_madd52hi_epu64() {
+    fn test_mm256_madd52hi_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -488,7 +488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_mask_madd52hi_epu64() {
+    fn test_mm256_mask_madd52hi_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -503,7 +503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_maskz_madd52hi_epu64() {
+    fn test_mm256_maskz_madd52hi_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -518,7 +518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxifma")]
-    unsafe fn test_mm256_madd52lo_avx_epu64() {
+    fn test_mm256_madd52lo_avx_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -532,7 +532,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_madd52lo_epu64() {
+    fn test_mm256_madd52lo_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -546,7 +546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_mask_madd52lo_epu64() {
+    fn test_mm256_mask_madd52lo_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -561,7 +561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm256_maskz_madd52lo_epu64() {
+    fn test_mm256_maskz_madd52lo_epu64() {
         let a = _mm256_set1_epi64x(10 << 40);
         let b = _mm256_set1_epi64x((11 << 40) + 4);
         let c = _mm256_set1_epi64x((12 << 40) + 3);
@@ -576,7 +576,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxifma")]
-    unsafe fn test_mm_madd52hi_avx_epu64() {
+    fn test_mm_madd52hi_avx_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -590,7 +590,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_madd52hi_epu64() {
+    fn test_mm_madd52hi_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -604,7 +604,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_mask_madd52hi_epu64() {
+    fn test_mm_mask_madd52hi_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -619,7 +619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_maskz_madd52hi_epu64() {
+    fn test_mm_maskz_madd52hi_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -634,7 +634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxifma")]
-    unsafe fn test_mm_madd52lo_avx_epu64() {
+    fn test_mm_madd52lo_avx_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -648,7 +648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_madd52lo_epu64() {
+    fn test_mm_madd52lo_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -662,7 +662,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_mask_madd52lo_epu64() {
+    fn test_mm_mask_madd52lo_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
@@ -677,7 +677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512ifma,avx512vl")]
-    unsafe fn test_mm_maskz_madd52lo_epu64() {
+    fn test_mm_maskz_madd52lo_epu64() {
         let a = _mm_set1_epi64x(10 << 40);
         let b = _mm_set1_epi64x((11 << 40) + 4);
         let c = _mm_set1_epi64x((12 << 40) + 3);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512vbmi.rs b/library/stdarch/crates/core_arch/src/x86/avx512vbmi.rs
index 3527ccc9e44a..d9ad14ef00dd 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512vbmi.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512vbmi.rs
@@ -484,7 +484,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_permutex2var_epi8() {
+    fn test_mm512_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -508,7 +508,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_mask_permutex2var_epi8() {
+    fn test_mm512_mask_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -539,7 +539,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_maskz_permutex2var_epi8() {
+    fn test_mm512_maskz_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -570,7 +570,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_mask2_permutex2var_epi8() {
+    fn test_mm512_mask2_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -601,7 +601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_permutex2var_epi8() {
+    fn test_mm256_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -619,7 +619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_epi8() {
+    fn test_mm256_mask_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -639,7 +639,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_epi8() {
+    fn test_mm256_maskz_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -659,7 +659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_epi8() {
+    fn test_mm256_mask2_permutex2var_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -679,7 +679,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_permutex2var_epi8() {
+    fn test_mm_permutex2var_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm_set_epi8(1, 1 << 4, 2, 1 << 4, 3, 1 << 4, 4, 1 << 4, 5, 1 << 4, 6, 1 << 4, 7, 1 << 4, 8, 1 << 4);
@@ -692,7 +692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_epi8() {
+    fn test_mm_mask_permutex2var_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm_set_epi8(1, 1 << 4, 2, 1 << 4, 3, 1 << 4, 4, 1 << 4, 5, 1 << 4, 6, 1 << 4, 7, 1 << 4, 8, 1 << 4);
@@ -707,7 +707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_epi8() {
+    fn test_mm_maskz_permutex2var_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm_set_epi8(1, 1 << 4, 2, 1 << 4, 3, 1 << 4, 4, 1 << 4, 5, 1 << 4, 6, 1 << 4, 7, 1 << 4, 8, 1 << 4);
@@ -722,7 +722,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_epi8() {
+    fn test_mm_mask2_permutex2var_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let idx = _mm_set_epi8(1, 1 << 4, 2, 1 << 4, 3, 1 << 4, 4, 1 << 4, 5, 1 << 4, 6, 1 << 4, 7, 1 << 4, 8, 1 << 4);
@@ -737,7 +737,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_permutexvar_epi8() {
+    fn test_mm512_permutexvar_epi8() {
         let idx = _mm512_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -750,7 +750,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_mask_permutexvar_epi8() {
+    fn test_mm512_mask_permutexvar_epi8() {
         let idx = _mm512_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -770,7 +770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_maskz_permutexvar_epi8() {
+    fn test_mm512_maskz_permutexvar_epi8() {
         let idx = _mm512_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -789,7 +789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_permutexvar_epi8() {
+    fn test_mm256_permutexvar_epi8() {
         let idx = _mm256_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -800,7 +800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_epi8() {
+    fn test_mm256_mask_permutexvar_epi8() {
         let idx = _mm256_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -813,7 +813,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_epi8() {
+    fn test_mm256_maskz_permutexvar_epi8() {
         let idx = _mm256_set1_epi8(1);
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -826,7 +826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_permutexvar_epi8() {
+    fn test_mm_permutexvar_epi8() {
         let idx = _mm_set1_epi8(1);
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_permutexvar_epi8(idx, a);
@@ -835,7 +835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_mask_permutexvar_epi8() {
+    fn test_mm_mask_permutexvar_epi8() {
         let idx = _mm_set1_epi8(1);
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_mask_permutexvar_epi8(a, 0, idx, a);
@@ -846,7 +846,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_maskz_permutexvar_epi8() {
+    fn test_mm_maskz_permutexvar_epi8() {
         let idx = _mm_set1_epi8(1);
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_permutexvar_epi8(0, idx, a);
@@ -857,7 +857,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_multishift_epi64_epi8() {
+    fn test_mm512_multishift_epi64_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_multishift_epi64_epi8(a, b);
@@ -866,7 +866,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_mask_multishift_epi64_epi8() {
+    fn test_mm512_mask_multishift_epi64_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_mask_multishift_epi64_epi8(a, 0, a, b);
@@ -882,7 +882,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi")]
-    unsafe fn test_mm512_maskz_multishift_epi64_epi8() {
+    fn test_mm512_maskz_multishift_epi64_epi8() {
         let a = _mm512_set1_epi8(1);
         let b = _mm512_set1_epi8(1);
         let r = _mm512_maskz_multishift_epi64_epi8(0, a, b);
@@ -897,7 +897,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_multishift_epi64_epi8() {
+    fn test_mm256_multishift_epi64_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_multishift_epi64_epi8(a, b);
@@ -906,7 +906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_mask_multishift_epi64_epi8() {
+    fn test_mm256_mask_multishift_epi64_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_mask_multishift_epi64_epi8(a, 0, a, b);
@@ -917,7 +917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm256_maskz_multishift_epi64_epi8() {
+    fn test_mm256_maskz_multishift_epi64_epi8() {
         let a = _mm256_set1_epi8(1);
         let b = _mm256_set1_epi8(1);
         let r = _mm256_maskz_multishift_epi64_epi8(0, a, b);
@@ -928,7 +928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_multishift_epi64_epi8() {
+    fn test_mm_multishift_epi64_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_multishift_epi64_epi8(a, b);
@@ -937,7 +937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_mask_multishift_epi64_epi8() {
+    fn test_mm_mask_multishift_epi64_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_mask_multishift_epi64_epi8(a, 0, a, b);
@@ -948,7 +948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi,avx512vl")]
-    unsafe fn test_mm_maskz_multishift_epi64_epi8() {
+    fn test_mm_maskz_multishift_epi64_epi8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(1);
         let r = _mm_maskz_multishift_epi64_epi8(0, a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512vbmi2.rs b/library/stdarch/crates/core_arch/src/x86/avx512vbmi2.rs
index da268f969c37..26cef5814e9c 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512vbmi2.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512vbmi2.rs
@@ -2450,7 +2450,7 @@ mod tests {
     use crate::hint::black_box;
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_mask_compress_epi16() {
+    fn test_mm512_mask_compress_epi16() {
         let src = _mm512_set1_epi16(200);
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2465,7 +2465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_maskz_compress_epi16() {
+    fn test_mm512_maskz_compress_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -2479,7 +2479,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_mask_compress_epi16() {
+    fn test_mm256_mask_compress_epi16() {
         let src = _mm256_set1_epi16(200);
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_mask_compress_epi16(src, 0b01010101_01010101, a);
@@ -2490,7 +2490,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_epi16() {
+    fn test_mm256_maskz_compress_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_compress_epi16(0b01010101_01010101, a);
         let e = _mm256_set_epi16(0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 9, 11, 13, 15);
@@ -2498,7 +2498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_mask_compress_epi16() {
+    fn test_mm_mask_compress_epi16() {
         let src = _mm_set1_epi16(200);
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_mask_compress_epi16(src, 0b01010101, a);
@@ -2507,7 +2507,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_maskz_compress_epi16() {
+    fn test_mm_maskz_compress_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_compress_epi16(0b01010101, a);
         let e = _mm_set_epi16(0, 0, 0, 0, 1, 3, 5, 7);
@@ -2515,7 +2515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_mask_compress_epi8() {
+    fn test_mm512_mask_compress_epi8() {
         let src = _mm512_set1_epi8(100);
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2538,7 +2538,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_maskz_compress_epi8() {
+    fn test_mm512_maskz_compress_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -2559,7 +2559,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_mask_compress_epi8() {
+    fn test_mm256_mask_compress_epi8() {
         let src = _mm256_set1_epi8(100);
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2574,7 +2574,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_epi8() {
+    fn test_mm256_maskz_compress_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -2588,7 +2588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_mask_compress_epi8() {
+    fn test_mm_mask_compress_epi8() {
         let src = _mm_set1_epi8(100);
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_mask_compress_epi8(src, 0b01010101_01010101, a);
@@ -2599,7 +2599,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_maskz_compress_epi8() {
+    fn test_mm_maskz_compress_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_compress_epi8(0b01010101_01010101, a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 9, 11, 13, 15);
@@ -2607,7 +2607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_mask_expand_epi16() {
+    fn test_mm512_mask_expand_epi16() {
         let src = _mm512_set1_epi16(200);
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2622,7 +2622,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_maskz_expand_epi16() {
+    fn test_mm512_maskz_expand_epi16() {
         #[rustfmt::skip]
         let a = _mm512_set_epi16(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -2634,7 +2634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_mask_expand_epi16() {
+    fn test_mm256_mask_expand_epi16() {
         let src = _mm256_set1_epi16(200);
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_mask_expand_epi16(src, 0b01010101_01010101, a);
@@ -2645,7 +2645,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_epi16() {
+    fn test_mm256_maskz_expand_epi16() {
         let a = _mm256_set_epi16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_expand_epi16(0b01010101_01010101, a);
         let e = _mm256_set_epi16(0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15);
@@ -2653,7 +2653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_mask_expand_epi16() {
+    fn test_mm_mask_expand_epi16() {
         let src = _mm_set1_epi16(200);
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_mask_expand_epi16(src, 0b01010101, a);
@@ -2662,7 +2662,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_maskz_expand_epi16() {
+    fn test_mm_maskz_expand_epi16() {
         let a = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_maskz_expand_epi16(0b01010101, a);
         let e = _mm_set_epi16(0, 4, 0, 5, 0, 6, 0, 7);
@@ -2670,7 +2670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_mask_expand_epi8() {
+    fn test_mm512_mask_expand_epi8() {
         let src = _mm512_set1_epi8(100);
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2693,7 +2693,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    unsafe fn test_mm512_maskz_expand_epi8() {
+    fn test_mm512_maskz_expand_epi8() {
         #[rustfmt::skip]
         let a = _mm512_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
@@ -2714,7 +2714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_mask_expand_epi8() {
+    fn test_mm256_mask_expand_epi8() {
         let src = _mm256_set1_epi8(100);
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
@@ -2729,7 +2729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_epi8() {
+    fn test_mm256_maskz_expand_epi8() {
         #[rustfmt::skip]
         let a = _mm256_set_epi8(0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
@@ -2743,7 +2743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_mask_expand_epi8() {
+    fn test_mm_mask_expand_epi8() {
         let src = _mm_set1_epi8(100);
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_mask_expand_epi8(src, 0b01010101_01010101, a);
@@ -2754,7 +2754,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    unsafe fn test_mm_maskz_expand_epi8() {
+    fn test_mm_maskz_expand_epi8() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_expand_epi8(0b01010101_01010101, a);
         let e = _mm_set_epi8(0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15);
@@ -2762,7 +2762,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldv_epi64() {
+    const fn test_mm512_shldv_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let c = _mm512_set1_epi64(2);
@@ -2772,7 +2772,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldv_epi64() {
+    const fn test_mm512_mask_shldv_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let c = _mm512_set1_epi64(2);
@@ -2784,7 +2784,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldv_epi64() {
+    const fn test_mm512_maskz_shldv_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let c = _mm512_set1_epi64(2);
@@ -2796,7 +2796,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldv_epi64() {
+    const fn test_mm256_shldv_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let c = _mm256_set1_epi64x(2);
@@ -2806,7 +2806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldv_epi64() {
+    const fn test_mm256_mask_shldv_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let c = _mm256_set1_epi64x(2);
@@ -2818,7 +2818,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldv_epi64() {
+    const fn test_mm256_maskz_shldv_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let c = _mm256_set1_epi64x(2);
@@ -2830,7 +2830,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldv_epi64() {
+    const fn test_mm_shldv_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let c = _mm_set1_epi64x(2);
@@ -2840,7 +2840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldv_epi64() {
+    const fn test_mm_mask_shldv_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let c = _mm_set1_epi64x(2);
@@ -2852,7 +2852,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldv_epi64() {
+    const fn test_mm_maskz_shldv_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let c = _mm_set1_epi64x(2);
@@ -2864,7 +2864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldv_epi32() {
+    const fn test_mm512_shldv_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let c = _mm512_set1_epi32(2);
@@ -2874,7 +2874,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldv_epi32() {
+    const fn test_mm512_mask_shldv_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let c = _mm512_set1_epi32(2);
@@ -2886,7 +2886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldv_epi32() {
+    const fn test_mm512_maskz_shldv_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let c = _mm512_set1_epi32(2);
@@ -2898,7 +2898,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldv_epi32() {
+    const fn test_mm256_shldv_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let c = _mm256_set1_epi32(2);
@@ -2908,7 +2908,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldv_epi32() {
+    const fn test_mm256_mask_shldv_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let c = _mm256_set1_epi32(2);
@@ -2920,7 +2920,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldv_epi32() {
+    const fn test_mm256_maskz_shldv_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let c = _mm256_set1_epi32(2);
@@ -2932,7 +2932,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldv_epi32() {
+    const fn test_mm_shldv_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let c = _mm_set1_epi32(2);
@@ -2942,7 +2942,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldv_epi32() {
+    const fn test_mm_mask_shldv_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let c = _mm_set1_epi32(2);
@@ -2954,7 +2954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldv_epi32() {
+    const fn test_mm_maskz_shldv_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let c = _mm_set1_epi32(2);
@@ -2966,7 +2966,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldv_epi16() {
+    const fn test_mm512_shldv_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let c = _mm512_set1_epi16(2);
@@ -2976,7 +2976,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldv_epi16() {
+    const fn test_mm512_mask_shldv_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let c = _mm512_set1_epi16(2);
@@ -2988,7 +2988,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldv_epi16() {
+    const fn test_mm512_maskz_shldv_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let c = _mm512_set1_epi16(2);
@@ -3000,7 +3000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldv_epi16() {
+    const fn test_mm256_shldv_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let c = _mm256_set1_epi16(2);
@@ -3010,7 +3010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldv_epi16() {
+    const fn test_mm256_mask_shldv_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let c = _mm256_set1_epi16(2);
@@ -3022,7 +3022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldv_epi16() {
+    const fn test_mm256_maskz_shldv_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let c = _mm256_set1_epi16(2);
@@ -3034,7 +3034,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldv_epi16() {
+    const fn test_mm_shldv_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let c = _mm_set1_epi16(2);
@@ -3044,7 +3044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldv_epi16() {
+    const fn test_mm_mask_shldv_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let c = _mm_set1_epi16(2);
@@ -3056,7 +3056,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldv_epi16() {
+    const fn test_mm_maskz_shldv_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let c = _mm_set1_epi16(2);
@@ -3068,7 +3068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdv_epi64() {
+    const fn test_mm512_shrdv_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let c = _mm512_set1_epi64(1);
@@ -3078,7 +3078,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdv_epi64() {
+    const fn test_mm512_mask_shrdv_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let c = _mm512_set1_epi64(1);
@@ -3090,7 +3090,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdv_epi64() {
+    const fn test_mm512_maskz_shrdv_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let c = _mm512_set1_epi64(1);
@@ -3102,7 +3102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdv_epi64() {
+    const fn test_mm256_shrdv_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let c = _mm256_set1_epi64x(1);
@@ -3112,7 +3112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdv_epi64() {
+    const fn test_mm256_mask_shrdv_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let c = _mm256_set1_epi64x(1);
@@ -3124,7 +3124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdv_epi64() {
+    const fn test_mm256_maskz_shrdv_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let c = _mm256_set1_epi64x(1);
@@ -3136,7 +3136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdv_epi64() {
+    const fn test_mm_shrdv_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let c = _mm_set1_epi64x(1);
@@ -3146,7 +3146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdv_epi64() {
+    const fn test_mm_mask_shrdv_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let c = _mm_set1_epi64x(1);
@@ -3158,7 +3158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdv_epi64() {
+    const fn test_mm_maskz_shrdv_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let c = _mm_set1_epi64x(1);
@@ -3170,7 +3170,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdv_epi32() {
+    const fn test_mm512_shrdv_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let c = _mm512_set1_epi32(1);
@@ -3180,7 +3180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdv_epi32() {
+    const fn test_mm512_mask_shrdv_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let c = _mm512_set1_epi32(1);
@@ -3192,7 +3192,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdv_epi32() {
+    const fn test_mm512_maskz_shrdv_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let c = _mm512_set1_epi32(1);
@@ -3204,7 +3204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdv_epi32() {
+    const fn test_mm256_shrdv_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let c = _mm256_set1_epi32(1);
@@ -3214,7 +3214,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdv_epi32() {
+    const fn test_mm256_mask_shrdv_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let c = _mm256_set1_epi32(1);
@@ -3226,7 +3226,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdv_epi32() {
+    const fn test_mm256_maskz_shrdv_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let c = _mm256_set1_epi32(1);
@@ -3238,7 +3238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdv_epi32() {
+    const fn test_mm_shrdv_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let c = _mm_set1_epi32(1);
@@ -3248,7 +3248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdv_epi32() {
+    const fn test_mm_mask_shrdv_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let c = _mm_set1_epi32(1);
@@ -3260,7 +3260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdv_epi32() {
+    const fn test_mm_maskz_shrdv_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let c = _mm_set1_epi32(1);
@@ -3272,7 +3272,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdv_epi16() {
+    const fn test_mm512_shrdv_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let c = _mm512_set1_epi16(1);
@@ -3282,7 +3282,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdv_epi16() {
+    const fn test_mm512_mask_shrdv_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let c = _mm512_set1_epi16(1);
@@ -3294,7 +3294,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdv_epi16() {
+    const fn test_mm512_maskz_shrdv_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let c = _mm512_set1_epi16(1);
@@ -3306,7 +3306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdv_epi16() {
+    const fn test_mm256_shrdv_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let c = _mm256_set1_epi16(1);
@@ -3316,7 +3316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdv_epi16() {
+    const fn test_mm256_mask_shrdv_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let c = _mm256_set1_epi16(1);
@@ -3328,7 +3328,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdv_epi16() {
+    const fn test_mm256_maskz_shrdv_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let c = _mm256_set1_epi16(1);
@@ -3340,7 +3340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdv_epi16() {
+    const fn test_mm_shrdv_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let c = _mm_set1_epi16(1);
@@ -3350,7 +3350,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdv_epi16() {
+    const fn test_mm_mask_shrdv_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let c = _mm_set1_epi16(1);
@@ -3362,7 +3362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdv_epi16() {
+    const fn test_mm_maskz_shrdv_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let c = _mm_set1_epi16(1);
@@ -3374,7 +3374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldi_epi64() {
+    const fn test_mm512_shldi_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let r = _mm512_shldi_epi64::<2>(a, b);
@@ -3383,7 +3383,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldi_epi64() {
+    const fn test_mm512_mask_shldi_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let r = _mm512_mask_shldi_epi64::<2>(a, 0, a, b);
@@ -3394,7 +3394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldi_epi64() {
+    const fn test_mm512_maskz_shldi_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(1 << 63);
         let r = _mm512_maskz_shldi_epi64::<2>(0, a, b);
@@ -3405,7 +3405,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldi_epi64() {
+    const fn test_mm256_shldi_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let r = _mm256_shldi_epi64::<2>(a, b);
@@ -3414,7 +3414,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldi_epi64() {
+    const fn test_mm256_mask_shldi_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let r = _mm256_mask_shldi_epi64::<2>(a, 0, a, b);
@@ -3425,7 +3425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldi_epi64() {
+    const fn test_mm256_maskz_shldi_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(1 << 63);
         let r = _mm256_maskz_shldi_epi64::<2>(0, a, b);
@@ -3436,7 +3436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldi_epi64() {
+    const fn test_mm_shldi_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let r = _mm_shldi_epi64::<2>(a, b);
@@ -3445,7 +3445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldi_epi64() {
+    const fn test_mm_mask_shldi_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let r = _mm_mask_shldi_epi64::<2>(a, 0, a, b);
@@ -3456,7 +3456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldi_epi64() {
+    const fn test_mm_maskz_shldi_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(1 << 63);
         let r = _mm_maskz_shldi_epi64::<2>(0, a, b);
@@ -3467,7 +3467,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldi_epi32() {
+    const fn test_mm512_shldi_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let r = _mm512_shldi_epi32::<2>(a, b);
@@ -3476,7 +3476,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldi_epi32() {
+    const fn test_mm512_mask_shldi_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let r = _mm512_mask_shldi_epi32::<2>(a, 0, a, b);
@@ -3487,7 +3487,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldi_epi32() {
+    const fn test_mm512_maskz_shldi_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_set1_epi32(1 << 31);
         let r = _mm512_maskz_shldi_epi32::<2>(0, a, b);
@@ -3498,7 +3498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldi_epi32() {
+    const fn test_mm256_shldi_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let r = _mm256_shldi_epi32::<2>(a, b);
@@ -3507,7 +3507,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldi_epi32() {
+    const fn test_mm256_mask_shldi_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let r = _mm256_mask_shldi_epi32::<2>(a, 0, a, b);
@@ -3518,7 +3518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldi_epi32() {
+    const fn test_mm256_maskz_shldi_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set1_epi32(1 << 31);
         let r = _mm256_maskz_shldi_epi32::<2>(0, a, b);
@@ -3529,7 +3529,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldi_epi32() {
+    const fn test_mm_shldi_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let r = _mm_shldi_epi32::<2>(a, b);
@@ -3538,7 +3538,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldi_epi32() {
+    const fn test_mm_mask_shldi_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let r = _mm_mask_shldi_epi32::<2>(a, 0, a, b);
@@ -3549,7 +3549,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldi_epi32() {
+    const fn test_mm_maskz_shldi_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set1_epi32(1 << 31);
         let r = _mm_maskz_shldi_epi32::<2>(0, a, b);
@@ -3560,7 +3560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shldi_epi16() {
+    const fn test_mm512_shldi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let r = _mm512_shldi_epi16::<2>(a, b);
@@ -3569,7 +3569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shldi_epi16() {
+    const fn test_mm512_mask_shldi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let r = _mm512_mask_shldi_epi16::<2>(a, 0, a, b);
@@ -3580,7 +3580,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shldi_epi16() {
+    const fn test_mm512_maskz_shldi_epi16() {
         let a = _mm512_set1_epi16(1);
         let b = _mm512_set1_epi16(1 << 15);
         let r = _mm512_maskz_shldi_epi16::<2>(0, a, b);
@@ -3591,7 +3591,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shldi_epi16() {
+    const fn test_mm256_shldi_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let r = _mm256_shldi_epi16::<2>(a, b);
@@ -3600,7 +3600,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shldi_epi16() {
+    const fn test_mm256_mask_shldi_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let r = _mm256_mask_shldi_epi16::<2>(a, 0, a, b);
@@ -3611,7 +3611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shldi_epi16() {
+    const fn test_mm256_maskz_shldi_epi16() {
         let a = _mm256_set1_epi16(1);
         let b = _mm256_set1_epi16(1 << 15);
         let r = _mm256_maskz_shldi_epi16::<2>(0, a, b);
@@ -3622,7 +3622,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shldi_epi16() {
+    const fn test_mm_shldi_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let r = _mm_shldi_epi16::<2>(a, b);
@@ -3631,7 +3631,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shldi_epi16() {
+    const fn test_mm_mask_shldi_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let r = _mm_mask_shldi_epi16::<2>(a, 0, a, b);
@@ -3642,7 +3642,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shldi_epi16() {
+    const fn test_mm_maskz_shldi_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(1 << 15);
         let r = _mm_maskz_shldi_epi16::<2>(0, a, b);
@@ -3653,7 +3653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdi_epi64() {
+    const fn test_mm512_shrdi_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let r = _mm512_shrdi_epi64::<1>(a, b);
@@ -3662,7 +3662,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdi_epi64() {
+    const fn test_mm512_mask_shrdi_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let r = _mm512_mask_shrdi_epi64::<1>(a, 0, a, b);
@@ -3673,7 +3673,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdi_epi64() {
+    const fn test_mm512_maskz_shrdi_epi64() {
         let a = _mm512_set1_epi64(2);
         let b = _mm512_set1_epi64(8);
         let r = _mm512_maskz_shrdi_epi64::<1>(0, a, b);
@@ -3684,7 +3684,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdi_epi64() {
+    const fn test_mm256_shrdi_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let r = _mm256_shrdi_epi64::<1>(a, b);
@@ -3693,7 +3693,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdi_epi64() {
+    const fn test_mm256_mask_shrdi_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let r = _mm256_mask_shrdi_epi64::<1>(a, 0, a, b);
@@ -3704,7 +3704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdi_epi64() {
+    const fn test_mm256_maskz_shrdi_epi64() {
         let a = _mm256_set1_epi64x(2);
         let b = _mm256_set1_epi64x(8);
         let r = _mm256_maskz_shrdi_epi64::<1>(0, a, b);
@@ -3715,7 +3715,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdi_epi64() {
+    const fn test_mm_shrdi_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let r = _mm_shrdi_epi64::<1>(a, b);
@@ -3724,7 +3724,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdi_epi64() {
+    const fn test_mm_mask_shrdi_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let r = _mm_mask_shrdi_epi64::<1>(a, 0, a, b);
@@ -3735,7 +3735,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdi_epi64() {
+    const fn test_mm_maskz_shrdi_epi64() {
         let a = _mm_set1_epi64x(2);
         let b = _mm_set1_epi64x(8);
         let r = _mm_maskz_shrdi_epi64::<1>(0, a, b);
@@ -3746,7 +3746,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdi_epi32() {
+    const fn test_mm512_shrdi_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let r = _mm512_shrdi_epi32::<1>(a, b);
@@ -3755,7 +3755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdi_epi32() {
+    const fn test_mm512_mask_shrdi_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let r = _mm512_mask_shrdi_epi32::<1>(a, 0, a, b);
@@ -3766,7 +3766,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdi_epi32() {
+    const fn test_mm512_maskz_shrdi_epi32() {
         let a = _mm512_set1_epi32(2);
         let b = _mm512_set1_epi32(8);
         let r = _mm512_maskz_shrdi_epi32::<1>(0, a, b);
@@ -3777,7 +3777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdi_epi32() {
+    const fn test_mm256_shrdi_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let r = _mm256_shrdi_epi32::<1>(a, b);
@@ -3786,7 +3786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdi_epi32() {
+    const fn test_mm256_mask_shrdi_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let r = _mm256_mask_shrdi_epi32::<1>(a, 0, a, b);
@@ -3797,7 +3797,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdi_epi32() {
+    const fn test_mm256_maskz_shrdi_epi32() {
         let a = _mm256_set1_epi32(2);
         let b = _mm256_set1_epi32(8);
         let r = _mm256_maskz_shrdi_epi32::<1>(0, a, b);
@@ -3808,7 +3808,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdi_epi32() {
+    const fn test_mm_shrdi_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let r = _mm_shrdi_epi32::<1>(a, b);
@@ -3817,7 +3817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdi_epi32() {
+    const fn test_mm_mask_shrdi_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let r = _mm_mask_shrdi_epi32::<1>(a, 0, a, b);
@@ -3828,7 +3828,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdi_epi32() {
+    const fn test_mm_maskz_shrdi_epi32() {
         let a = _mm_set1_epi32(2);
         let b = _mm_set1_epi32(8);
         let r = _mm_maskz_shrdi_epi32::<1>(0, a, b);
@@ -3839,7 +3839,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_shrdi_epi16() {
+    const fn test_mm512_shrdi_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let r = _mm512_shrdi_epi16::<1>(a, b);
@@ -3848,7 +3848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_mask_shrdi_epi16() {
+    const fn test_mm512_mask_shrdi_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let r = _mm512_mask_shrdi_epi16::<1>(a, 0, a, b);
@@ -3859,7 +3859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2")]
-    const unsafe fn test_mm512_maskz_shrdi_epi16() {
+    const fn test_mm512_maskz_shrdi_epi16() {
         let a = _mm512_set1_epi16(2);
         let b = _mm512_set1_epi16(8);
         let r = _mm512_maskz_shrdi_epi16::<1>(0, a, b);
@@ -3870,7 +3870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_shrdi_epi16() {
+    const fn test_mm256_shrdi_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let r = _mm256_shrdi_epi16::<1>(a, b);
@@ -3879,7 +3879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_mask_shrdi_epi16() {
+    const fn test_mm256_mask_shrdi_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let r = _mm256_mask_shrdi_epi16::<1>(a, 0, a, b);
@@ -3890,7 +3890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm256_maskz_shrdi_epi16() {
+    const fn test_mm256_maskz_shrdi_epi16() {
         let a = _mm256_set1_epi16(2);
         let b = _mm256_set1_epi16(8);
         let r = _mm256_maskz_shrdi_epi16::<1>(0, a, b);
@@ -3901,7 +3901,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_shrdi_epi16() {
+    const fn test_mm_shrdi_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let r = _mm_shrdi_epi16::<1>(a, b);
@@ -3910,7 +3910,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_mask_shrdi_epi16() {
+    const fn test_mm_mask_shrdi_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let r = _mm_mask_shrdi_epi16::<1>(a, 0, a, b);
@@ -3921,7 +3921,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vbmi2,avx512vl")]
-    const unsafe fn test_mm_maskz_shrdi_epi16() {
+    const fn test_mm_maskz_shrdi_epi16() {
         let a = _mm_set1_epi16(2);
         let b = _mm_set1_epi16(8);
         let r = _mm_maskz_shrdi_epi16::<1>(0, a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512vnni.rs b/library/stdarch/crates/core_arch/src/x86/avx512vnni.rs
index 93ea01cbb45b..49b790b15104 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512vnni.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512vnni.rs
@@ -970,7 +970,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_dpwssd_epi32() {
+    fn test_mm512_dpwssd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -980,7 +980,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_mask_dpwssd_epi32() {
+    fn test_mm512_mask_dpwssd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -992,7 +992,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_maskz_dpwssd_epi32() {
+    fn test_mm512_maskz_dpwssd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -1004,7 +1004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm256_dpwssd_avx_epi32() {
+    fn test_mm256_dpwssd_avx_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1014,7 +1014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_dpwssd_epi32() {
+    fn test_mm256_dpwssd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1024,7 +1024,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_mask_dpwssd_epi32() {
+    fn test_mm256_mask_dpwssd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1036,7 +1036,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_maskz_dpwssd_epi32() {
+    fn test_mm256_maskz_dpwssd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1048,7 +1048,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm_dpwssd_avx_epi32() {
+    fn test_mm_dpwssd_avx_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1058,7 +1058,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_dpwssd_epi32() {
+    fn test_mm_dpwssd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1068,7 +1068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_mask_dpwssd_epi32() {
+    fn test_mm_mask_dpwssd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1080,7 +1080,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_maskz_dpwssd_epi32() {
+    fn test_mm_maskz_dpwssd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1092,7 +1092,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_dpwssds_epi32() {
+    fn test_mm512_dpwssds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -1102,7 +1102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_mask_dpwssds_epi32() {
+    fn test_mm512_mask_dpwssds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -1114,7 +1114,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_maskz_dpwssds_epi32() {
+    fn test_mm512_maskz_dpwssds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 16 | 1 << 0);
@@ -1126,7 +1126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm256_dpwssds_avx_epi32() {
+    fn test_mm256_dpwssds_avx_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1136,7 +1136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_dpwssds_epi32() {
+    fn test_mm256_dpwssds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1146,7 +1146,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_mask_dpwssds_epi32() {
+    fn test_mm256_mask_dpwssds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1158,7 +1158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_maskz_dpwssds_epi32() {
+    fn test_mm256_maskz_dpwssds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1170,7 +1170,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm_dpwssds_avx_epi32() {
+    fn test_mm_dpwssds_avx_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1180,7 +1180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_dpwssds_epi32() {
+    fn test_mm_dpwssds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1190,7 +1190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_mask_dpwssds_epi32() {
+    fn test_mm_mask_dpwssds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1202,7 +1202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_maskz_dpwssds_epi32() {
+    fn test_mm_maskz_dpwssds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1214,7 +1214,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_dpbusd_epi32() {
+    fn test_mm512_dpbusd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1224,7 +1224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_mask_dpbusd_epi32() {
+    fn test_mm512_mask_dpbusd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1236,7 +1236,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_maskz_dpbusd_epi32() {
+    fn test_mm512_maskz_dpbusd_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1248,7 +1248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm256_dpbusd_avx_epi32() {
+    fn test_mm256_dpbusd_avx_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1258,7 +1258,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_dpbusd_epi32() {
+    fn test_mm256_dpbusd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1268,7 +1268,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_mask_dpbusd_epi32() {
+    fn test_mm256_mask_dpbusd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1280,7 +1280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_maskz_dpbusd_epi32() {
+    fn test_mm256_maskz_dpbusd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1292,7 +1292,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm_dpbusd_avx_epi32() {
+    fn test_mm_dpbusd_avx_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1302,7 +1302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_dpbusd_epi32() {
+    fn test_mm_dpbusd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1312,7 +1312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_mask_dpbusd_epi32() {
+    fn test_mm_mask_dpbusd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1324,7 +1324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_maskz_dpbusd_epi32() {
+    fn test_mm_maskz_dpbusd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1336,7 +1336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_dpbusds_epi32() {
+    fn test_mm512_dpbusds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1346,7 +1346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_mask_dpbusds_epi32() {
+    fn test_mm512_mask_dpbusds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1358,7 +1358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni")]
-    unsafe fn test_mm512_maskz_dpbusds_epi32() {
+    fn test_mm512_maskz_dpbusds_epi32() {
         let src = _mm512_set1_epi32(1);
         let a = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm512_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1370,7 +1370,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm256_dpbusds_avx_epi32() {
+    fn test_mm256_dpbusds_avx_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1380,7 +1380,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_dpbusds_epi32() {
+    fn test_mm256_dpbusds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1390,7 +1390,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_mask_dpbusds_epi32() {
+    fn test_mm256_mask_dpbusds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1402,7 +1402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm256_maskz_dpbusds_epi32() {
+    fn test_mm256_maskz_dpbusds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1414,7 +1414,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnni")]
-    unsafe fn test_mm_dpbusds_avx_epi32() {
+    fn test_mm_dpbusds_avx_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1424,7 +1424,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_dpbusds_epi32() {
+    fn test_mm_dpbusds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1434,7 +1434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_mask_dpbusds_epi32() {
+    fn test_mm_mask_dpbusds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1446,7 +1446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vnni,avx512vl")]
-    unsafe fn test_mm_maskz_dpbusds_epi32() {
+    fn test_mm_maskz_dpbusds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1458,7 +1458,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbssd_epi32() {
+    fn test_mm_dpbssd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1468,7 +1468,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbssd_epi32() {
+    fn test_mm256_dpbssd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1478,7 +1478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbssds_epi32() {
+    fn test_mm_dpbssds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1488,7 +1488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbssds_epi32() {
+    fn test_mm256_dpbssds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1498,7 +1498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbsud_epi32() {
+    fn test_mm_dpbsud_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1508,7 +1508,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbsud_epi32() {
+    fn test_mm256_dpbsud_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1518,7 +1518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbsuds_epi32() {
+    fn test_mm_dpbsuds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1528,7 +1528,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbsuds_epi32() {
+    fn test_mm256_dpbsuds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1538,7 +1538,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbuud_epi32() {
+    fn test_mm_dpbuud_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1548,7 +1548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbuud_epi32() {
+    fn test_mm256_dpbuud_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1558,7 +1558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm_dpbuuds_epi32() {
+    fn test_mm_dpbuuds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1568,7 +1568,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint8")]
-    unsafe fn test_mm256_dpbuuds_epi32() {
+    fn test_mm256_dpbuuds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 24 | 1 << 16 | 1 << 8 | 1 << 0);
@@ -1578,7 +1578,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwsud_epi32() {
+    fn test_mm_dpwsud_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1588,7 +1588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwsud_epi32() {
+    fn test_mm256_dpwsud_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1598,7 +1598,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwsuds_epi32() {
+    fn test_mm_dpwsuds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1608,7 +1608,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwsuds_epi32() {
+    fn test_mm256_dpwsuds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1618,7 +1618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwusd_epi32() {
+    fn test_mm_dpwusd_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1628,7 +1628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwusd_epi32() {
+    fn test_mm256_dpwusd_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1638,7 +1638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwusds_epi32() {
+    fn test_mm_dpwusds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1648,7 +1648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwusds_epi32() {
+    fn test_mm256_dpwusds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1658,7 +1658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwuud_epi32() {
+    fn test_mm_dpwuud_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1668,7 +1668,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwuud_epi32() {
+    fn test_mm256_dpwuud_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
@@ -1678,7 +1678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm_dpwuuds_epi32() {
+    fn test_mm_dpwuuds_epi32() {
         let src = _mm_set1_epi32(1);
         let a = _mm_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm_set1_epi32(1 << 16 | 1 << 0);
@@ -1688,7 +1688,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avxvnniint16")]
-    unsafe fn test_mm256_dpwuuds_epi32() {
+    fn test_mm256_dpwuuds_epi32() {
         let src = _mm256_set1_epi32(1);
         let a = _mm256_set1_epi32(1 << 16 | 1 << 0);
         let b = _mm256_set1_epi32(1 << 16 | 1 << 0);
diff --git a/library/stdarch/crates/core_arch/src/x86/avx512vpopcntdq.rs b/library/stdarch/crates/core_arch/src/x86/avx512vpopcntdq.rs
index 38ef54b550fd..476640fab561 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512vpopcntdq.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512vpopcntdq.rs
@@ -351,7 +351,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_popcnt_epi32() {
+    const fn test_mm512_popcnt_epi32() {
         let test_data = _mm512_set_epi32(
             0,
             1,
@@ -377,7 +377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_mask_popcnt_epi32() {
+    const fn test_mm512_mask_popcnt_epi32() {
         let test_data = _mm512_set_epi32(
             0,
             1,
@@ -420,7 +420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_maskz_popcnt_epi32() {
+    const fn test_mm512_maskz_popcnt_epi32() {
         let test_data = _mm512_set_epi32(
             0,
             1,
@@ -446,7 +446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm256_popcnt_epi32() {
+    const fn test_mm256_popcnt_epi32() {
         let test_data = _mm256_set_epi32(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF, -100);
         let actual_result = _mm256_popcnt_epi32(test_data);
         let reference_result = _mm256_set_epi32(0, 1, 32, 1, 3, 15, 31, 28);
@@ -454,7 +454,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_popcnt_epi32() {
+    const fn test_mm256_mask_popcnt_epi32() {
         let test_data = _mm256_set_epi32(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF, -100);
         let mask = 0xF0;
         let actual_result = _mm256_mask_popcnt_epi32(test_data, mask, test_data);
@@ -463,7 +463,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_popcnt_epi32() {
+    const fn test_mm256_maskz_popcnt_epi32() {
         let test_data = _mm256_set_epi32(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF, -100);
         let mask = 0xF0;
         let actual_result = _mm256_maskz_popcnt_epi32(mask, test_data);
@@ -472,7 +472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm_popcnt_epi32() {
+    const fn test_mm_popcnt_epi32() {
         let test_data = _mm_set_epi32(0, 1, -1, -100);
         let actual_result = _mm_popcnt_epi32(test_data);
         let reference_result = _mm_set_epi32(0, 1, 32, 28);
@@ -480,7 +480,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_popcnt_epi32() {
+    const fn test_mm_mask_popcnt_epi32() {
         let test_data = _mm_set_epi32(0, 1, -1, -100);
         let mask = 0xE;
         let actual_result = _mm_mask_popcnt_epi32(test_data, mask, test_data);
@@ -489,7 +489,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_popcnt_epi32() {
+    const fn test_mm_maskz_popcnt_epi32() {
         let test_data = _mm_set_epi32(0, 1, -1, -100);
         let mask = 0xE;
         let actual_result = _mm_maskz_popcnt_epi32(mask, test_data);
@@ -498,7 +498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_popcnt_epi64() {
+    const fn test_mm512_popcnt_epi64() {
         let test_data = _mm512_set_epi64(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF_FF_FF_FF_FF, -100);
         let actual_result = _mm512_popcnt_epi64(test_data);
         let reference_result = _mm512_set_epi64(0, 1, 64, 1, 3, 15, 63, 60);
@@ -506,7 +506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_mask_popcnt_epi64() {
+    const fn test_mm512_mask_popcnt_epi64() {
         let test_data = _mm512_set_epi64(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF_FF_FF_FF_FF, -100);
         let mask = 0xF0;
         let actual_result = _mm512_mask_popcnt_epi64(test_data, mask, test_data);
@@ -516,7 +516,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512f")]
-    const unsafe fn test_mm512_maskz_popcnt_epi64() {
+    const fn test_mm512_maskz_popcnt_epi64() {
         let test_data = _mm512_set_epi64(0, 1, -1, 2, 7, 0xFF_FE, 0x7F_FF_FF_FF_FF_FF_FF_FF, -100);
         let mask = 0xF0;
         let actual_result = _mm512_maskz_popcnt_epi64(mask, test_data);
@@ -525,7 +525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm256_popcnt_epi64() {
+    const fn test_mm256_popcnt_epi64() {
         let test_data = _mm256_set_epi64x(0, 1, -1, -100);
         let actual_result = _mm256_popcnt_epi64(test_data);
         let reference_result = _mm256_set_epi64x(0, 1, 64, 60);
@@ -533,7 +533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm256_mask_popcnt_epi64() {
+    const fn test_mm256_mask_popcnt_epi64() {
         let test_data = _mm256_set_epi64x(0, 1, -1, -100);
         let mask = 0xE;
         let actual_result = _mm256_mask_popcnt_epi64(test_data, mask, test_data);
@@ -542,7 +542,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm256_maskz_popcnt_epi64() {
+    const fn test_mm256_maskz_popcnt_epi64() {
         let test_data = _mm256_set_epi64x(0, 1, -1, -100);
         let mask = 0xE;
         let actual_result = _mm256_maskz_popcnt_epi64(mask, test_data);
@@ -551,7 +551,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm_popcnt_epi64() {
+    const fn test_mm_popcnt_epi64() {
         let test_data = _mm_set_epi64x(0, 1);
         let actual_result = _mm_popcnt_epi64(test_data);
         let reference_result = _mm_set_epi64x(0, 1);
@@ -563,7 +563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm_mask_popcnt_epi64() {
+    const fn test_mm_mask_popcnt_epi64() {
         let test_data = _mm_set_epi64x(0, -100);
         let mask = 0x2;
         let actual_result = _mm_mask_popcnt_epi64(test_data, mask, test_data);
@@ -577,7 +577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512vpopcntdq,avx512vl")]
-    const unsafe fn test_mm_maskz_popcnt_epi64() {
+    const fn test_mm_maskz_popcnt_epi64() {
         let test_data = _mm_set_epi64x(0, 1);
         let mask = 0x2;
         let actual_result = _mm_maskz_popcnt_epi64(mask, test_data);
diff --git a/library/stdarch/crates/core_arch/src/x86/avxneconvert.rs b/library/stdarch/crates/core_arch/src/x86/avxneconvert.rs
index b92ec823ec64..a53d6d97e8a0 100644
--- a/library/stdarch/crates/core_arch/src/x86/avxneconvert.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avxneconvert.rs
@@ -87,7 +87,7 @@ pub unsafe fn _mm256_cvtneebf16_ps(a: *const __m256bh) -> __m256 {
 #[inline]
 #[target_feature(enable = "avxneconvert")]
 #[cfg_attr(test, assert_instr(vcvtneeph2ps))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub unsafe fn _mm_cvtneeph_ps(a: *const __m128h) -> __m128 {
     transmute(cvtneeph2ps_128(a))
 }
@@ -99,7 +99,7 @@ pub unsafe fn _mm_cvtneeph_ps(a: *const __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avxneconvert")]
 #[cfg_attr(test, assert_instr(vcvtneeph2ps))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub unsafe fn _mm256_cvtneeph_ps(a: *const __m256h) -> __m256 {
     transmute(cvtneeph2ps_256(a))
 }
@@ -135,7 +135,7 @@ pub unsafe fn _mm256_cvtneobf16_ps(a: *const __m256bh) -> __m256 {
 #[inline]
 #[target_feature(enable = "avxneconvert")]
 #[cfg_attr(test, assert_instr(vcvtneoph2ps))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub unsafe fn _mm_cvtneoph_ps(a: *const __m128h) -> __m128 {
     transmute(cvtneoph2ps_128(a))
 }
@@ -147,7 +147,7 @@ pub unsafe fn _mm_cvtneoph_ps(a: *const __m128h) -> __m128 {
 #[inline]
 #[target_feature(enable = "avxneconvert")]
 #[cfg_attr(test, assert_instr(vcvtneoph2ps))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub unsafe fn _mm256_cvtneoph_ps(a: *const __m256h) -> __m256 {
     transmute(cvtneoph2ps_256(a))
 }
diff --git a/library/stdarch/crates/core_arch/src/x86/bmi1.rs b/library/stdarch/crates/core_arch/src/x86/bmi1.rs
index 11d66f699a12..432051abd1cf 100644
--- a/library/stdarch/crates/core_arch/src/x86/bmi1.rs
+++ b/library/stdarch/crates/core_arch/src/x86/bmi1.rs
@@ -144,13 +144,13 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "bmi1")]
-    unsafe fn test_bextr_u32() {
+    fn test_bextr_u32() {
         let r = _bextr_u32(0b0101_0000u32, 4, 4);
         assert_eq!(r, 0b0000_0101u32);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_andn_u32() {
+    const fn test_andn_u32() {
         assert_eq!(_andn_u32(0, 0), 0);
         assert_eq!(_andn_u32(0, 1), 1);
         assert_eq!(_andn_u32(1, 0), 0);
@@ -173,32 +173,32 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsi_u32() {
+    const fn test_blsi_u32() {
         assert_eq!(_blsi_u32(0b1101_0000u32), 0b0001_0000u32);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsmsk_u32() {
+    const fn test_blsmsk_u32() {
         let r = _blsmsk_u32(0b0011_0000u32);
         assert_eq!(r, 0b0001_1111u32);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsr_u32() {
+    const fn test_blsr_u32() {
         // TODO: test the behavior when the input is `0`.
         let r = _blsr_u32(0b0011_0000u32);
         assert_eq!(r, 0b0010_0000u32);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_tzcnt_u16() {
+    const fn test_tzcnt_u16() {
         assert_eq!(_tzcnt_u16(0b0000_0001u16), 0u16);
         assert_eq!(_tzcnt_u16(0b0000_0000u16), 16u16);
         assert_eq!(_tzcnt_u16(0b1001_0000u16), 4u16);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_tzcnt_u32() {
+    const fn test_tzcnt_u32() {
         assert_eq!(_tzcnt_u32(0b0000_0001u32), 0u32);
         assert_eq!(_tzcnt_u32(0b0000_0000u32), 32u32);
         assert_eq!(_tzcnt_u32(0b1001_0000u32), 4u32);
diff --git a/library/stdarch/crates/core_arch/src/x86/bmi2.rs b/library/stdarch/crates/core_arch/src/x86/bmi2.rs
index 54d3b5387ec7..5320640d9687 100644
--- a/library/stdarch/crates/core_arch/src/x86/bmi2.rs
+++ b/library/stdarch/crates/core_arch/src/x86/bmi2.rs
@@ -84,7 +84,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_pext_u32() {
+    fn test_pext_u32() {
         let n = 0b1011_1110_1001_0011u32;
 
         let m0 = 0b0110_0011_1000_0101u32;
@@ -98,7 +98,7 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_pdep_u32() {
+    fn test_pdep_u32() {
         let n = 0b1011_1110_1001_0011u32;
 
         let m0 = 0b0110_0011_1000_0101u32;
@@ -112,14 +112,14 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_bzhi_u32() {
+    fn test_bzhi_u32() {
         let n = 0b1111_0010u32;
         let s = 0b0001_0010u32;
         assert_eq!(_bzhi_u32(n, 5), s);
     }
 
     #[simd_test(enable = "bmi2")]
-    const unsafe fn test_mulx_u32() {
+    const fn test_mulx_u32() {
         let a: u32 = 4_294_967_200;
         let b: u32 = 2;
         let mut hi = 0;
diff --git a/library/stdarch/crates/core_arch/src/x86/f16c.rs b/library/stdarch/crates/core_arch/src/x86/f16c.rs
index 09971939ba44..0a26a9ff8d25 100644
--- a/library/stdarch/crates/core_arch/src/x86/f16c.rs
+++ b/library/stdarch/crates/core_arch/src/x86/f16c.rs
@@ -119,7 +119,7 @@ mod tests {
     const F16_EIGHT: i16 = 0x4800;
 
     #[simd_test(enable = "f16c")]
-    const unsafe fn test_mm_cvtph_ps() {
+    const fn test_mm_cvtph_ps() {
         let a = _mm_set_epi16(0, 0, 0, 0, F16_ONE, F16_TWO, F16_THREE, F16_FOUR);
         let r = _mm_cvtph_ps(a);
         let e = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
@@ -127,7 +127,7 @@ mod tests {
     }
 
     #[simd_test(enable = "f16c")]
-    const unsafe fn test_mm256_cvtph_ps() {
+    const fn test_mm256_cvtph_ps() {
         let a = _mm_set_epi16(
             F16_ONE, F16_TWO, F16_THREE, F16_FOUR, F16_FIVE, F16_SIX, F16_SEVEN, F16_EIGHT,
         );
@@ -137,7 +137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "f16c")]
-    unsafe fn test_mm_cvtps_ph() {
+    fn test_mm_cvtps_ph() {
         let a = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_cvtps_ph::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm_set_epi16(0, 0, 0, 0, F16_ONE, F16_TWO, F16_THREE, F16_FOUR);
@@ -145,7 +145,7 @@ mod tests {
     }
 
     #[simd_test(enable = "f16c")]
-    unsafe fn test_mm256_cvtps_ph() {
+    fn test_mm256_cvtps_ph() {
         let a = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm256_cvtps_ph::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm_set_epi16(
diff --git a/library/stdarch/crates/core_arch/src/x86/fma.rs b/library/stdarch/crates/core_arch/src/x86/fma.rs
index c0900e61d92d..b95bb331dfb0 100644
--- a/library/stdarch/crates/core_arch/src/x86/fma.rs
+++ b/library/stdarch/crates/core_arch/src/x86/fma.rs
@@ -560,7 +560,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmadd_pd() {
+    const fn test_mm_fmadd_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -569,7 +569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmadd_pd() {
+    const fn test_mm256_fmadd_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -578,7 +578,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmadd_ps() {
+    const fn test_mm_fmadd_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -587,7 +587,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmadd_ps() {
+    const fn test_mm256_fmadd_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -596,7 +596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmadd_sd() {
+    const fn test_mm_fmadd_sd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -605,7 +605,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmadd_ss() {
+    const fn test_mm_fmadd_ss() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -614,7 +614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmaddsub_pd() {
+    const fn test_mm_fmaddsub_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -623,7 +623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmaddsub_pd() {
+    const fn test_mm256_fmaddsub_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -632,7 +632,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmaddsub_ps() {
+    const fn test_mm_fmaddsub_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -641,7 +641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmaddsub_ps() {
+    const fn test_mm256_fmaddsub_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -650,7 +650,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsub_pd() {
+    const fn test_mm_fmsub_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -659,7 +659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmsub_pd() {
+    const fn test_mm256_fmsub_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -668,7 +668,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsub_ps() {
+    const fn test_mm_fmsub_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -677,7 +677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmsub_ps() {
+    const fn test_mm256_fmsub_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -686,7 +686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsub_sd() {
+    const fn test_mm_fmsub_sd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -695,7 +695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsub_ss() {
+    const fn test_mm_fmsub_ss() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -704,7 +704,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsubadd_pd() {
+    const fn test_mm_fmsubadd_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -713,7 +713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmsubadd_pd() {
+    const fn test_mm256_fmsubadd_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -722,7 +722,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fmsubadd_ps() {
+    const fn test_mm_fmsubadd_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -731,7 +731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fmsubadd_ps() {
+    const fn test_mm256_fmsubadd_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -740,7 +740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmadd_pd() {
+    const fn test_mm_fnmadd_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -749,7 +749,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fnmadd_pd() {
+    const fn test_mm256_fnmadd_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -758,7 +758,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmadd_ps() {
+    const fn test_mm_fnmadd_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -767,7 +767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fnmadd_ps() {
+    const fn test_mm256_fnmadd_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -776,7 +776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmadd_sd() {
+    const fn test_mm_fnmadd_sd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -785,7 +785,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmadd_ss() {
+    const fn test_mm_fnmadd_ss() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -794,7 +794,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmsub_pd() {
+    const fn test_mm_fnmsub_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -803,7 +803,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fnmsub_pd() {
+    const fn test_mm256_fnmsub_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 3., 7., 2.);
         let c = _mm256_setr_pd(4., 9., 1., 7.);
@@ -812,7 +812,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmsub_ps() {
+    const fn test_mm_fnmsub_ps() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
@@ -821,7 +821,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm256_fnmsub_ps() {
+    const fn test_mm256_fnmsub_ps() {
         let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
         let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
         let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
@@ -830,7 +830,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmsub_sd() {
+    const fn test_mm_fnmsub_sd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(5., 3.);
         let c = _mm_setr_pd(4., 9.);
@@ -839,7 +839,7 @@ mod tests {
     }
 
     #[simd_test(enable = "fma")]
-    const unsafe fn test_mm_fnmsub_ss() {
+    const fn test_mm_fnmsub_ss() {
         let a = _mm_setr_ps(1., 2., 3., 4.);
         let b = _mm_setr_ps(5., 3., 7., 2.);
         let c = _mm_setr_ps(4., 9., 1., 7.);
diff --git a/library/stdarch/crates/core_arch/src/x86/mod.rs b/library/stdarch/crates/core_arch/src/x86/mod.rs
index 7612cffd078a..c40fbd3ca317 100644
--- a/library/stdarch/crates/core_arch/src/x86/mod.rs
+++ b/library/stdarch/crates/core_arch/src/x86/mod.rs
@@ -401,7 +401,7 @@ types! {
 }
 
 types! {
-    #![unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+    #![stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 
     /// 128-bit wide set of 8 `f16` types, x86-specific
     ///
@@ -768,7 +768,7 @@ mod avxneconvert;
 pub use self::avxneconvert::*;
 
 mod avx512fp16;
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub use self::avx512fp16::*;
 
 mod kl;
diff --git a/library/stdarch/crates/core_arch/src/x86/pclmulqdq.rs b/library/stdarch/crates/core_arch/src/x86/pclmulqdq.rs
index efc01190305e..0f2769257f95 100644
--- a/library/stdarch/crates/core_arch/src/x86/pclmulqdq.rs
+++ b/library/stdarch/crates/core_arch/src/x86/pclmulqdq.rs
@@ -45,7 +45,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "pclmulqdq")]
-    unsafe fn test_mm_clmulepi64_si128() {
+    fn test_mm_clmulepi64_si128() {
         // Constants taken from https://software.intel.com/sites/default/files/managed/72/cc/clmul-wp-rev-2.02-2014-04-20.pdf
         let a = _mm_set_epi64x(0x7b5b546573745665, 0x63746f725d53475d);
         let b = _mm_set_epi64x(0x4869285368617929, 0x5b477565726f6e5d);
diff --git a/library/stdarch/crates/core_arch/src/x86/sha.rs b/library/stdarch/crates/core_arch/src/x86/sha.rs
index 9ad1a9f14c15..f8a3295d1958 100644
--- a/library/stdarch/crates/core_arch/src/x86/sha.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sha.rs
@@ -286,7 +286,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha1msg1_epu32() {
+    fn test_mm_sha1msg1_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0x98829f34f74ad457, 0xda2b1a44d0b5ad3c);
@@ -296,7 +296,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha1msg2_epu32() {
+    fn test_mm_sha1msg2_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0xf714b202d863d47d, 0x90c30d946b3d3b35);
@@ -306,7 +306,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha1nexte_epu32() {
+    fn test_mm_sha1nexte_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0x2589d5be923f82a4, 0x59f111f13956c25b);
@@ -316,7 +316,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha1rnds4_epu32() {
+    fn test_mm_sha1rnds4_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0x32b13cd8322f5268, 0xc54420862bd9246f);
@@ -338,7 +338,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha256msg1_epu32() {
+    fn test_mm_sha256msg1_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0xeb84973fd5cda67d, 0x2857b88f406b09ee);
@@ -348,7 +348,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha256msg2_epu32() {
+    fn test_mm_sha256msg2_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let expected = _mm_set_epi64x(0xb58777ce887fd851, 0x15d1ec8b73ac8450);
@@ -358,7 +358,7 @@ mod tests {
 
     #[simd_test(enable = "sha")]
     #[allow(overflowing_literals)]
-    unsafe fn test_mm_sha256rnds2_epu32() {
+    fn test_mm_sha256rnds2_epu32() {
         let a = _mm_set_epi64x(0xe9b5dba5b5c0fbcf, 0x71374491428a2f98);
         let b = _mm_set_epi64x(0xab1c5ed5923f82a4, 0x59f111f13956c25b);
         let k = _mm_set_epi64x(0, 0x12835b01d807aa98);
@@ -381,7 +381,7 @@ mod tests {
     ];
 
     #[simd_test(enable = "sha512,avx")]
-    unsafe fn test_mm256_sha512msg1_epi64() {
+    fn test_mm256_sha512msg1_epi64() {
         fn s0(word: u64) -> u64 {
             word.rotate_right(1) ^ word.rotate_right(8) ^ (word >> 7)
         }
@@ -389,8 +389,8 @@ mod tests {
         let A = &DATA_64[0..4];
         let B = &DATA_64[4..6];
 
-        let a = _mm256_loadu_si256(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
+        let a = unsafe { _mm256_loadu_si256(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
 
         let r = _mm256_sha512msg1_epi64(a, b);
 
@@ -405,7 +405,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sha512,avx")]
-    unsafe fn test_mm256_sha512msg2_epi64() {
+    fn test_mm256_sha512msg2_epi64() {
         fn s1(word: u64) -> u64 {
             word.rotate_right(19) ^ word.rotate_right(61) ^ (word >> 6)
         }
@@ -413,8 +413,8 @@ mod tests {
         let A = &DATA_64[0..4];
         let B = &DATA_64[4..8];
 
-        let a = _mm256_loadu_si256(A.as_ptr().cast());
-        let b = _mm256_loadu_si256(B.as_ptr().cast());
+        let a = unsafe { _mm256_loadu_si256(A.as_ptr().cast()) };
+        let b = unsafe { _mm256_loadu_si256(B.as_ptr().cast()) };
 
         let r = _mm256_sha512msg2_epi64(a, b);
 
@@ -431,7 +431,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sha512,avx")]
-    unsafe fn test_mm256_sha512rnds2_epi64() {
+    fn test_mm256_sha512rnds2_epi64() {
         fn cap_sigma0(word: u64) -> u64 {
             word.rotate_right(28) ^ word.rotate_right(34) ^ word.rotate_right(39)
         }
@@ -452,9 +452,9 @@ mod tests {
         let B = &DATA_64[4..8];
         let K = &DATA_64[8..10];
 
-        let a = _mm256_loadu_si256(A.as_ptr().cast());
-        let b = _mm256_loadu_si256(B.as_ptr().cast());
-        let k = _mm_loadu_si128(K.as_ptr().cast());
+        let a = unsafe { _mm256_loadu_si256(A.as_ptr().cast()) };
+        let b = unsafe { _mm256_loadu_si256(B.as_ptr().cast()) };
+        let k = unsafe { _mm_loadu_si128(K.as_ptr().cast()) };
 
         let r = _mm256_sha512rnds2_epi64(a, b, k);
 
@@ -482,7 +482,7 @@ mod tests {
     ];
 
     #[simd_test(enable = "sm3,avx")]
-    unsafe fn test_mm_sm3msg1_epi32() {
+    fn test_mm_sm3msg1_epi32() {
         fn p1(x: u32) -> u32 {
             x ^ x.rotate_left(15) ^ x.rotate_left(23)
         }
@@ -490,9 +490,9 @@ mod tests {
         let B = &DATA_32[4..8];
         let C = &DATA_32[8..12];
 
-        let a = _mm_loadu_si128(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
-        let c = _mm_loadu_si128(C.as_ptr().cast());
+        let a = unsafe { _mm_loadu_si128(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
+        let c = unsafe { _mm_loadu_si128(C.as_ptr().cast()) };
 
         let r = _mm_sm3msg1_epi32(a, b, c);
 
@@ -507,14 +507,14 @@ mod tests {
     }
 
     #[simd_test(enable = "sm3,avx")]
-    unsafe fn test_mm_sm3msg2_epi32() {
+    fn test_mm_sm3msg2_epi32() {
         let A = &DATA_32[0..4];
         let B = &DATA_32[4..8];
         let C = &DATA_32[8..12];
 
-        let a = _mm_loadu_si128(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
-        let c = _mm_loadu_si128(C.as_ptr().cast());
+        let a = unsafe { _mm_loadu_si128(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
+        let c = unsafe { _mm_loadu_si128(C.as_ptr().cast()) };
 
         let r = _mm_sm3msg2_epi32(a, b, c);
 
@@ -535,7 +535,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sm3,avx")]
-    unsafe fn test_mm_sm3rnds2_epi32() {
+    fn test_mm_sm3rnds2_epi32() {
         fn p0(x: u32) -> u32 {
             x ^ x.rotate_left(9) ^ x.rotate_left(17)
         }
@@ -560,9 +560,9 @@ mod tests {
         let B = &DATA_32[4..8];
         let C = &DATA_32[8..12];
 
-        let a = _mm_loadu_si128(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
-        let c = _mm_loadu_si128(C.as_ptr().cast());
+        let a = unsafe { _mm_loadu_si128(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
+        let c = unsafe { _mm_loadu_si128(C.as_ptr().cast()) };
 
         let r = _mm_sm3rnds2_epi32::<{ ROUND as i32 }>(a, b, c);
 
@@ -641,7 +641,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sm4,avx")]
-    unsafe fn test_mm_sm4key4_epi32() {
+    fn test_mm_sm4key4_epi32() {
         fn l_key(x: u32) -> u32 {
             x ^ x.rotate_left(13) ^ x.rotate_left(23)
         }
@@ -652,8 +652,8 @@ mod tests {
         let A = &DATA_32[0..4];
         let B = &DATA_32[4..8];
 
-        let a = _mm_loadu_si128(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
+        let a = unsafe { _mm_loadu_si128(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
 
         let r = _mm_sm4key4_epi32(a, b);
 
@@ -667,11 +667,11 @@ mod tests {
     }
 
     #[simd_test(enable = "sm4,avx")]
-    unsafe fn test_mm256_sm4key4_epi32() {
-        let a_low = _mm_loadu_si128(DATA_32.as_ptr().cast());
-        let a_high = _mm_loadu_si128(DATA_32[4..].as_ptr().cast());
-        let b_low = _mm_loadu_si128(DATA_32[8..].as_ptr().cast());
-        let b_high = _mm_loadu_si128(DATA_32[12..].as_ptr().cast());
+    fn test_mm256_sm4key4_epi32() {
+        let a_low = unsafe { _mm_loadu_si128(DATA_32.as_ptr().cast()) };
+        let a_high = unsafe { _mm_loadu_si128(DATA_32[4..].as_ptr().cast()) };
+        let b_low = unsafe { _mm_loadu_si128(DATA_32[8..].as_ptr().cast()) };
+        let b_high = unsafe { _mm_loadu_si128(DATA_32[12..].as_ptr().cast()) };
 
         let a = _mm256_set_m128i(a_high, a_low);
         let b = _mm256_set_m128i(b_high, b_low);
@@ -686,7 +686,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sm4,avx")]
-    unsafe fn test_mm_sm4rnds4_epi32() {
+    fn test_mm_sm4rnds4_epi32() {
         fn l_rnd(x: u32) -> u32 {
             x ^ x.rotate_left(2) ^ x.rotate_left(10) ^ x.rotate_left(18) ^ x.rotate_left(24)
         }
@@ -697,8 +697,8 @@ mod tests {
         let A = &DATA_32[0..4];
         let B = &DATA_32[4..8];
 
-        let a = _mm_loadu_si128(A.as_ptr().cast());
-        let b = _mm_loadu_si128(B.as_ptr().cast());
+        let a = unsafe { _mm_loadu_si128(A.as_ptr().cast()) };
+        let b = unsafe { _mm_loadu_si128(B.as_ptr().cast()) };
 
         let r = _mm_sm4rnds4_epi32(a, b);
 
@@ -712,11 +712,11 @@ mod tests {
     }
 
     #[simd_test(enable = "sm4,avx")]
-    unsafe fn test_mm256_sm4rnds4_epi32() {
-        let a_low = _mm_loadu_si128(DATA_32.as_ptr().cast());
-        let a_high = _mm_loadu_si128(DATA_32[4..].as_ptr().cast());
-        let b_low = _mm_loadu_si128(DATA_32[8..].as_ptr().cast());
-        let b_high = _mm_loadu_si128(DATA_32[12..].as_ptr().cast());
+    fn test_mm256_sm4rnds4_epi32() {
+        let a_low = unsafe { _mm_loadu_si128(DATA_32.as_ptr().cast()) };
+        let a_high = unsafe { _mm_loadu_si128(DATA_32[4..].as_ptr().cast()) };
+        let b_low = unsafe { _mm_loadu_si128(DATA_32[8..].as_ptr().cast()) };
+        let b_high = unsafe { _mm_loadu_si128(DATA_32[12..].as_ptr().cast()) };
 
         let a = _mm256_set_m128i(a_high, a_low);
         let b = _mm256_set_m128i(b_high, b_low);
diff --git a/library/stdarch/crates/core_arch/src/x86/sse.rs b/library/stdarch/crates/core_arch/src/x86/sse.rs
index 165c61104e1a..751f969e50c3 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse.rs
@@ -1947,7 +1947,7 @@ pub fn _mm_prefetch<const STRATEGY: i32>(p: *const i8) {
     }
 }
 
-/// Returns vector of type __m128 with indeterminate elements.with indetermination elements.
+/// Returns vector of type __m128 with indeterminate elements.
 /// Despite using the word "undefined" (following Intel's naming scheme), this non-deterministically
 /// picks some valid value and is not equivalent to [`mem::MaybeUninit`].
 /// In practice, this is typically equivalent to [`mem::zeroed`].
@@ -2088,7 +2088,7 @@ mod tests {
     const NAN: f32 = f32::NAN;
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_add_ps() {
+    const fn test_mm_add_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_add_ps(a, b);
@@ -2096,7 +2096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_add_ss() {
+    const 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);
@@ -2104,7 +2104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_sub_ps() {
+    const fn test_mm_sub_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_sub_ps(a, b);
@@ -2112,7 +2112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_sub_ss() {
+    const 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);
@@ -2120,7 +2120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_mul_ps() {
+    const fn test_mm_mul_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_mul_ps(a, b);
@@ -2128,7 +2128,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_mul_ss() {
+    const 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);
@@ -2136,7 +2136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_div_ps() {
+    const fn test_mm_div_ps() {
         let a = _mm_setr_ps(-1.0, 5.0, 2.0, -10.0);
         let b = _mm_setr_ps(-100.0, 20.0, 0.2, -5.0);
         let r = _mm_div_ps(a, b);
@@ -2144,7 +2144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_div_ss() {
+    const 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);
@@ -2152,7 +2152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_sqrt_ss() {
+    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);
@@ -2160,7 +2160,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_sqrt_ps() {
+    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);
@@ -2168,7 +2168,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_rcp_ss() {
+    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);
@@ -2180,7 +2180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_rcp_ps() {
+    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);
@@ -2191,7 +2191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_rsqrt_ss() {
+    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);
@@ -2202,7 +2202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_rsqrt_ps() {
+    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);
@@ -2213,7 +2213,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_min_ss() {
+    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);
@@ -2244,7 +2244,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_max_ss() {
+    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);
@@ -2749,7 +2749,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_comieq_ss() {
+    fn test_mm_comieq_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2770,7 +2770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_comilt_ss() {
+    fn test_mm_comilt_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2791,7 +2791,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_comile_ss() {
+    fn test_mm_comile_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2812,7 +2812,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_comigt_ss() {
+    fn test_mm_comigt_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2833,7 +2833,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_comineq_ss() {
+    fn test_mm_comineq_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2854,7 +2854,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomieq_ss() {
+    fn test_mm_ucomieq_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2875,7 +2875,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomilt_ss() {
+    fn test_mm_ucomilt_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2896,7 +2896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomile_ss() {
+    fn test_mm_ucomile_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2917,7 +2917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomigt_ss() {
+    fn test_mm_ucomigt_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2938,7 +2938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomige_ss() {
+    fn test_mm_ucomige_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2959,7 +2959,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_ucomineq_ss() {
+    fn test_mm_ucomineq_ss() {
         let aa = &[3.0f32, 12.0, 23.0, NAN];
         let bb = &[3.0f32, 47.5, 1.5, NAN];
 
@@ -2980,7 +2980,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_cvtss_si32() {
+    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() {
@@ -2996,7 +2996,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_cvttss_si32() {
+    fn test_mm_cvttss_si32() {
         let inputs = &[
             (42.0f32, 42i32),
             (-31.4, -31),
@@ -3021,7 +3021,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_cvtsi32_ss() {
+    const fn test_mm_cvtsi32_ss() {
         let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
 
         let r = _mm_cvtsi32_ss(a, 4555);
@@ -3042,19 +3042,19 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_cvtss_f32() {
+    const 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);
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_set_ss() {
+    const fn test_mm_set_ss() {
         let r = _mm_set_ss(black_box(4.25));
         assert_eq_m128(r, _mm_setr_ps(4.25, 0.0, 0.0, 0.0));
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_set1_ps() {
+    const fn test_mm_set1_ps() {
         let r1 = _mm_set1_ps(black_box(4.25));
         let r2 = _mm_set_ps1(black_box(4.25));
         assert_eq!(get_m128(r1, 0), 4.25);
@@ -3068,7 +3068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_set_ps() {
+    const fn test_mm_set_ps() {
         let r = _mm_set_ps(
             black_box(1.0),
             black_box(2.0),
@@ -3082,7 +3082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_setr_ps() {
+    const fn test_mm_setr_ps() {
         let r = _mm_setr_ps(
             black_box(1.0),
             black_box(2.0),
@@ -3093,7 +3093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_setzero_ps() {
+    const fn test_mm_setzero_ps() {
         let r = *black_box(&_mm_setzero_ps());
         assert_eq_m128(r, _mm_set1_ps(0.0));
     }
@@ -3107,7 +3107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_shuffle_ps() {
+    const fn test_mm_shuffle_ps() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let r = _mm_shuffle_ps::<0b00_01_01_11>(a, b);
@@ -3115,7 +3115,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_unpackhi_ps() {
+    const fn test_mm_unpackhi_ps() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let r = _mm_unpackhi_ps(a, b);
@@ -3123,7 +3123,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_unpacklo_ps() {
+    const fn test_mm_unpacklo_ps() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let r = _mm_unpacklo_ps(a, b);
@@ -3131,7 +3131,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_movehl_ps() {
+    const fn test_mm_movehl_ps() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let r = _mm_movehl_ps(a, b);
@@ -3139,7 +3139,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_movelh_ps() {
+    const fn test_mm_movelh_ps() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let r = _mm_movelh_ps(a, b);
@@ -3266,7 +3266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_move_ss() {
+    const fn test_mm_move_ss() {
         let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
 
@@ -3276,7 +3276,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_movemask_ps() {
+    const 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);
 
@@ -3287,12 +3287,12 @@ mod tests {
     #[simd_test(enable = "sse")]
     // Miri cannot support this until it is clear how it fits in the Rust memory model
     #[cfg_attr(miri, ignore)]
-    unsafe fn test_mm_sfence() {
+    fn test_mm_sfence() {
         _mm_sfence();
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_MM_TRANSPOSE4_PS() {
+    const fn test_MM_TRANSPOSE4_PS() {
         let mut a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let mut b = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
         let mut c = _mm_setr_ps(9.0, 10.0, 11.0, 12.0);
diff --git a/library/stdarch/crates/core_arch/src/x86/sse2.rs b/library/stdarch/crates/core_arch/src/x86/sse2.rs
index 098cd67c02d0..eec01ce1db7c 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse2.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse2.rs
@@ -210,14 +210,20 @@ pub const fn _mm_avg_epu16(a: __m128i, b: __m128i) -> __m128i {
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(pmaddwd))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
-#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
-pub const fn _mm_madd_epi16(a: __m128i, b: __m128i) -> __m128i {
-    unsafe {
-        let r: i32x8 = simd_mul(simd_cast(a.as_i16x8()), simd_cast(b.as_i16x8()));
-        let even: i32x4 = simd_shuffle!(r, r, [0, 2, 4, 6]);
-        let odd: i32x4 = simd_shuffle!(r, r, [1, 3, 5, 7]);
-        simd_add(even, odd).as_m128i()
-    }
+pub fn _mm_madd_epi16(a: __m128i, b: __m128i) -> __m128i {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
+    //
+    // ```rust
+    // #[target_feature(enable = "sse2")]
+    // unsafe fn widening_add(mad: __m128i) -> __m128i {
+    //     _mm_madd_epi16(mad, _mm_set1_epi16(1))
+    // }
+    // ```
+    //
+    // If we implement this using generic vector intrinsics, the optimizer
+    // will eliminate this pattern, and `pmaddwd` will no longer be emitted.
+    // For this reason, we use x86 intrinsics.
+    unsafe { transmute(pmaddwd(a.as_i16x8(), b.as_i16x8())) }
 }
 
 /// Compares packed 16-bit integers in `a` and `b`, and returns the packed
@@ -3187,6 +3193,8 @@ unsafe extern "C" {
     fn lfence();
     #[link_name = "llvm.x86.sse2.mfence"]
     fn mfence();
+    #[link_name = "llvm.x86.sse2.pmadd.wd"]
+    fn pmaddwd(a: i16x8, b: i16x8) -> i32x4;
     #[link_name = "llvm.x86.sse2.psad.bw"]
     fn psadbw(a: u8x16, b: u8x16) -> u64x2;
     #[link_name = "llvm.x86.sse2.psll.w"]
@@ -3295,19 +3303,19 @@ mod tests {
     #[simd_test(enable = "sse2")]
     // Miri cannot support this until it is clear how it fits in the Rust memory model
     #[cfg_attr(miri, ignore)]
-    unsafe fn test_mm_lfence() {
+    fn test_mm_lfence() {
         _mm_lfence();
     }
 
     #[simd_test(enable = "sse2")]
     // Miri cannot support this until it is clear how it fits in the Rust memory model
     #[cfg_attr(miri, ignore)]
-    unsafe fn test_mm_mfence() {
+    fn test_mm_mfence() {
         _mm_mfence();
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_epi8() {
+    const fn test_mm_add_epi8() {
         let a = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let b = _mm_setr_epi8(
@@ -3322,7 +3330,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_add_epi8_overflow() {
+    fn test_mm_add_epi8_overflow() {
         let a = _mm_set1_epi8(0x7F);
         let b = _mm_set1_epi8(1);
         let r = _mm_add_epi8(a, b);
@@ -3330,7 +3338,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_epi16() {
+    const fn test_mm_add_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_add_epi16(a, b);
@@ -3339,7 +3347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_epi32() {
+    const fn test_mm_add_epi32() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let b = _mm_setr_epi32(4, 5, 6, 7);
         let r = _mm_add_epi32(a, b);
@@ -3348,7 +3356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_epi64() {
+    const fn test_mm_add_epi64() {
         let a = _mm_setr_epi64x(0, 1);
         let b = _mm_setr_epi64x(2, 3);
         let r = _mm_add_epi64(a, b);
@@ -3357,7 +3365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_adds_epi8() {
+    const fn test_mm_adds_epi8() {
         let a = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let b = _mm_setr_epi8(
@@ -3372,7 +3380,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epi8_saturate_positive() {
+    fn test_mm_adds_epi8_saturate_positive() {
         let a = _mm_set1_epi8(0x7F);
         let b = _mm_set1_epi8(1);
         let r = _mm_adds_epi8(a, b);
@@ -3380,7 +3388,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epi8_saturate_negative() {
+    fn test_mm_adds_epi8_saturate_negative() {
         let a = _mm_set1_epi8(-0x80);
         let b = _mm_set1_epi8(-1);
         let r = _mm_adds_epi8(a, b);
@@ -3388,7 +3396,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_adds_epi16() {
+    const fn test_mm_adds_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_adds_epi16(a, b);
@@ -3397,7 +3405,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epi16_saturate_positive() {
+    fn test_mm_adds_epi16_saturate_positive() {
         let a = _mm_set1_epi16(0x7FFF);
         let b = _mm_set1_epi16(1);
         let r = _mm_adds_epi16(a, b);
@@ -3405,7 +3413,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epi16_saturate_negative() {
+    fn test_mm_adds_epi16_saturate_negative() {
         let a = _mm_set1_epi16(-0x8000);
         let b = _mm_set1_epi16(-1);
         let r = _mm_adds_epi16(a, b);
@@ -3413,7 +3421,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_adds_epu8() {
+    const fn test_mm_adds_epu8() {
         let a = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         #[rustfmt::skip]
         let b = _mm_setr_epi8(
@@ -3428,7 +3436,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epu8_saturate() {
+    fn test_mm_adds_epu8_saturate() {
         let a = _mm_set1_epi8(!0);
         let b = _mm_set1_epi8(1);
         let r = _mm_adds_epu8(a, b);
@@ -3436,7 +3444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_adds_epu16() {
+    const fn test_mm_adds_epu16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_adds_epu16(a, b);
@@ -3445,7 +3453,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_adds_epu16_saturate() {
+    fn test_mm_adds_epu16_saturate() {
         let a = _mm_set1_epi16(!0);
         let b = _mm_set1_epi16(1);
         let r = _mm_adds_epu16(a, b);
@@ -3453,21 +3461,21 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_avg_epu8() {
+    const 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));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_avg_epu16() {
+    const 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));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_madd_epi16() {
+    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);
@@ -3502,7 +3510,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_max_epi16() {
+    const fn test_mm_max_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(-1);
         let r = _mm_max_epi16(a, b);
@@ -3510,7 +3518,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_max_epu8() {
+    const fn test_mm_max_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(!0);
         let r = _mm_max_epu8(a, b);
@@ -3518,7 +3526,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_min_epi16() {
+    const fn test_mm_min_epi16() {
         let a = _mm_set1_epi16(1);
         let b = _mm_set1_epi16(-1);
         let r = _mm_min_epi16(a, b);
@@ -3526,7 +3534,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_min_epu8() {
+    const fn test_mm_min_epu8() {
         let a = _mm_set1_epi8(1);
         let b = _mm_set1_epi8(!0);
         let r = _mm_min_epu8(a, b);
@@ -3534,28 +3542,28 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mulhi_epi16() {
+    const 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));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mulhi_epu16() {
+    const 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));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mullo_epi16() {
+    const fn test_mm_mullo_epi16() {
         let (a, b) = (_mm_set1_epi16(1000), _mm_set1_epi16(-1001));
         let r = _mm_mullo_epi16(a, b);
         assert_eq_m128i(r, _mm_set1_epi16(-17960));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mul_epu32() {
+    const 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);
@@ -3564,7 +3572,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sad_epu8() {
+    fn test_mm_sad_epu8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             255u8 as i8, 254u8 as i8, 253u8 as i8, 252u8 as i8,
@@ -3579,42 +3587,42 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_epi8() {
+    const fn test_mm_sub_epi8() {
         let (a, b) = (_mm_set1_epi8(5), _mm_set1_epi8(6));
         let r = _mm_sub_epi8(a, b);
         assert_eq_m128i(r, _mm_set1_epi8(-1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_epi16() {
+    const fn test_mm_sub_epi16() {
         let (a, b) = (_mm_set1_epi16(5), _mm_set1_epi16(6));
         let r = _mm_sub_epi16(a, b);
         assert_eq_m128i(r, _mm_set1_epi16(-1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_epi32() {
+    const fn test_mm_sub_epi32() {
         let (a, b) = (_mm_set1_epi32(5), _mm_set1_epi32(6));
         let r = _mm_sub_epi32(a, b);
         assert_eq_m128i(r, _mm_set1_epi32(-1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_epi64() {
+    const fn test_mm_sub_epi64() {
         let (a, b) = (_mm_set1_epi64x(5), _mm_set1_epi64x(6));
         let r = _mm_sub_epi64(a, b);
         assert_eq_m128i(r, _mm_set1_epi64x(-1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_subs_epi8() {
+    const fn test_mm_subs_epi8() {
         let (a, b) = (_mm_set1_epi8(5), _mm_set1_epi8(2));
         let r = _mm_subs_epi8(a, b);
         assert_eq_m128i(r, _mm_set1_epi8(3));
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epi8_saturate_positive() {
+    fn test_mm_subs_epi8_saturate_positive() {
         let a = _mm_set1_epi8(0x7F);
         let b = _mm_set1_epi8(-1);
         let r = _mm_subs_epi8(a, b);
@@ -3622,7 +3630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epi8_saturate_negative() {
+    fn test_mm_subs_epi8_saturate_negative() {
         let a = _mm_set1_epi8(-0x80);
         let b = _mm_set1_epi8(1);
         let r = _mm_subs_epi8(a, b);
@@ -3630,14 +3638,14 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_subs_epi16() {
+    const fn test_mm_subs_epi16() {
         let (a, b) = (_mm_set1_epi16(5), _mm_set1_epi16(2));
         let r = _mm_subs_epi16(a, b);
         assert_eq_m128i(r, _mm_set1_epi16(3));
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epi16_saturate_positive() {
+    fn test_mm_subs_epi16_saturate_positive() {
         let a = _mm_set1_epi16(0x7FFF);
         let b = _mm_set1_epi16(-1);
         let r = _mm_subs_epi16(a, b);
@@ -3645,7 +3653,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epi16_saturate_negative() {
+    fn test_mm_subs_epi16_saturate_negative() {
         let a = _mm_set1_epi16(-0x8000);
         let b = _mm_set1_epi16(1);
         let r = _mm_subs_epi16(a, b);
@@ -3653,14 +3661,14 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_subs_epu8() {
+    const fn test_mm_subs_epu8() {
         let (a, b) = (_mm_set1_epi8(5), _mm_set1_epi8(2));
         let r = _mm_subs_epu8(a, b);
         assert_eq_m128i(r, _mm_set1_epi8(3));
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epu8_saturate() {
+    fn test_mm_subs_epu8_saturate() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set1_epi8(1);
         let r = _mm_subs_epu8(a, b);
@@ -3668,14 +3676,14 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_subs_epu16() {
+    const fn test_mm_subs_epu16() {
         let (a, b) = (_mm_set1_epi16(5), _mm_set1_epi16(2));
         let r = _mm_subs_epu16(a, b);
         assert_eq_m128i(r, _mm_set1_epi16(3));
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_subs_epu16_saturate() {
+    fn test_mm_subs_epu16_saturate() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let r = _mm_subs_epu16(a, b);
@@ -3683,7 +3691,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_slli_si128() {
+    const fn test_mm_slli_si128() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
@@ -3709,7 +3717,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_slli_epi16() {
+    const fn test_mm_slli_epi16() {
         let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
         let r = _mm_slli_epi16::<4>(a);
         assert_eq_m128i(
@@ -3737,7 +3745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_slli_epi32() {
+    const fn test_mm_slli_epi32() {
         let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
         let r = _mm_slli_epi32::<4>(a);
         assert_eq_m128i(r, _mm_setr_epi32(0xEEEE0, -0xEEEE0, 0xFFFF0, -0xFFFF0));
@@ -3746,7 +3754,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sll_epi32() {
+    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));
@@ -3759,7 +3767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_slli_epi64() {
+    const fn test_mm_slli_epi64() {
         let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
         let r = _mm_slli_epi64::<4>(a);
         assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFFF0, -0xFFFFFFFF0));
@@ -3768,7 +3776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sll_epi64() {
+    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));
@@ -3781,7 +3789,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srai_epi16() {
+    const fn test_mm_srai_epi16() {
         let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
         let r = _mm_srai_epi16::<4>(a);
         assert_eq_m128i(
@@ -3793,7 +3801,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sra_epi16() {
+    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(
@@ -3809,7 +3817,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srai_epi32() {
+    const fn test_mm_srai_epi32() {
         let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
         let r = _mm_srai_epi32::<4>(a);
         assert_eq_m128i(r, _mm_setr_epi32(0xEEE, -0xEEF, 0xFFF, -0x1000));
@@ -3818,7 +3826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sra_epi32() {
+    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));
@@ -3831,7 +3839,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srli_si128() {
+    const fn test_mm_srli_si128() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
@@ -3860,7 +3868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srli_epi16() {
+    const fn test_mm_srli_epi16() {
         let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
         let r = _mm_srli_epi16::<4>(a);
         assert_eq_m128i(
@@ -3872,7 +3880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_srl_epi16() {
+    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(
@@ -3888,7 +3896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srli_epi32() {
+    const fn test_mm_srli_epi32() {
         let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
         let r = _mm_srli_epi32::<4>(a);
         assert_eq_m128i(r, _mm_setr_epi32(0xEEE, 0xFFFF111, 0xFFF, 0xFFFF000));
@@ -3897,7 +3905,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_srl_epi32() {
+    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));
@@ -3910,7 +3918,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_srli_epi64() {
+    const fn test_mm_srli_epi64() {
         let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
         let r = _mm_srli_epi64::<4>(a);
         assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFF, 0xFFFFFFFF0000000));
@@ -3919,7 +3927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_srl_epi64() {
+    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));
@@ -3932,7 +3940,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_and_si128() {
+    const fn test_mm_and_si128() {
         let a = _mm_set1_epi8(5);
         let b = _mm_set1_epi8(3);
         let r = _mm_and_si128(a, b);
@@ -3940,7 +3948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_andnot_si128() {
+    const fn test_mm_andnot_si128() {
         let a = _mm_set1_epi8(5);
         let b = _mm_set1_epi8(3);
         let r = _mm_andnot_si128(a, b);
@@ -3948,7 +3956,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_or_si128() {
+    const fn test_mm_or_si128() {
         let a = _mm_set1_epi8(5);
         let b = _mm_set1_epi8(3);
         let r = _mm_or_si128(a, b);
@@ -3956,7 +3964,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_xor_si128() {
+    const fn test_mm_xor_si128() {
         let a = _mm_set1_epi8(5);
         let b = _mm_set1_epi8(3);
         let r = _mm_xor_si128(a, b);
@@ -3964,7 +3972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpeq_epi8() {
+    const fn test_mm_cmpeq_epi8() {
         let a = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let b = _mm_setr_epi8(15, 14, 2, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm_cmpeq_epi8(a, b);
@@ -3978,7 +3986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpeq_epi16() {
+    const fn test_mm_cmpeq_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(7, 6, 2, 4, 3, 2, 1, 0);
         let r = _mm_cmpeq_epi16(a, b);
@@ -3986,7 +3994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpeq_epi32() {
+    const fn test_mm_cmpeq_epi32() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let b = _mm_setr_epi32(3, 2, 2, 0);
         let r = _mm_cmpeq_epi32(a, b);
@@ -3994,7 +4002,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpgt_epi8() {
+    const fn test_mm_cmpgt_epi8() {
         let a = _mm_set_epi8(5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
         let b = _mm_set1_epi8(0);
         let r = _mm_cmpgt_epi8(a, b);
@@ -4003,7 +4011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpgt_epi16() {
+    const fn test_mm_cmpgt_epi16() {
         let a = _mm_set_epi16(5, 0, 0, 0, 0, 0, 0, 0);
         let b = _mm_set1_epi16(0);
         let r = _mm_cmpgt_epi16(a, b);
@@ -4012,7 +4020,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmpgt_epi32() {
+    const fn test_mm_cmpgt_epi32() {
         let a = _mm_set_epi32(5, 0, 0, 0);
         let b = _mm_set1_epi32(0);
         let r = _mm_cmpgt_epi32(a, b);
@@ -4020,7 +4028,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmplt_epi8() {
+    const fn test_mm_cmplt_epi8() {
         let a = _mm_set1_epi8(0);
         let b = _mm_set_epi8(5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm_cmplt_epi8(a, b);
@@ -4029,7 +4037,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmplt_epi16() {
+    const fn test_mm_cmplt_epi16() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set_epi16(5, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm_cmplt_epi16(a, b);
@@ -4038,7 +4046,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cmplt_epi32() {
+    const fn test_mm_cmplt_epi32() {
         let a = _mm_set1_epi32(0);
         let b = _mm_set_epi32(5, 0, 0, 0);
         let r = _mm_cmplt_epi32(a, b);
@@ -4046,21 +4054,21 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtepi32_pd() {
+    const fn test_mm_cvtepi32_pd() {
         let a = _mm_set_epi32(35, 25, 15, 5);
         let r = _mm_cvtepi32_pd(a);
         assert_eq_m128d(r, _mm_setr_pd(5.0, 15.0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi32_sd() {
+    const fn test_mm_cvtsi32_sd() {
         let a = _mm_set1_pd(3.5);
         let r = _mm_cvtsi32_sd(a, 5);
         assert_eq_m128d(r, _mm_setr_pd(5.0, 3.5));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtepi32_ps() {
+    const 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));
@@ -4074,37 +4082,37 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi32_si128() {
+    const fn test_mm_cvtsi32_si128() {
         let r = _mm_cvtsi32_si128(5);
         assert_eq_m128i(r, _mm_setr_epi32(5, 0, 0, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi128_si32() {
+    const fn test_mm_cvtsi128_si32() {
         let r = _mm_cvtsi128_si32(_mm_setr_epi32(5, 0, 0, 0));
         assert_eq!(r, 5);
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_epi64x() {
+    const fn test_mm_set_epi64x() {
         let r = _mm_set_epi64x(0, 1);
         assert_eq_m128i(r, _mm_setr_epi64x(1, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_epi32() {
+    const fn test_mm_set_epi32() {
         let r = _mm_set_epi32(0, 1, 2, 3);
         assert_eq_m128i(r, _mm_setr_epi32(3, 2, 1, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_epi16() {
+    const fn test_mm_set_epi16() {
         let r = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         assert_eq_m128i(r, _mm_setr_epi16(7, 6, 5, 4, 3, 2, 1, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_epi8() {
+    const fn test_mm_set_epi8() {
         #[rustfmt::skip]
         let r = _mm_set_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -4118,43 +4126,43 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set1_epi64x() {
+    const fn test_mm_set1_epi64x() {
         let r = _mm_set1_epi64x(1);
         assert_eq_m128i(r, _mm_set1_epi64x(1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set1_epi32() {
+    const fn test_mm_set1_epi32() {
         let r = _mm_set1_epi32(1);
         assert_eq_m128i(r, _mm_set1_epi32(1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set1_epi16() {
+    const fn test_mm_set1_epi16() {
         let r = _mm_set1_epi16(1);
         assert_eq_m128i(r, _mm_set1_epi16(1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set1_epi8() {
+    const fn test_mm_set1_epi8() {
         let r = _mm_set1_epi8(1);
         assert_eq_m128i(r, _mm_set1_epi8(1));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setr_epi32() {
+    const fn test_mm_setr_epi32() {
         let r = _mm_setr_epi32(0, 1, 2, 3);
         assert_eq_m128i(r, _mm_setr_epi32(0, 1, 2, 3));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setr_epi16() {
+    const fn test_mm_setr_epi16() {
         let r = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         assert_eq_m128i(r, _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setr_epi8() {
+    const fn test_mm_setr_epi8() {
         #[rustfmt::skip]
         let r = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -4168,7 +4176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setzero_si128() {
+    const fn test_mm_setzero_si128() {
         let r = _mm_setzero_si128();
         assert_eq_m128i(r, _mm_set1_epi64x(0));
     }
@@ -4261,14 +4269,14 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_move_epi64() {
+    const fn test_mm_move_epi64() {
         let a = _mm_setr_epi64x(5, 6);
         let r = _mm_move_epi64(a);
         assert_eq_m128i(r, _mm_setr_epi64x(5, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_packs_epi16() {
+    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);
@@ -4282,7 +4290,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_packs_epi32() {
+    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);
@@ -4293,7 +4301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_packus_epi16() {
+    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);
@@ -4304,7 +4312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_extract_epi16() {
+    const fn test_mm_extract_epi16() {
         let a = _mm_setr_epi16(-1, 1, 2, 3, 4, 5, 6, 7);
         let r1 = _mm_extract_epi16::<0>(a);
         let r2 = _mm_extract_epi16::<3>(a);
@@ -4313,7 +4321,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_insert_epi16() {
+    const fn test_mm_insert_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm_insert_epi16::<0>(a, 9);
         let e = _mm_setr_epi16(9, 1, 2, 3, 4, 5, 6, 7);
@@ -4321,7 +4329,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_movemask_epi8() {
+    const fn test_mm_movemask_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0b1000_0000u8 as i8, 0b0, 0b1000_0000u8 as i8, 0b01,
@@ -4334,7 +4342,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_shuffle_epi32() {
+    const fn test_mm_shuffle_epi32() {
         let a = _mm_setr_epi32(5, 10, 15, 20);
         let r = _mm_shuffle_epi32::<0b00_01_01_11>(a);
         let e = _mm_setr_epi32(20, 10, 10, 5);
@@ -4342,7 +4350,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_shufflehi_epi16() {
+    const fn test_mm_shufflehi_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 10, 15, 20);
         let r = _mm_shufflehi_epi16::<0b00_01_01_11>(a);
         let e = _mm_setr_epi16(1, 2, 3, 4, 20, 10, 10, 5);
@@ -4350,7 +4358,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_shufflelo_epi16() {
+    const fn test_mm_shufflelo_epi16() {
         let a = _mm_setr_epi16(5, 10, 15, 20, 1, 2, 3, 4);
         let r = _mm_shufflelo_epi16::<0b00_01_01_11>(a);
         let e = _mm_setr_epi16(20, 10, 10, 5, 1, 2, 3, 4);
@@ -4358,7 +4366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpackhi_epi8() {
+    const fn test_mm_unpackhi_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4377,7 +4385,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpackhi_epi16() {
+    const fn test_mm_unpackhi_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_unpackhi_epi16(a, b);
@@ -4386,7 +4394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpackhi_epi32() {
+    const fn test_mm_unpackhi_epi32() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let b = _mm_setr_epi32(4, 5, 6, 7);
         let r = _mm_unpackhi_epi32(a, b);
@@ -4395,7 +4403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpackhi_epi64() {
+    const fn test_mm_unpackhi_epi64() {
         let a = _mm_setr_epi64x(0, 1);
         let b = _mm_setr_epi64x(2, 3);
         let r = _mm_unpackhi_epi64(a, b);
@@ -4404,7 +4412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpacklo_epi8() {
+    const fn test_mm_unpacklo_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -4424,7 +4432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpacklo_epi16() {
+    const fn test_mm_unpacklo_epi16() {
         let a = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm_setr_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_unpacklo_epi16(a, b);
@@ -4433,7 +4441,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpacklo_epi32() {
+    const fn test_mm_unpacklo_epi32() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let b = _mm_setr_epi32(4, 5, 6, 7);
         let r = _mm_unpacklo_epi32(a, b);
@@ -4442,7 +4450,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpacklo_epi64() {
+    const fn test_mm_unpacklo_epi64() {
         let a = _mm_setr_epi64x(0, 1);
         let b = _mm_setr_epi64x(2, 3);
         let r = _mm_unpacklo_epi64(a, b);
@@ -4451,7 +4459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_sd() {
+    const fn test_mm_add_sd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_add_sd(a, b);
@@ -4459,7 +4467,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_add_pd() {
+    const fn test_mm_add_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_add_pd(a, b);
@@ -4467,7 +4475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_div_sd() {
+    const fn test_mm_div_sd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_div_sd(a, b);
@@ -4475,7 +4483,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_div_pd() {
+    const fn test_mm_div_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_div_pd(a, b);
@@ -4483,7 +4491,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_max_sd() {
+    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);
@@ -4491,7 +4499,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_max_pd() {
+    fn test_mm_max_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_max_pd(a, b);
@@ -4500,17 +4508,18 @@ mod tests {
         // Check SSE(2)-specific semantics for -0.0 handling.
         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
+        // Cast to __m128i to compare exact bit patterns
+        let r1 = _mm_castpd_si128(_mm_max_pd(a, b));
+        let r2 = _mm_castpd_si128(_mm_max_pd(b, a));
+        let a = _mm_castpd_si128(a);
+        let b = _mm_castpd_si128(b);
+        assert_eq_m128i(r1, b);
+        assert_eq_m128i(r2, a);
+        assert_ne!(a.as_u8x16(), b.as_u8x16()); // sanity check that -0.0 is actually present
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_min_sd() {
+    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);
@@ -4518,7 +4527,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_min_pd() {
+    fn test_mm_min_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_min_pd(a, b);
@@ -4527,17 +4536,18 @@ mod tests {
         // Check SSE(2)-specific semantics for -0.0 handling.
         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
+        // Cast to __m128i to compare exact bit patterns
+        let r1 = _mm_castpd_si128(_mm_min_pd(a, b));
+        let r2 = _mm_castpd_si128(_mm_min_pd(b, a));
+        let a = _mm_castpd_si128(a);
+        let b = _mm_castpd_si128(b);
+        assert_eq_m128i(r1, b);
+        assert_eq_m128i(r2, a);
+        assert_ne!(a.as_u8x16(), b.as_u8x16()); // sanity check that -0.0 is actually present
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mul_sd() {
+    const fn test_mm_mul_sd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_mul_sd(a, b);
@@ -4545,7 +4555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_mul_pd() {
+    const fn test_mm_mul_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_mul_pd(a, b);
@@ -4553,7 +4563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sqrt_sd() {
+    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);
@@ -4561,13 +4571,13 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_sqrt_pd() {
+    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()));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_sd() {
+    const fn test_mm_sub_sd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_sub_sd(a, b);
@@ -4575,7 +4585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_sub_pd() {
+    const fn test_mm_sub_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(5.0, 10.0);
         let r = _mm_sub_pd(a, b);
@@ -4619,199 +4629,199 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpeq_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpeq_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpeq_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmplt_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmplt_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmplt_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmple_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmple_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmple_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpgt_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpgt_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpgt_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpge_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpge_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpge_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpord_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpord_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpord_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpunord_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpunord_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpunord_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpneq_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpneq_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpneq_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnlt_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpnlt_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpnlt_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnle_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpnle_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpnle_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpngt_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpngt_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpngt_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnge_sd() {
+    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, 2.0f64.to_bits() as i64);
-        let r = transmute::<_, __m128i>(_mm_cmpnge_sd(a, b));
+        let r = _mm_castpd_si128(_mm_cmpnge_sd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpeq_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpeq_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmplt_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmplt_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmple_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmple_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpgt_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpgt_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpge_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpge_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpord_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpord_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpunord_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpunord_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpneq_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpneq_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnlt_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpnlt_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnle_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpnle_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpngt_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpngt_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cmpnge_pd() {
+    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));
+        let r = _mm_castpd_si128(_mm_cmpnge_pd(a, b));
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comieq_sd() {
+    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);
 
@@ -4820,37 +4830,37 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comilt_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comile_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comigt_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comige_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_comineq_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomieq_sd() {
+    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);
 
@@ -4859,37 +4869,37 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomilt_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomile_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomigt_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomige_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_ucomineq_sd() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_movemask_pd() {
+    const fn test_mm_movemask_pd() {
         let r = _mm_movemask_pd(_mm_setr_pd(-1.0, 5.0));
         assert_eq!(r, 0b01);
 
@@ -5122,7 +5132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtpd_ps() {
+    const 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));
 
@@ -5137,7 +5147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtps_pd() {
+    const 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));
 
@@ -5151,7 +5161,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvtpd_epi32() {
+    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));
 
@@ -5169,7 +5179,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvtsd_si32() {
+    fn test_mm_cvtsd_si32() {
         let r = _mm_cvtsd_si32(_mm_setr_pd(-2.0, 5.0));
         assert_eq!(r, -2);
 
@@ -5181,7 +5191,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvtsd_ss() {
+    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);
 
@@ -5206,13 +5216,13 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsd_f64() {
+    const fn test_mm_cvtsd_f64() {
         let r = _mm_cvtsd_f64(_mm_setr_pd(-1.1, 2.2));
         assert_eq!(r, -1.1);
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtss_sd() {
+    const 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);
 
@@ -5227,7 +5237,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvttpd_epi32() {
+    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));
@@ -5238,7 +5248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvttsd_si32() {
+    fn test_mm_cvttsd_si32() {
         let a = _mm_setr_pd(-1.1, 2.2);
         let r = _mm_cvttsd_si32(a);
         assert_eq!(r, -1);
@@ -5249,7 +5259,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvttps_epi32() {
+    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));
@@ -5260,37 +5270,37 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_sd() {
+    const fn test_mm_set_sd() {
         let r = _mm_set_sd(-1.0_f64);
         assert_eq_m128d(r, _mm_setr_pd(-1.0_f64, 0_f64));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set1_pd() {
+    const fn test_mm_set1_pd() {
         let r = _mm_set1_pd(-1.0_f64);
         assert_eq_m128d(r, _mm_setr_pd(-1.0_f64, -1.0_f64));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_pd1() {
+    const fn test_mm_set_pd1() {
         let r = _mm_set_pd1(-2.0_f64);
         assert_eq_m128d(r, _mm_setr_pd(-2.0_f64, -2.0_f64));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_set_pd() {
+    const fn test_mm_set_pd() {
         let r = _mm_set_pd(1.0_f64, 5.0_f64);
         assert_eq_m128d(r, _mm_setr_pd(5.0_f64, 1.0_f64));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setr_pd() {
+    const fn test_mm_setr_pd() {
         let r = _mm_setr_pd(1.0_f64, -5.0_f64);
         assert_eq_m128d(r, _mm_setr_pd(1.0_f64, -5.0_f64));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_setzero_pd() {
+    const fn test_mm_setzero_pd() {
         let r = _mm_setzero_pd();
         assert_eq_m128d(r, _mm_setr_pd(0_f64, 0_f64));
     }
@@ -5310,7 +5320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpackhi_pd() {
+    const fn test_mm_unpackhi_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(3.0, 4.0);
         let r = _mm_unpackhi_pd(a, b);
@@ -5318,7 +5328,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_unpacklo_pd() {
+    const fn test_mm_unpacklo_pd() {
         let a = _mm_setr_pd(1.0, 2.0);
         let b = _mm_setr_pd(3.0, 4.0);
         let r = _mm_unpacklo_pd(a, b);
@@ -5326,7 +5336,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_shuffle_pd() {
+    const fn test_mm_shuffle_pd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(3., 4.);
         let expected = _mm_setr_pd(1., 3.);
@@ -5335,7 +5345,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_move_sd() {
+    const fn test_mm_move_sd() {
         let a = _mm_setr_pd(1., 2.);
         let b = _mm_setr_pd(3., 4.);
         let expected = _mm_setr_pd(3., 2.);
@@ -5344,7 +5354,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castpd_ps() {
+    const fn test_mm_castpd_ps() {
         let a = _mm_set1_pd(0.);
         let expected = _mm_set1_ps(0.);
         let r = _mm_castpd_ps(a);
@@ -5352,7 +5362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castpd_si128() {
+    const fn test_mm_castpd_si128() {
         let a = _mm_set1_pd(0.);
         let expected = _mm_set1_epi64x(0);
         let r = _mm_castpd_si128(a);
@@ -5360,7 +5370,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castps_pd() {
+    const fn test_mm_castps_pd() {
         let a = _mm_set1_ps(0.);
         let expected = _mm_set1_pd(0.);
         let r = _mm_castps_pd(a);
@@ -5368,7 +5378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castps_si128() {
+    const fn test_mm_castps_si128() {
         let a = _mm_set1_ps(0.);
         let expected = _mm_set1_epi32(0);
         let r = _mm_castps_si128(a);
@@ -5376,7 +5386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castsi128_pd() {
+    const fn test_mm_castsi128_pd() {
         let a = _mm_set1_epi64x(0);
         let expected = _mm_set1_pd(0.);
         let r = _mm_castsi128_pd(a);
@@ -5384,7 +5394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_castsi128_ps() {
+    const fn test_mm_castsi128_ps() {
         let a = _mm_set1_epi32(0);
         let expected = _mm_set1_ps(0.);
         let r = _mm_castsi128_ps(a);
diff --git a/library/stdarch/crates/core_arch/src/x86/sse3.rs b/library/stdarch/crates/core_arch/src/x86/sse3.rs
index eebca864f43c..68817856f44a 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse3.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse3.rs
@@ -191,7 +191,7 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_addsub_ps() {
+    const fn test_mm_addsub_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_addsub_ps(a, b);
@@ -199,7 +199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_addsub_pd() {
+    const fn test_mm_addsub_pd() {
         let a = _mm_setr_pd(-1.0, 5.0);
         let b = _mm_setr_pd(-100.0, 20.0);
         let r = _mm_addsub_pd(a, b);
@@ -207,7 +207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_hadd_pd() {
+    const fn test_mm_hadd_pd() {
         let a = _mm_setr_pd(-1.0, 5.0);
         let b = _mm_setr_pd(-100.0, 20.0);
         let r = _mm_hadd_pd(a, b);
@@ -215,7 +215,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_hadd_ps() {
+    const fn test_mm_hadd_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_hadd_ps(a, b);
@@ -223,7 +223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_hsub_pd() {
+    const fn test_mm_hsub_pd() {
         let a = _mm_setr_pd(-1.0, 5.0);
         let b = _mm_setr_pd(-100.0, 20.0);
         let r = _mm_hsub_pd(a, b);
@@ -231,7 +231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_hsub_ps() {
+    const fn test_mm_hsub_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_hsub_ps(a, b);
@@ -252,21 +252,21 @@ mod tests {
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_movedup_pd() {
+    const fn test_mm_movedup_pd() {
         let a = _mm_setr_pd(-1.0, 5.0);
         let r = _mm_movedup_pd(a);
         assert_eq_m128d(r, _mm_setr_pd(-1.0, -1.0));
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_movehdup_ps() {
+    const fn test_mm_movehdup_ps() {
         let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
         let r = _mm_movehdup_ps(a);
         assert_eq_m128(r, _mm_setr_ps(5.0, 5.0, -10.0, -10.0));
     }
 
     #[simd_test(enable = "sse3")]
-    const unsafe fn test_mm_moveldup_ps() {
+    const fn test_mm_moveldup_ps() {
         let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
         let r = _mm_moveldup_ps(a);
         assert_eq_m128(r, _mm_setr_ps(-1.0, -1.0, 0.0, 0.0));
diff --git a/library/stdarch/crates/core_arch/src/x86/sse41.rs b/library/stdarch/crates/core_arch/src/x86/sse41.rs
index a83f8cc747a8..a499bf898b80 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse41.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse41.rs
@@ -1196,7 +1196,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_blendv_epi8() {
+    const fn test_mm_blendv_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -1239,7 +1239,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_blend_pd() {
+    const fn test_mm_blend_pd() {
         let a = _mm_set1_pd(0.0);
         let b = _mm_set1_pd(1.0);
         let r = _mm_blend_pd::<0b10>(a, b);
@@ -1248,7 +1248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_blend_ps() {
+    const fn test_mm_blend_ps() {
         let a = _mm_set1_ps(0.0);
         let b = _mm_set1_ps(1.0);
         let r = _mm_blend_ps::<0b1010>(a, b);
@@ -1257,7 +1257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_blend_epi16() {
+    const fn test_mm_blend_epi16() {
         let a = _mm_set1_epi16(0);
         let b = _mm_set1_epi16(1);
         let r = _mm_blend_epi16::<0b1010_1100>(a, b);
@@ -1266,7 +1266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_extract_ps() {
+    const fn test_mm_extract_ps() {
         let a = _mm_setr_ps(0.0, 1.0, 2.0, 3.0);
         let r: f32 = f32::from_bits(_mm_extract_ps::<1>(a) as u32);
         assert_eq!(r, 1.0);
@@ -1275,7 +1275,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_extract_epi8() {
+    const fn test_mm_extract_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             -1, 1, 2, 3, 4, 5, 6, 7,
@@ -1288,7 +1288,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_extract_epi32() {
+    const fn test_mm_extract_epi32() {
         let a = _mm_setr_epi32(0, 1, 2, 3);
         let r = _mm_extract_epi32::<1>(a);
         assert_eq!(r, 1);
@@ -1297,7 +1297,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_insert_ps() {
+    fn test_mm_insert_ps() {
         let a = _mm_set1_ps(1.0);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
         let r = _mm_insert_ps::<0b11_00_1100>(a, b);
@@ -1313,7 +1313,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_insert_epi8() {
+    const fn test_mm_insert_epi8() {
         let a = _mm_set1_epi8(0);
         let e = _mm_setr_epi8(0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
         let r = _mm_insert_epi8::<1>(a, 32);
@@ -1324,7 +1324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_insert_epi32() {
+    const fn test_mm_insert_epi32() {
         let a = _mm_set1_epi32(0);
         let e = _mm_setr_epi32(0, 32, 0, 0);
         let r = _mm_insert_epi32::<1>(a, 32);
@@ -1335,7 +1335,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_max_epi8() {
+    const fn test_mm_max_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 4, 5, 8, 9, 12, 13, 16,
@@ -1356,7 +1356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_max_epu16() {
+    const fn test_mm_max_epu16() {
         let a = _mm_setr_epi16(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm_setr_epi16(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm_max_epu16(a, b);
@@ -1365,7 +1365,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_max_epi32() {
+    const fn test_mm_max_epi32() {
         let a = _mm_setr_epi32(1, 4, 5, 8);
         let b = _mm_setr_epi32(2, 3, 6, 7);
         let r = _mm_max_epi32(a, b);
@@ -1374,7 +1374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_max_epu32() {
+    const fn test_mm_max_epu32() {
         let a = _mm_setr_epi32(1, 4, 5, 8);
         let b = _mm_setr_epi32(2, 3, 6, 7);
         let r = _mm_max_epu32(a, b);
@@ -1383,7 +1383,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_min_epi8() {
+    const fn test_mm_min_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 4, 5, 8, 9, 12, 13, 16,
@@ -1422,7 +1422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_min_epu16() {
+    const fn test_mm_min_epu16() {
         let a = _mm_setr_epi16(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm_setr_epi16(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm_min_epu16(a, b);
@@ -1431,7 +1431,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_min_epi32() {
+    const fn test_mm_min_epi32() {
         let a = _mm_setr_epi32(1, 4, 5, 8);
         let b = _mm_setr_epi32(2, 3, 6, 7);
         let r = _mm_min_epi32(a, b);
@@ -1446,7 +1446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_min_epu32() {
+    const fn test_mm_min_epu32() {
         let a = _mm_setr_epi32(1, 4, 5, 8);
         let b = _mm_setr_epi32(2, 3, 6, 7);
         let r = _mm_min_epu32(a, b);
@@ -1455,7 +1455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_packus_epi32() {
+    fn test_mm_packus_epi32() {
         let a = _mm_setr_epi32(1, 2, 3, 4);
         let b = _mm_setr_epi32(-1, -2, -3, -4);
         let r = _mm_packus_epi32(a, b);
@@ -1464,7 +1464,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cmpeq_epi64() {
+    const fn test_mm_cmpeq_epi64() {
         let a = _mm_setr_epi64x(0, 1);
         let b = _mm_setr_epi64x(0, 0);
         let r = _mm_cmpeq_epi64(a, b);
@@ -1473,7 +1473,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi8_epi16() {
+    const fn test_mm_cvtepi8_epi16() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepi8_epi16(a);
         let e = _mm_set1_epi16(10);
@@ -1485,7 +1485,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi8_epi32() {
+    const fn test_mm_cvtepi8_epi32() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepi8_epi32(a);
         let e = _mm_set1_epi32(10);
@@ -1497,7 +1497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi8_epi64() {
+    const fn test_mm_cvtepi8_epi64() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepi8_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1509,7 +1509,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi16_epi32() {
+    const fn test_mm_cvtepi16_epi32() {
         let a = _mm_set1_epi16(10);
         let r = _mm_cvtepi16_epi32(a);
         let e = _mm_set1_epi32(10);
@@ -1521,7 +1521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi16_epi64() {
+    const fn test_mm_cvtepi16_epi64() {
         let a = _mm_set1_epi16(10);
         let r = _mm_cvtepi16_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1533,7 +1533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepi32_epi64() {
+    const fn test_mm_cvtepi32_epi64() {
         let a = _mm_set1_epi32(10);
         let r = _mm_cvtepi32_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1545,7 +1545,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu8_epi16() {
+    const fn test_mm_cvtepu8_epi16() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepu8_epi16(a);
         let e = _mm_set1_epi16(10);
@@ -1553,7 +1553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu8_epi32() {
+    const fn test_mm_cvtepu8_epi32() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepu8_epi32(a);
         let e = _mm_set1_epi32(10);
@@ -1561,7 +1561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu8_epi64() {
+    const fn test_mm_cvtepu8_epi64() {
         let a = _mm_set1_epi8(10);
         let r = _mm_cvtepu8_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1569,7 +1569,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu16_epi32() {
+    const fn test_mm_cvtepu16_epi32() {
         let a = _mm_set1_epi16(10);
         let r = _mm_cvtepu16_epi32(a);
         let e = _mm_set1_epi32(10);
@@ -1577,7 +1577,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu16_epi64() {
+    const fn test_mm_cvtepu16_epi64() {
         let a = _mm_set1_epi16(10);
         let r = _mm_cvtepu16_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1585,7 +1585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_cvtepu32_epi64() {
+    const fn test_mm_cvtepu32_epi64() {
         let a = _mm_set1_epi32(10);
         let r = _mm_cvtepu32_epi64(a);
         let e = _mm_set1_epi64x(10);
@@ -1593,7 +1593,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_dp_pd() {
+    fn test_mm_dp_pd() {
         let a = _mm_setr_pd(2.0, 3.0);
         let b = _mm_setr_pd(1.0, 4.0);
         let e = _mm_setr_pd(14.0, 0.0);
@@ -1601,7 +1601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_dp_ps() {
+    fn test_mm_dp_ps() {
         let a = _mm_setr_ps(2.0, 3.0, 1.0, 10.0);
         let b = _mm_setr_ps(1.0, 4.0, 0.5, 10.0);
         let e = _mm_setr_ps(14.5, 0.0, 14.5, 0.0);
@@ -1609,7 +1609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_floor_pd() {
+    const fn test_mm_floor_pd() {
         let a = _mm_setr_pd(2.5, 4.5);
         let r = _mm_floor_pd(a);
         let e = _mm_setr_pd(2.0, 4.0);
@@ -1617,7 +1617,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_floor_ps() {
+    const fn test_mm_floor_ps() {
         let a = _mm_setr_ps(2.5, 4.5, 8.5, 16.5);
         let r = _mm_floor_ps(a);
         let e = _mm_setr_ps(2.0, 4.0, 8.0, 16.0);
@@ -1625,7 +1625,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_floor_sd() {
+    fn test_mm_floor_sd() {
         let a = _mm_setr_pd(2.5, 4.5);
         let b = _mm_setr_pd(-1.5, -3.5);
         let r = _mm_floor_sd(a, b);
@@ -1634,7 +1634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_floor_ss() {
+    fn test_mm_floor_ss() {
         let a = _mm_setr_ps(2.5, 4.5, 8.5, 16.5);
         let b = _mm_setr_ps(-1.5, -3.5, -7.5, -15.5);
         let r = _mm_floor_ss(a, b);
@@ -1643,7 +1643,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_ceil_pd() {
+    const fn test_mm_ceil_pd() {
         let a = _mm_setr_pd(1.5, 3.5);
         let r = _mm_ceil_pd(a);
         let e = _mm_setr_pd(2.0, 4.0);
@@ -1651,7 +1651,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_ceil_ps() {
+    const fn test_mm_ceil_ps() {
         let a = _mm_setr_ps(1.5, 3.5, 7.5, 15.5);
         let r = _mm_ceil_ps(a);
         let e = _mm_setr_ps(2.0, 4.0, 8.0, 16.0);
@@ -1659,7 +1659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_ceil_sd() {
+    fn test_mm_ceil_sd() {
         let a = _mm_setr_pd(1.5, 3.5);
         let b = _mm_setr_pd(-2.5, -4.5);
         let r = _mm_ceil_sd(a, b);
@@ -1668,7 +1668,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_ceil_ss() {
+    fn test_mm_ceil_ss() {
         let a = _mm_setr_ps(1.5, 3.5, 7.5, 15.5);
         let b = _mm_setr_ps(-2.5, -4.5, -8.5, -16.5);
         let r = _mm_ceil_ss(a, b);
@@ -1677,7 +1677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_round_pd() {
+    fn test_mm_round_pd() {
         let a = _mm_setr_pd(1.25, 3.75);
         let r = _mm_round_pd::<_MM_FROUND_TO_NEAREST_INT>(a);
         let e = _mm_setr_pd(1.0, 4.0);
@@ -1685,7 +1685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_round_ps() {
+    fn test_mm_round_ps() {
         let a = _mm_setr_ps(2.25, 4.75, -1.75, -4.25);
         let r = _mm_round_ps::<_MM_FROUND_TO_ZERO>(a);
         let e = _mm_setr_ps(2.0, 4.0, -1.0, -4.0);
@@ -1693,7 +1693,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_round_sd() {
+    fn test_mm_round_sd() {
         let a = _mm_setr_pd(1.5, 3.5);
         let b = _mm_setr_pd(-2.5, -4.5);
         let r = _mm_round_sd::<_MM_FROUND_TO_NEAREST_INT>(a, b);
@@ -1720,7 +1720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_round_ss() {
+    fn test_mm_round_ss() {
         let a = _mm_setr_ps(1.5, 3.5, 7.5, 15.5);
         let b = _mm_setr_ps(-1.75, -4.5, -8.5, -16.5);
         let r = _mm_round_ss::<_MM_FROUND_TO_NEAREST_INT>(a, b);
@@ -1747,7 +1747,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_minpos_epu16_1() {
+    fn test_mm_minpos_epu16_1() {
         let a = _mm_setr_epi16(23, 18, 44, 97, 50, 13, 67, 66);
         let r = _mm_minpos_epu16(a);
         let e = _mm_setr_epi16(13, 5, 0, 0, 0, 0, 0, 0);
@@ -1755,7 +1755,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_minpos_epu16_2() {
+    fn test_mm_minpos_epu16_2() {
         let a = _mm_setr_epi16(0, 18, 44, 97, 50, 13, 67, 66);
         let r = _mm_minpos_epu16(a);
         let e = _mm_setr_epi16(0, 0, 0, 0, 0, 0, 0, 0);
@@ -1763,7 +1763,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_minpos_epu16_3() {
+    fn test_mm_minpos_epu16_3() {
         // Case where the minimum value is repeated
         let a = _mm_setr_epi16(23, 18, 44, 97, 50, 13, 67, 13);
         let r = _mm_minpos_epu16(a);
@@ -1772,7 +1772,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_mul_epi32() {
+    const fn test_mm_mul_epi32() {
         {
             let a = _mm_setr_epi32(1, 1, 1, 1);
             let b = _mm_setr_epi32(1, 2, 3, 4);
@@ -1793,7 +1793,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_mullo_epi32() {
+    const fn test_mm_mullo_epi32() {
         {
             let a = _mm_setr_epi32(1, 1, 1, 1);
             let b = _mm_setr_epi32(1, 2, 3, 4);
@@ -1814,7 +1814,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_minpos_epu16() {
+    fn test_mm_minpos_epu16() {
         let a = _mm_setr_epi16(8, 7, 6, 5, 4, 1, 2, 3);
         let r = _mm_minpos_epu16(a);
         let e = _mm_setr_epi16(1, 5, 0, 0, 0, 0, 0, 0);
@@ -1822,7 +1822,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_mpsadbw_epu8() {
+    fn test_mm_mpsadbw_epu8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             0, 1, 2, 3, 4, 5, 6, 7,
@@ -1851,7 +1851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_testz_si128() {
+    const fn test_mm_testz_si128() {
         let a = _mm_set1_epi8(1);
         let mask = _mm_set1_epi8(0);
         let r = _mm_testz_si128(a, mask);
@@ -1867,7 +1867,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_testc_si128() {
+    const fn test_mm_testc_si128() {
         let a = _mm_set1_epi8(-1);
         let mask = _mm_set1_epi8(0);
         let r = _mm_testc_si128(a, mask);
@@ -1883,7 +1883,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_testnzc_si128() {
+    fn test_mm_testnzc_si128() {
         let a = _mm_set1_epi8(0);
         let mask = _mm_set1_epi8(1);
         let r = _mm_testnzc_si128(a, mask);
@@ -1903,7 +1903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_test_all_zeros() {
+    const fn test_mm_test_all_zeros() {
         let a = _mm_set1_epi8(1);
         let mask = _mm_set1_epi8(0);
         let r = _mm_test_all_zeros(a, mask);
@@ -1919,7 +1919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_test_all_ones() {
+    const fn test_mm_test_all_ones() {
         let a = _mm_set1_epi8(-1);
         let r = _mm_test_all_ones(a);
         assert_eq!(r, 1);
@@ -1929,7 +1929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    unsafe fn test_mm_test_mix_ones_zeros() {
+    fn test_mm_test_mix_ones_zeros() {
         let a = _mm_set1_epi8(0);
         let mask = _mm_set1_epi8(1);
         let r = _mm_test_mix_ones_zeros(a, mask);
diff --git a/library/stdarch/crates/core_arch/src/x86/sse42.rs b/library/stdarch/crates/core_arch/src/x86/sse42.rs
index 4d3c481fe124..65d1fe4d6233 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse42.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse42.rs
@@ -619,18 +619,17 @@ mod tests {
     // Currently one cannot `load` a &[u8] that is less than 16
     // in length. This makes loading strings less than 16 in length
     // a bit difficult. Rather than `load` and mutate the __m128i,
-    // it is easier to memcpy the given string to a local slice with
-    // length 16 and `load` the local slice.
-    #[target_feature(enable = "sse4.2")]
-    unsafe fn str_to_m128i(s: &[u8]) -> __m128i {
+    // it is easier to memcpy the given string to a zero-padded
+    // 16-byte array and transmute it to `__m128i`.
+    fn str_to_m128i(s: &[u8]) -> __m128i {
         assert!(s.len() <= 16);
-        let slice = &mut [0u8; 16];
-        ptr::copy_nonoverlapping(s.as_ptr(), slice.as_mut_ptr(), s.len());
-        _mm_loadu_si128(slice.as_ptr() as *const _)
+        let mut array = [0u8; 16];
+        array[..s.len()].copy_from_slice(s);
+        unsafe { transmute(array) }
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistrm() {
+    fn test_mm_cmpistrm() {
         let a = str_to_m128i(b"Hello! Good-Bye!");
         let b = str_to_m128i(b"hello! good-bye!");
         let i = _mm_cmpistrm::<_SIDD_UNIT_MASK>(a, b);
@@ -643,7 +642,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistri() {
+    fn test_mm_cmpistri() {
         let a = str_to_m128i(b"Hello");
         let b = str_to_m128i(b"   Hello        ");
         let i = _mm_cmpistri::<_SIDD_CMP_EQUAL_ORDERED>(a, b);
@@ -651,7 +650,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistrz() {
+    fn test_mm_cmpistrz() {
         let a = str_to_m128i(b"");
         let b = str_to_m128i(b"Hello");
         let i = _mm_cmpistrz::<_SIDD_CMP_EQUAL_ORDERED>(a, b);
@@ -659,7 +658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistrc() {
+    fn test_mm_cmpistrc() {
         let a = str_to_m128i(b"                ");
         let b = str_to_m128i(b"       !        ");
         let i = _mm_cmpistrc::<_SIDD_UNIT_MASK>(a, b);
@@ -667,7 +666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistrs() {
+    fn test_mm_cmpistrs() {
         let a = str_to_m128i(b"Hello");
         let b = str_to_m128i(b"");
         let i = _mm_cmpistrs::<_SIDD_CMP_EQUAL_ORDERED>(a, b);
@@ -675,7 +674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistro() {
+    fn test_mm_cmpistro() {
         #[rustfmt::skip]
         let a_bytes = _mm_setr_epi8(
             0x00, 0x47, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x6c,
@@ -693,7 +692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpistra() {
+    fn test_mm_cmpistra() {
         let a = str_to_m128i(b"");
         let b = str_to_m128i(b"Hello!!!!!!!!!!!");
         let i = _mm_cmpistra::<_SIDD_UNIT_MASK>(a, b);
@@ -701,7 +700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestrm() {
+    fn test_mm_cmpestrm() {
         let a = str_to_m128i(b"Hello!");
         let b = str_to_m128i(b"Hello.");
         let i = _mm_cmpestrm::<_SIDD_UNIT_MASK>(a, 5, b, 5);
@@ -714,7 +713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestri() {
+    fn test_mm_cmpestri() {
         let a = str_to_m128i(b"bar - garbage");
         let b = str_to_m128i(b"foobar");
         let i = _mm_cmpestri::<_SIDD_CMP_EQUAL_ORDERED>(a, 3, b, 6);
@@ -722,7 +721,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestrz() {
+    fn test_mm_cmpestrz() {
         let a = str_to_m128i(b"");
         let b = str_to_m128i(b"Hello");
         let i = _mm_cmpestrz::<_SIDD_CMP_EQUAL_ORDERED>(a, 16, b, 6);
@@ -730,7 +729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestrc() {
+    fn test_mm_cmpestrc() {
         let va = str_to_m128i(b"!!!!!!!!");
         let vb = str_to_m128i(b"        ");
         let i = _mm_cmpestrc::<_SIDD_UNIT_MASK>(va, 7, vb, 7);
@@ -738,7 +737,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestrs() {
+    fn test_mm_cmpestrs() {
         #[rustfmt::skip]
         let a_bytes = _mm_setr_epi8(
             0x00, 0x48, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x6c,
@@ -751,7 +750,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestro() {
+    fn test_mm_cmpestro() {
         let a = str_to_m128i(b"Hello");
         let b = str_to_m128i(b"World");
         let i = _mm_cmpestro::<_SIDD_UBYTE_OPS>(a, 5, b, 5);
@@ -759,7 +758,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_cmpestra() {
+    fn test_mm_cmpestra() {
         let a = str_to_m128i(b"Cannot match a");
         let b = str_to_m128i(b"Null after 14");
         let i = _mm_cmpestra::<{ _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK }>(a, 14, b, 16);
@@ -767,7 +766,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_crc32_u8() {
+    fn test_mm_crc32_u8() {
         let crc = 0x2aa1e72b;
         let v = 0x2a;
         let i = _mm_crc32_u8(crc, v);
@@ -775,7 +774,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_crc32_u16() {
+    fn test_mm_crc32_u16() {
         let crc = 0x8ecec3b5;
         let v = 0x22b;
         let i = _mm_crc32_u16(crc, v);
@@ -783,7 +782,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_crc32_u32() {
+    fn test_mm_crc32_u32() {
         let crc = 0xae2912c8;
         let v = 0x845fed;
         let i = _mm_crc32_u32(crc, v);
@@ -791,7 +790,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.2")]
-    const unsafe fn test_mm_cmpgt_epi64() {
+    const fn test_mm_cmpgt_epi64() {
         let a = _mm_setr_epi64x(0, 0x2a);
         let b = _mm_set1_epi64x(0x00);
         let i = _mm_cmpgt_epi64(a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/sse4a.rs b/library/stdarch/crates/core_arch/src/x86/sse4a.rs
index 7978d018e466..020baeff152d 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse4a.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse4a.rs
@@ -151,7 +151,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse4a")]
-    unsafe fn test_mm_extract_si64() {
+    fn test_mm_extract_si64() {
         let b = 0b0110_0000_0000_i64;
         //        ^^^^ bit range extracted
         let x = _mm_setr_epi64x(b, 0);
@@ -164,7 +164,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4a")]
-    unsafe fn test_mm_extracti_si64() {
+    fn test_mm_extracti_si64() {
         let a = _mm_setr_epi64x(0x0123456789abcdef, 0);
         let r = _mm_extracti_si64::<8, 8>(a);
         let e = _mm_setr_epi64x(0xcd, 0);
@@ -172,7 +172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4a")]
-    unsafe fn test_mm_insert_si64() {
+    fn test_mm_insert_si64() {
         let i = 0b0110_i64;
         //        ^^^^ bit range inserted
         let z = 0b1010_1010_1010i64;
@@ -189,7 +189,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4a")]
-    unsafe fn test_mm_inserti_si64() {
+    fn test_mm_inserti_si64() {
         let a = _mm_setr_epi64x(0x0123456789abcdef, 0);
         let b = _mm_setr_epi64x(0x0011223344556677, 0);
         let r = _mm_inserti_si64::<8, 8>(a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86/ssse3.rs b/library/stdarch/crates/core_arch/src/x86/ssse3.rs
index c44da6eb97e4..4426a3274c38 100644
--- a/library/stdarch/crates/core_arch/src/x86/ssse3.rs
+++ b/library/stdarch/crates/core_arch/src/x86/ssse3.rs
@@ -367,25 +367,25 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_abs_epi8() {
+    const fn test_mm_abs_epi8() {
         let r = _mm_abs_epi8(_mm_set1_epi8(-5));
         assert_eq_m128i(r, _mm_set1_epi8(5));
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_abs_epi16() {
+    const fn test_mm_abs_epi16() {
         let r = _mm_abs_epi16(_mm_set1_epi16(-5));
         assert_eq_m128i(r, _mm_set1_epi16(5));
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_abs_epi32() {
+    const fn test_mm_abs_epi32() {
         let r = _mm_abs_epi32(_mm_set1_epi32(-5));
         assert_eq_m128i(r, _mm_set1_epi32(5));
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_shuffle_epi8() {
+    fn test_mm_shuffle_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -409,7 +409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_alignr_epi8() {
+    const fn test_mm_alignr_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -449,7 +449,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_hadd_epi16() {
+    const fn test_mm_hadd_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 4, 3, 24, 12, 6, 19);
         let expected = _mm_setr_epi16(3, 7, 11, 15, 132, 7, 36, 25);
@@ -474,7 +474,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_hadds_epi16() {
+    fn test_mm_hadds_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 4, 3, 32767, 1, -32768, -1);
         let expected = _mm_setr_epi16(3, 7, 11, 15, 132, 7, 32767, -32768);
@@ -499,7 +499,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_hadd_epi32() {
+    const fn test_mm_hadd_epi32() {
         let a = _mm_setr_epi32(1, 2, 3, 4);
         let b = _mm_setr_epi32(4, 128, 4, 3);
         let expected = _mm_setr_epi32(3, 7, 132, 7);
@@ -515,7 +515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_hsub_epi16() {
+    const fn test_mm_hsub_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 4, 3, 24, 12, 6, 19);
         let expected = _mm_setr_epi16(-1, -1, -1, -1, -124, 1, 12, -13);
@@ -540,7 +540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_hsubs_epi16() {
+    fn test_mm_hsubs_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 4, 3, 32767, -1, -32768, 1);
         let expected = _mm_setr_epi16(-1, -1, -1, -1, -124, 1, 32767, -32768);
@@ -565,7 +565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    const unsafe fn test_mm_hsub_epi32() {
+    const fn test_mm_hsub_epi32() {
         let a = _mm_setr_epi32(1, 2, 3, 4);
         let b = _mm_setr_epi32(4, 128, 4, 3);
         let expected = _mm_setr_epi32(-1, -1, -124, 1);
@@ -581,7 +581,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_maddubs_epi16() {
+    fn test_mm_maddubs_epi16() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -621,7 +621,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_mulhrs_epi16() {
+    fn test_mm_mulhrs_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 4, 3, 32767, -1, -32768, 1);
         let expected = _mm_setr_epi16(0, 0, 0, 0, 5, 0, -7, 0);
@@ -637,7 +637,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_sign_epi8() {
+    fn test_mm_sign_epi8() {
         #[rustfmt::skip]
         let a = _mm_setr_epi8(
             1, 2, 3, 4, 5, 6, 7, 8,
@@ -658,7 +658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_sign_epi16() {
+    fn test_mm_sign_epi16() {
         let a = _mm_setr_epi16(1, 2, 3, 4, -5, -6, 7, 8);
         let b = _mm_setr_epi16(4, 128, 0, 3, 1, -1, -2, 1);
         let expected = _mm_setr_epi16(1, 2, 0, 4, -5, 6, -7, 8);
@@ -667,7 +667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "ssse3")]
-    unsafe fn test_mm_sign_epi32() {
+    fn test_mm_sign_epi32() {
         let a = _mm_setr_epi32(-1, 2, 3, 4);
         let b = _mm_setr_epi32(1, -1, 1, 0);
         let expected = _mm_setr_epi32(-1, -2, 3, 0);
diff --git a/library/stdarch/crates/core_arch/src/x86/tbm.rs b/library/stdarch/crates/core_arch/src/x86/tbm.rs
index 1e863fe15c0b..0ba4572dcd02 100644
--- a/library/stdarch/crates/core_arch/src/x86/tbm.rs
+++ b/library/stdarch/crates/core_arch/src/x86/tbm.rs
@@ -154,18 +154,18 @@ mod tests {
     use crate::core_arch::x86::*;
 
     #[simd_test(enable = "tbm")]
-    unsafe fn test_bextri_u32() {
+    fn test_bextri_u32() {
         assert_eq!(_bextri_u32::<0x0404>(0b0101_0000u32), 0b0000_0101u32);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcfill_u32() {
+    const fn test_blcfill_u32() {
         assert_eq!(_blcfill_u32(0b0101_0111u32), 0b0101_0000u32);
         assert_eq!(_blcfill_u32(0b1111_1111u32), 0u32);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blci_u32() {
+    const fn test_blci_u32() {
         assert_eq!(
             _blci_u32(0b0101_0000u32),
             0b1111_1111_1111_1111_1111_1111_1111_1110u32
@@ -177,25 +177,25 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcic_u32() {
+    const fn test_blcic_u32() {
         assert_eq!(_blcic_u32(0b0101_0001u32), 0b0000_0010u32);
         assert_eq!(_blcic_u32(0b1111_1111u32), 0b1_0000_0000u32);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcmsk_u32() {
+    const fn test_blcmsk_u32() {
         assert_eq!(_blcmsk_u32(0b0101_0001u32), 0b0000_0011u32);
         assert_eq!(_blcmsk_u32(0b1111_1111u32), 0b1_1111_1111u32);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcs_u32() {
+    const fn test_blcs_u32() {
         assert_eq!(_blcs_u32(0b0101_0001u32), 0b0101_0011u32);
         assert_eq!(_blcs_u32(0b1111_1111u32), 0b1_1111_1111u32);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blsfill_u32() {
+    const fn test_blsfill_u32() {
         assert_eq!(_blsfill_u32(0b0101_0100u32), 0b0101_0111u32);
         assert_eq!(
             _blsfill_u32(0u32),
@@ -204,7 +204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blsic_u32() {
+    const fn test_blsic_u32() {
         assert_eq!(
             _blsic_u32(0b0101_0100u32),
             0b1111_1111_1111_1111_1111_1111_1111_1011u32
@@ -216,7 +216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_t1mskc_u32() {
+    const fn test_t1mskc_u32() {
         assert_eq!(
             _t1mskc_u32(0b0101_0111u32),
             0b1111_1111_1111_1111_1111_1111_1111_1000u32
@@ -228,7 +228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_tzmsk_u32() {
+    const fn test_tzmsk_u32() {
         assert_eq!(_tzmsk_u32(0b0101_1000u32), 0b0000_0111u32);
         assert_eq!(_tzmsk_u32(0b0101_1001u32), 0b0000_0000u32);
     }
diff --git a/library/stdarch/crates/core_arch/src/x86/test.rs b/library/stdarch/crates/core_arch/src/x86/test.rs
index 9fa88fc98d60..4b2ef26044e8 100644
--- a/library/stdarch/crates/core_arch/src/x86/test.rs
+++ b/library/stdarch/crates/core_arch/src/x86/test.rs
@@ -1,225 +1,122 @@
 //! Utilities used in testing the x86 intrinsics
 
 use crate::core_arch::assert_eq_const as assert_eq;
+use crate::core_arch::simd::*;
 use crate::core_arch::x86::*;
 use std::mem::transmute;
 
 #[track_caller]
-#[target_feature(enable = "sse2")]
 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-pub(crate) const unsafe fn assert_eq_m128i(a: __m128i, b: __m128i) {
-    assert_eq!(transmute::<_, [u64; 2]>(a), transmute::<_, [u64; 2]>(b))
-}
-
-#[track_caller]
-#[target_feature(enable = "avx")]
-#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-pub(crate) const unsafe fn assert_eq_m256i(a: __m256i, b: __m256i) {
-    assert_eq!(transmute::<_, [u64; 4]>(a), transmute::<_, [u64; 4]>(b))
+pub(crate) const fn assert_eq_m128i(a: __m128i, b: __m128i) {
+    assert_eq!(a.as_u32x4(), b.as_u32x4());
 }
 
 #[track_caller]
 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-pub(crate) const unsafe fn assert_eq_m512i(a: __m512i, b: __m512i) {
-    assert_eq!(transmute::<_, [i32; 16]>(a), transmute::<_, [i32; 16]>(b))
+pub(crate) const fn assert_eq_m128(a: __m128, b: __m128) {
+    assert_eq!(a.as_f32x4(), b.as_f32x4());
 }
 
-macro_rules! make_ct_rt {
-    ($(
-        $( #[$meta:meta] )*
-        $vis:vis unsafe fn $name:ident ($($param:ident : $type:ty),* $(,)?) {
-            ct: $ct:expr;
-            rt: $rt:expr;
-        }
-    )*) => {$(
-        $( #[$meta] )*
-        #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-        $vis const unsafe fn $name ($($param : $type),*) {
-            #[inline(always)]
-            #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-            const fn ct($($param : $type),*) {
-                $ct
-            }
-            #[inline(always)]
-            fn rt($($param : $type),*) {
-                $rt
-            }
-
-            $crate::intrinsics::const_eval_select(($($param),*), ct, rt)
-        }
-    )*}
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m128d(a: __m128d, b: __m128d) {
+    assert_eq!(a.as_f64x2(), b.as_f64x2());
 }
 
-make_ct_rt! {
-    // SAFETY: we can use simple float equality because when this should only be used in const
-    // context where Intel peculiarities don't appear
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m128h(a: __m128h, b: __m128h) {
+    assert_eq!(a.as_f16x8(), b.as_f16x8());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "sse2")]
-    pub unsafe fn assert_eq_m128d(a: __m128d, b: __m128d) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f64; 2]>(a), transmute::<_, [f64; 2]>(b))
-        };
-        rt: unsafe {
-            if _mm_movemask_pd(_mm_cmpeq_pd(a, b)) != 0b11 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m256i(a: __m256i, b: __m256i) {
+    assert_eq!(a.as_u32x8(), b.as_u32x8());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "sse")]
-    pub unsafe fn assert_eq_m128(a: __m128, b: __m128) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f32; 4]>(a), transmute::<_, [f32; 4]>(b))
-        };
-        rt: unsafe {
-            let r = _mm_cmpeq_ps(a, b);
-            if _mm_movemask_ps(r) != 0b1111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m256(a: __m256, b: __m256) {
+    assert_eq!(a.as_f32x8(), b.as_f32x8());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx512fp16,avx512vl")]
-    pub unsafe fn assert_eq_m128h(a: __m128h, b: __m128h) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f16; 8]>(a), transmute::<_, [f16; 8]>(b))
-        };
-        rt: unsafe {
-            let r = _mm_cmp_ph_mask::<_CMP_EQ_OQ>(a, b);
-            if r != 0b1111_1111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m256d(a: __m256d, b: __m256d) {
+    assert_eq!(a.as_f64x4(), b.as_f64x4());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx")]
-    pub unsafe fn assert_eq_m256d(a: __m256d, b: __m256d) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f64; 4]>(a), transmute::<_, [f64; 4]>(b))
-        };
-        rt: unsafe {
-            let cmp = _mm256_cmp_pd::<_CMP_EQ_OQ>(a, b);
-            if _mm256_movemask_pd(cmp) != 0b1111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m256h(a: __m256h, b: __m256h) {
+    assert_eq!(a.as_f16x16(), b.as_f16x16());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx")]
-    pub unsafe fn assert_eq_m256(a: __m256, b: __m256) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f32; 8]>(a), transmute::<_, [f32; 8]>(b))
-        };
-        rt: unsafe {
-            let cmp = _mm256_cmp_ps::<_CMP_EQ_OQ>(a, b);
-            if _mm256_movemask_ps(cmp) != 0b11111111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m512i(a: __m512i, b: __m512i) {
+    assert_eq!(a.as_i64x8(), b.as_i64x8());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx512fp16,avx512vl")]
-    pub unsafe fn assert_eq_m256h(a: __m256h, b: __m256h) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f16; 16]>(a), transmute::<_, [f16; 16]>(b))
-        };
-        rt: unsafe {
-            let r = _mm256_cmp_ph_mask::<_CMP_EQ_OQ>(a, b);
-            if r != 0b11111111_11111111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m512(a: __m512, b: __m512) {
+    assert_eq!(a.as_f32x16(), b.as_f32x16());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx512f")]
-    pub unsafe fn assert_eq_m512d(a: __m512d, b: __m512d) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f64; 8]>(a), transmute::<_, [f64; 8]>(b))
-        };
-        rt: unsafe {
-            let cmp = _mm512_cmp_pd_mask::<_CMP_EQ_OQ>(a, b);
-            if cmp != 0b11111111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m512d(a: __m512d, b: __m512d) {
+    assert_eq!(a.as_f64x8(), b.as_f64x8());
+}
 
-    #[track_caller]
-    #[target_feature(enable = "avx512f")]
-    pub unsafe fn assert_eq_m512(a: __m512, b: __m512) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f32; 16]>(a), transmute::<_, [f32; 16]>(b))
-        };
-        rt: unsafe {
-            let cmp = _mm512_cmp_ps_mask::<_CMP_EQ_OQ>(a, b);
-            if cmp != 0b11111111_11111111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
-
-    #[track_caller]
-    #[target_feature(enable = "avx512fp16")]
-    pub unsafe fn assert_eq_m512h(a: __m512h, b: __m512h) {
-        ct: unsafe {
-            assert_eq!(transmute::<_, [f16; 32]>(a), transmute::<_, [f16; 32]>(b))
-        };
-        rt: unsafe {
-            let r = _mm512_cmp_ph_mask::<_CMP_EQ_OQ>(a, b);
-            if r != 0b11111111_11111111_11111111_11111111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        };
-    }
+#[track_caller]
+#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
+pub(crate) const fn assert_eq_m512h(a: __m512h, b: __m512h) {
+    assert_eq!(a.as_f16x32(), b.as_f16x32());
 }
 
 #[target_feature(enable = "sse2")]
-pub(crate) const unsafe fn get_m128d(a: __m128d, idx: usize) -> f64 {
-    transmute::<_, [f64; 2]>(a)[idx]
+pub(crate) const fn get_m128d(a: __m128d, idx: usize) -> f64 {
+    a.as_f64x2().extract(idx)
 }
 
 #[target_feature(enable = "sse")]
-pub(crate) const unsafe fn get_m128(a: __m128, idx: usize) -> f32 {
-    transmute::<_, [f32; 4]>(a)[idx]
+pub(crate) const fn get_m128(a: __m128, idx: usize) -> f32 {
+    a.as_f32x4().extract(idx)
 }
 
 #[target_feature(enable = "avx")]
-pub(crate) const unsafe fn get_m256d(a: __m256d, idx: usize) -> f64 {
-    transmute::<_, [f64; 4]>(a)[idx]
+pub(crate) const fn get_m256d(a: __m256d, idx: usize) -> f64 {
+    a.as_f64x4().extract(idx)
 }
 
 #[target_feature(enable = "avx")]
-pub(crate) const unsafe fn get_m256(a: __m256, idx: usize) -> f32 {
-    transmute::<_, [f32; 8]>(a)[idx]
+pub(crate) const fn get_m256(a: __m256, idx: usize) -> f32 {
+    a.as_f32x8().extract(idx)
 }
 
 #[target_feature(enable = "avx512f")]
-pub(crate) const unsafe fn get_m512(a: __m512, idx: usize) -> f32 {
-    transmute::<_, [f32; 16]>(a)[idx]
+pub(crate) const fn get_m512(a: __m512, idx: usize) -> f32 {
+    a.as_f32x16().extract(idx)
 }
 
 #[target_feature(enable = "avx512f")]
-pub(crate) const unsafe fn get_m512d(a: __m512d, idx: usize) -> f64 {
-    transmute::<_, [f64; 8]>(a)[idx]
+pub(crate) const fn get_m512d(a: __m512d, idx: usize) -> f64 {
+    a.as_f64x8().extract(idx)
 }
 
 #[target_feature(enable = "avx512f")]
-pub(crate) const unsafe fn get_m512i(a: __m512i, idx: usize) -> i64 {
-    transmute::<_, [i64; 8]>(a)[idx]
+pub(crate) const fn get_m512i(a: __m512i, idx: usize) -> i64 {
+    a.as_i64x8().extract(idx)
 }
 
 // not actually an intrinsic but useful in various tests as we ported from
 // `i64x2::new` which is backwards from `_mm_set_epi64x`
 #[target_feature(enable = "sse2")]
 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-pub const unsafe fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
+pub const fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
     _mm_set_epi64x(b, a)
 }
 
@@ -232,17 +129,17 @@ mod x86_polyfill {
 
     #[rustc_legacy_const_generics(2)]
     #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-    pub const unsafe fn _mm_insert_epi64<const INDEX: i32>(a: __m128i, val: i64) -> __m128i {
+    pub const fn _mm_insert_epi64<const INDEX: i32>(a: __m128i, val: i64) -> __m128i {
         static_assert_uimm_bits!(INDEX, 1);
-        transmute(simd_insert!(a.as_i64x2(), INDEX as u32, val))
+        unsafe { transmute(simd_insert!(a.as_i64x2(), INDEX as u32, val)) }
     }
 
     #[target_feature(enable = "avx2")]
     #[rustc_legacy_const_generics(2)]
     #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
-    pub const unsafe fn _mm256_insert_epi64<const INDEX: i32>(a: __m256i, val: i64) -> __m256i {
+    pub const fn _mm256_insert_epi64<const INDEX: i32>(a: __m256i, val: i64) -> __m256i {
         static_assert_uimm_bits!(INDEX, 2);
-        transmute(simd_insert!(a.as_i64x4(), INDEX as u32, val))
+        unsafe { transmute(simd_insert!(a.as_i64x4(), INDEX as u32, val)) }
     }
 }
 
diff --git a/library/stdarch/crates/core_arch/src/x86/vaes.rs b/library/stdarch/crates/core_arch/src/x86/vaes.rs
index 561b8b4b308c..864b1d56d105 100644
--- a/library/stdarch/crates/core_arch/src/x86/vaes.rs
+++ b/library/stdarch/crates/core_arch/src/x86/vaes.rs
@@ -146,9 +146,9 @@ mod tests {
     // ideally we'd be using quickcheck here instead
 
     #[target_feature(enable = "avx2")]
-    unsafe fn helper_for_256_vaes(
-        linear: unsafe fn(__m128i, __m128i) -> __m128i,
-        vectorized: unsafe fn(__m256i, __m256i) -> __m256i,
+    fn helper_for_256_vaes(
+        linear: fn(__m128i, __m128i) -> __m128i,
+        vectorized: fn(__m256i, __m256i) -> __m256i,
     ) {
         let a = _mm256_set_epi64x(
             0xDCB4DB3657BF0B7D,
@@ -178,7 +178,7 @@ mod tests {
     }
 
     #[target_feature(enable = "sse2")]
-    unsafe fn setup_state_key<T>(broadcast: unsafe fn(__m128i) -> T) -> (T, T) {
+    fn setup_state_key<T>(broadcast: fn(__m128i) -> T) -> (T, T) {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664949.aspx.
         let a = _mm_set_epi64x(0x0123456789abcdef, 0x8899aabbccddeeff);
         let k = _mm_set_epi64x(0x1133557799bbddff, 0x0022446688aaccee);
@@ -186,17 +186,17 @@ mod tests {
     }
 
     #[target_feature(enable = "avx2")]
-    unsafe fn setup_state_key_256() -> (__m256i, __m256i) {
+    fn setup_state_key_256() -> (__m256i, __m256i) {
         setup_state_key(_mm256_broadcastsi128_si256)
     }
 
     #[target_feature(enable = "avx512f")]
-    unsafe fn setup_state_key_512() -> (__m512i, __m512i) {
+    fn setup_state_key_512() -> (__m512i, __m512i) {
         setup_state_key(_mm512_broadcast_i32x4)
     }
 
     #[simd_test(enable = "vaes,avx512vl")]
-    unsafe fn test_mm256_aesdec_epi128() {
+    fn test_mm256_aesdec_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664949.aspx.
         let (a, k) = setup_state_key_256();
         let e = _mm_set_epi64x(0x044e4f5176fec48f, 0xb57ecfa381da39ee);
@@ -208,7 +208,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512vl")]
-    unsafe fn test_mm256_aesdeclast_epi128() {
+    fn test_mm256_aesdeclast_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714178.aspx.
         let (a, k) = setup_state_key_256();
         let e = _mm_set_epi64x(0x36cad57d9072bf9e, 0xf210dd981fa4a493);
@@ -220,7 +220,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512vl")]
-    unsafe fn test_mm256_aesenc_epi128() {
+    fn test_mm256_aesenc_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664810.aspx.
         // they are repeated appropriately
         let (a, k) = setup_state_key_256();
@@ -233,7 +233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512vl")]
-    unsafe fn test_mm256_aesenclast_epi128() {
+    fn test_mm256_aesenclast_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714136.aspx.
         let (a, k) = setup_state_key_256();
         let e = _mm_set_epi64x(0xb6dd7df25d7ab320, 0x4b04f98cf4c860f8);
@@ -245,9 +245,9 @@ mod tests {
     }
 
     #[target_feature(enable = "avx512f")]
-    unsafe fn helper_for_512_vaes(
-        linear: unsafe fn(__m128i, __m128i) -> __m128i,
-        vectorized: unsafe fn(__m512i, __m512i) -> __m512i,
+    fn helper_for_512_vaes(
+        linear: fn(__m128i, __m128i) -> __m128i,
+        vectorized: fn(__m512i, __m512i) -> __m512i,
     ) {
         let a = _mm512_set_epi64(
             0xDCB4DB3657BF0B7D,
@@ -291,7 +291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512f")]
-    unsafe fn test_mm512_aesdec_epi128() {
+    fn test_mm512_aesdec_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664949.aspx.
         let (a, k) = setup_state_key_512();
         let e = _mm_set_epi64x(0x044e4f5176fec48f, 0xb57ecfa381da39ee);
@@ -303,7 +303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512f")]
-    unsafe fn test_mm512_aesdeclast_epi128() {
+    fn test_mm512_aesdeclast_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714178.aspx.
         let (a, k) = setup_state_key_512();
         let e = _mm_set_epi64x(0x36cad57d9072bf9e, 0xf210dd981fa4a493);
@@ -315,7 +315,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512f")]
-    unsafe fn test_mm512_aesenc_epi128() {
+    fn test_mm512_aesenc_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc664810.aspx.
         let (a, k) = setup_state_key_512();
         let e = _mm_set_epi64x(0x16ab0e57dfc442ed, 0x28e4ee1884504333);
@@ -327,7 +327,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vaes,avx512f")]
-    unsafe fn test_mm512_aesenclast_epi128() {
+    fn test_mm512_aesenclast_epi128() {
         // Constants taken from https://msdn.microsoft.com/en-us/library/cc714136.aspx.
         let (a, k) = setup_state_key_512();
         let e = _mm_set_epi64x(0xb6dd7df25d7ab320, 0x4b04f98cf4c860f8);
diff --git a/library/stdarch/crates/core_arch/src/x86/vpclmulqdq.rs b/library/stdarch/crates/core_arch/src/x86/vpclmulqdq.rs
index b1f23bd2f45c..ad44e59f3ada 100644
--- a/library/stdarch/crates/core_arch/src/x86/vpclmulqdq.rs
+++ b/library/stdarch/crates/core_arch/src/x86/vpclmulqdq.rs
@@ -124,9 +124,9 @@ mod tests {
     // this function tests one of the possible 4 instances
     // with different inputs across lanes
     #[target_feature(enable = "vpclmulqdq,avx512f")]
-    unsafe fn verify_512_helper(
-        linear: unsafe fn(__m128i, __m128i) -> __m128i,
-        vectorized: unsafe fn(__m512i, __m512i) -> __m512i,
+    fn verify_512_helper(
+        linear: fn(__m128i, __m128i) -> __m128i,
+        vectorized: fn(__m512i, __m512i) -> __m512i,
     ) {
         let a = _mm512_set_epi64(
             0xDCB4DB3657BF0B7D,
@@ -165,9 +165,9 @@ mod tests {
     // this function tests one of the possible 4 instances
     // with different inputs across lanes for the VL version
     #[target_feature(enable = "vpclmulqdq,avx512vl")]
-    unsafe fn verify_256_helper(
-        linear: unsafe fn(__m128i, __m128i) -> __m128i,
-        vectorized: unsafe fn(__m256i, __m256i) -> __m256i,
+    fn verify_256_helper(
+        linear: fn(__m128i, __m128i) -> __m128i,
+        vectorized: fn(__m256i, __m256i) -> __m256i,
     ) {
         let a = _mm512_set_epi64(
             0xDCB4DB3657BF0B7D,
@@ -207,7 +207,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vpclmulqdq,avx512f")]
-    unsafe fn test_mm512_clmulepi64_epi128() {
+    fn test_mm512_clmulepi64_epi128() {
         verify_kat_pclmul!(
             _mm512_broadcast_i32x4,
             _mm512_clmulepi64_epi128,
@@ -233,7 +233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "vpclmulqdq,avx512vl")]
-    unsafe fn test_mm256_clmulepi64_epi128() {
+    fn test_mm256_clmulepi64_epi128() {
         verify_kat_pclmul!(
             _mm256_broadcastsi128_si256,
             _mm256_clmulepi64_epi128,
diff --git a/library/stdarch/crates/core_arch/src/x86_64/abm.rs b/library/stdarch/crates/core_arch/src/x86_64/abm.rs
index 9fb76be4ba89..21b5f26a9b4f 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/abm.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/abm.rs
@@ -54,12 +54,12 @@ mod tests {
     use crate::core_arch::arch::x86_64::*;
 
     #[simd_test(enable = "lzcnt")]
-    const unsafe fn test_lzcnt_u64() {
+    const fn test_lzcnt_u64() {
         assert_eq!(_lzcnt_u64(0b0101_1010), 57);
     }
 
     #[simd_test(enable = "popcnt")]
-    const unsafe fn test_popcnt64() {
+    const fn test_popcnt64() {
         assert_eq!(_popcnt64(0b0101_1010), 4);
     }
 }
diff --git a/library/stdarch/crates/core_arch/src/x86_64/amx.rs b/library/stdarch/crates/core_arch/src/x86_64/amx.rs
index 3e0ac8f47cea..f372f7066d51 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/amx.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/amx.rs
@@ -510,7 +510,7 @@ mod tests {
     use syscalls::{Sysno, syscall};
 
     #[allow(non_camel_case_types)]
-    #[repr(packed)]
+    #[repr(C, packed)]
     #[derive(Copy, Clone, Default, Debug, PartialEq)]
     struct __tilecfg {
         /// 0 `or` 1
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx.rs b/library/stdarch/crates/core_arch/src/x86_64/avx.rs
index aae3c981d6fe..b626c1a59299 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx.rs
@@ -52,7 +52,7 @@ mod tests {
     use crate::core_arch::arch::x86_64::*;
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_insert_epi64() {
+    const fn test_mm256_insert_epi64() {
         let a = _mm256_setr_epi64x(1, 2, 3, 4);
         let r = _mm256_insert_epi64::<3>(a, 0);
         let e = _mm256_setr_epi64x(1, 2, 3, 0);
@@ -60,7 +60,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx")]
-    const unsafe fn test_mm256_extract_epi64() {
+    const fn test_mm256_extract_epi64() {
         let a = _mm256_setr_epi64x(0, 1, 2, 3);
         let r = _mm256_extract_epi64::<3>(a);
         assert_eq!(r, 3);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx512bw.rs b/library/stdarch/crates/core_arch/src/x86_64/avx512bw.rs
index a8e5183e0c2f..3450f6e194d5 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx512bw.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx512bw.rs
@@ -31,7 +31,7 @@ mod tests {
     use crate::core_arch::{x86::*, x86_64::*};
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_cvtmask64_u64() {
+    const fn test_cvtmask64_u64() {
         let a: __mmask64 = 0b11001100_00110011_01100110_10011001;
         let r = _cvtmask64_u64(a);
         let e: u64 = 0b11001100_00110011_01100110_10011001;
@@ -39,7 +39,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512bw")]
-    const unsafe fn test_cvtu64_mask64() {
+    const fn test_cvtu64_mask64() {
         let a: u64 = 0b11001100_00110011_01100110_10011001;
         let r = _cvtu64_mask64(a);
         let e: __mmask64 = 0b11001100_00110011_01100110_10011001;
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
index c85a5580c864..368fb0c238e4 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
@@ -567,7 +567,7 @@ mod tests {
     use crate::hint::black_box;
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_abs_epi64() {
+    const fn test_mm512_abs_epi64() {
         let a = _mm512_set_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let r = _mm512_abs_epi64(a);
         let e = _mm512_set_epi64(0, 1, 1, i64::MAX, i64::MAX.wrapping_add(1), 100, 100, 32);
@@ -575,7 +575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_abs_epi64() {
+    const fn test_mm512_mask_abs_epi64() {
         let a = _mm512_set_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let r = _mm512_mask_abs_epi64(a, 0, a);
         assert_eq_m512i(r, a);
@@ -585,7 +585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_abs_epi64() {
+    const fn test_mm512_maskz_abs_epi64() {
         let a = _mm512_set_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let r = _mm512_maskz_abs_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -595,7 +595,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_abs_epi64() {
+    const fn test_mm256_abs_epi64() {
         let a = _mm256_set_epi64x(i64::MAX, i64::MIN, 100, -100);
         let r = _mm256_abs_epi64(a);
         let e = _mm256_set_epi64x(i64::MAX, i64::MAX.wrapping_add(1), 100, 100);
@@ -603,7 +603,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_abs_epi64() {
+    const fn test_mm256_mask_abs_epi64() {
         let a = _mm256_set_epi64x(i64::MAX, i64::MIN, 100, -100);
         let r = _mm256_mask_abs_epi64(a, 0, a);
         assert_eq_m256i(r, a);
@@ -613,7 +613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_abs_epi64() {
+    const fn test_mm256_maskz_abs_epi64() {
         let a = _mm256_set_epi64x(i64::MAX, i64::MIN, 100, -100);
         let r = _mm256_maskz_abs_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -623,7 +623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_abs_epi64() {
+    const fn test_mm_abs_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let r = _mm_abs_epi64(a);
         let e = _mm_set_epi64x(i64::MAX, i64::MAX.wrapping_add(1));
@@ -635,7 +635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_abs_epi64() {
+    const fn test_mm_mask_abs_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let r = _mm_mask_abs_epi64(a, 0, a);
         assert_eq_m128i(r, a);
@@ -649,7 +649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_abs_epi64() {
+    const fn test_mm_maskz_abs_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let r = _mm_maskz_abs_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -663,7 +663,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_abs_pd() {
+    const fn test_mm512_abs_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let r = _mm512_abs_pd(a);
         let e = _mm512_setr_pd(0., 1., 1., f64::MAX, f64::MAX, 100., 100., 32.);
@@ -671,7 +671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_abs_pd() {
+    const fn test_mm512_mask_abs_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let r = _mm512_mask_abs_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -681,7 +681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mov_epi64() {
+    const fn test_mm512_mask_mov_epi64() {
         let src = _mm512_set1_epi64(1);
         let a = _mm512_set1_epi64(2);
         let r = _mm512_mask_mov_epi64(src, 0, a);
@@ -691,7 +691,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mov_epi64() {
+    const fn test_mm512_maskz_mov_epi64() {
         let a = _mm512_set1_epi64(2);
         let r = _mm512_maskz_mov_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -700,7 +700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_epi64() {
+    const fn test_mm256_mask_mov_epi64() {
         let src = _mm256_set1_epi64x(1);
         let a = _mm256_set1_epi64x(2);
         let r = _mm256_mask_mov_epi64(src, 0, a);
@@ -710,7 +710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_epi64() {
+    const fn test_mm256_maskz_mov_epi64() {
         let a = _mm256_set1_epi64x(2);
         let r = _mm256_maskz_mov_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -719,7 +719,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mov_epi64() {
+    const fn test_mm_mask_mov_epi64() {
         let src = _mm_set1_epi64x(1);
         let a = _mm_set1_epi64x(2);
         let r = _mm_mask_mov_epi64(src, 0, a);
@@ -729,7 +729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_epi64() {
+    const fn test_mm_maskz_mov_epi64() {
         let a = _mm_set1_epi64x(2);
         let r = _mm_maskz_mov_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -738,7 +738,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mov_pd() {
+    const fn test_mm512_mask_mov_pd() {
         let src = _mm512_set1_pd(1.);
         let a = _mm512_set1_pd(2.);
         let r = _mm512_mask_mov_pd(src, 0, a);
@@ -748,7 +748,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mov_pd() {
+    const fn test_mm512_maskz_mov_pd() {
         let a = _mm512_set1_pd(2.);
         let r = _mm512_maskz_mov_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -757,7 +757,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mov_pd() {
+    const fn test_mm256_mask_mov_pd() {
         let src = _mm256_set1_pd(1.);
         let a = _mm256_set1_pd(2.);
         let r = _mm256_mask_mov_pd(src, 0, a);
@@ -767,7 +767,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mov_pd() {
+    const fn test_mm256_maskz_mov_pd() {
         let a = _mm256_set1_pd(2.);
         let r = _mm256_maskz_mov_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -776,7 +776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mov_pd() {
+    const fn test_mm_mask_mov_pd() {
         let src = _mm_set1_pd(1.);
         let a = _mm_set1_pd(2.);
         let r = _mm_mask_mov_pd(src, 0, a);
@@ -786,7 +786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mov_pd() {
+    const fn test_mm_maskz_mov_pd() {
         let a = _mm_set1_pd(2.);
         let r = _mm_maskz_mov_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -795,7 +795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_add_epi64() {
+    const fn test_mm512_add_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_add_epi64(a, b);
@@ -804,7 +804,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_add_epi64() {
+    const fn test_mm512_mask_add_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_mask_add_epi64(a, 0, a, b);
@@ -815,7 +815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_add_epi64() {
+    const fn test_mm512_maskz_add_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_maskz_add_epi64(0, a, b);
@@ -826,7 +826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_add_epi64() {
+    const fn test_mm256_mask_add_epi64() {
         let a = _mm256_set_epi64x(1, -1, i64::MAX, i64::MIN);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_mask_add_epi64(a, 0, a, b);
@@ -837,7 +837,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_epi64() {
+    const fn test_mm256_maskz_add_epi64() {
         let a = _mm256_set_epi64x(1, -1, i64::MAX, i64::MIN);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_add_epi64(0, a, b);
@@ -848,7 +848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_add_epi64() {
+    const fn test_mm_mask_add_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let b = _mm_set1_epi64x(1);
         let r = _mm_mask_add_epi64(a, 0, a, b);
@@ -859,7 +859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_add_epi64() {
+    const fn test_mm_maskz_add_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let b = _mm_set1_epi64x(1);
         let r = _mm_maskz_add_epi64(0, a, b);
@@ -870,7 +870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_add_pd() {
+    const fn test_mm512_add_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_add_pd(a, b);
@@ -879,7 +879,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_add_pd() {
+    const fn test_mm512_mask_add_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_mask_add_pd(a, 0, a, b);
@@ -890,7 +890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_add_pd() {
+    const fn test_mm512_maskz_add_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_maskz_add_pd(0, a, b);
@@ -901,7 +901,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_add_pd() {
+    const fn test_mm256_mask_add_pd() {
         let a = _mm256_set_pd(1., -1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(1.);
         let r = _mm256_mask_add_pd(a, 0, a, b);
@@ -912,7 +912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_add_pd() {
+    const fn test_mm256_maskz_add_pd() {
         let a = _mm256_set_pd(1., -1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(1.);
         let r = _mm256_maskz_add_pd(0, a, b);
@@ -923,7 +923,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_add_pd() {
+    const fn test_mm_mask_add_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(1.);
         let r = _mm_mask_add_pd(a, 0, a, b);
@@ -934,7 +934,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_add_pd() {
+    const fn test_mm_maskz_add_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(1.);
         let r = _mm_maskz_add_pd(0, a, b);
@@ -945,7 +945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sub_epi64() {
+    const fn test_mm512_sub_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_sub_epi64(a, b);
@@ -954,7 +954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sub_epi64() {
+    const fn test_mm512_mask_sub_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_mask_sub_epi64(a, 0, a, b);
@@ -965,7 +965,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sub_epi64() {
+    const fn test_mm512_maskz_sub_epi64() {
         let a = _mm512_setr_epi64(0, 1, -1, i64::MAX, i64::MIN, 100, -100, -32);
         let b = _mm512_set1_epi64(1);
         let r = _mm512_maskz_sub_epi64(0, a, b);
@@ -976,7 +976,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_epi64() {
+    const fn test_mm256_mask_sub_epi64() {
         let a = _mm256_set_epi64x(1, -1, i64::MAX, i64::MIN);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_mask_sub_epi64(a, 0, a, b);
@@ -987,7 +987,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_epi64() {
+    const fn test_mm256_maskz_sub_epi64() {
         let a = _mm256_set_epi64x(1, -1, i64::MAX, i64::MIN);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_sub_epi64(0, a, b);
@@ -998,7 +998,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sub_epi64() {
+    const fn test_mm_mask_sub_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let b = _mm_set1_epi64x(1);
         let r = _mm_mask_sub_epi64(a, 0, a, b);
@@ -1009,7 +1009,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_epi64() {
+    const fn test_mm_maskz_sub_epi64() {
         let a = _mm_set_epi64x(i64::MAX, i64::MIN);
         let b = _mm_set1_epi64x(1);
         let r = _mm_maskz_sub_epi64(0, a, b);
@@ -1020,7 +1020,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sub_pd() {
+    const fn test_mm512_sub_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_sub_pd(a, b);
@@ -1029,7 +1029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sub_pd() {
+    const fn test_mm512_mask_sub_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_mask_sub_pd(a, 0, a, b);
@@ -1040,7 +1040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sub_pd() {
+    const fn test_mm512_maskz_sub_pd() {
         let a = _mm512_setr_pd(0., 1., -1., f64::MAX, f64::MIN, 100., -100., -32.);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_maskz_sub_pd(0, a, b);
@@ -1051,7 +1051,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sub_pd() {
+    const fn test_mm256_mask_sub_pd() {
         let a = _mm256_set_pd(1., -1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(1.);
         let r = _mm256_mask_sub_pd(a, 0, a, b);
@@ -1062,7 +1062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sub_pd() {
+    const fn test_mm256_maskz_sub_pd() {
         let a = _mm256_set_pd(1., -1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(1.);
         let r = _mm256_maskz_sub_pd(0, a, b);
@@ -1073,7 +1073,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sub_pd() {
+    const fn test_mm_mask_sub_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(1.);
         let r = _mm_mask_sub_pd(a, 0, a, b);
@@ -1084,7 +1084,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sub_pd() {
+    const fn test_mm_maskz_sub_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(1.);
         let r = _mm_maskz_sub_pd(0, a, b);
@@ -1095,7 +1095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mul_epi32() {
+    const fn test_mm512_mul_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mul_epi32(a, b);
@@ -1104,7 +1104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mul_epi32() {
+    const fn test_mm512_mask_mul_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_mul_epi32(a, 0, a, b);
@@ -1119,7 +1119,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mul_epi32() {
+    const fn test_mm512_maskz_mul_epi32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_mul_epi32(0, a, b);
@@ -1130,7 +1130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mul_epi32() {
+    const fn test_mm256_mask_mul_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_mask_mul_epi32(a, 0, a, b);
@@ -1141,7 +1141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mul_epi32() {
+    const fn test_mm256_maskz_mul_epi32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_mul_epi32(0, a, b);
@@ -1152,7 +1152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mul_epi32() {
+    const fn test_mm_mask_mul_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_mask_mul_epi32(a, 0, a, b);
@@ -1163,7 +1163,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_epi32() {
+    const fn test_mm_maskz_mul_epi32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_mul_epi32(0, a, b);
@@ -1174,7 +1174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mul_epu32() {
+    const fn test_mm512_mul_epu32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mul_epu32(a, b);
@@ -1183,7 +1183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mul_epu32() {
+    const fn test_mm512_mask_mul_epu32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_mask_mul_epu32(a, 0, a, b);
@@ -1198,7 +1198,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mul_epu32() {
+    const fn test_mm512_maskz_mul_epu32() {
         let a = _mm512_set1_epi32(1);
         let b = _mm512_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
         let r = _mm512_maskz_mul_epu32(0, a, b);
@@ -1209,7 +1209,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mul_epu32() {
+    const fn test_mm256_mask_mul_epu32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_mask_mul_epu32(a, 0, a, b);
@@ -1220,7 +1220,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mul_epu32() {
+    const fn test_mm256_maskz_mul_epu32() {
         let a = _mm256_set1_epi32(1);
         let b = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm256_maskz_mul_epu32(0, a, b);
@@ -1231,7 +1231,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mul_epu32() {
+    const fn test_mm_mask_mul_epu32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_mask_mul_epu32(a, 0, a, b);
@@ -1242,7 +1242,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_epu32() {
+    const fn test_mm_maskz_mul_epu32() {
         let a = _mm_set1_epi32(1);
         let b = _mm_set_epi32(1, 2, 3, 4);
         let r = _mm_maskz_mul_epu32(0, a, b);
@@ -1253,7 +1253,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mullox_epi64() {
+    const fn test_mm512_mullox_epi64() {
         let a = _mm512_setr_epi64(0, 1, i64::MAX, i64::MIN, i64::MAX, 100, -100, -32);
         let b = _mm512_set1_epi64(2);
         let r = _mm512_mullox_epi64(a, b);
@@ -1262,7 +1262,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mullox_epi64() {
+    const fn test_mm512_mask_mullox_epi64() {
         let a = _mm512_setr_epi64(0, 1, i64::MAX, i64::MIN, i64::MAX, 100, -100, -32);
         let b = _mm512_set1_epi64(2);
         let r = _mm512_mask_mullox_epi64(a, 0, a, b);
@@ -1273,7 +1273,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mul_pd() {
+    const fn test_mm512_mul_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_set1_pd(2.);
         let r = _mm512_mul_pd(a, b);
@@ -1286,7 +1286,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_mul_pd() {
+    const fn test_mm512_mask_mul_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_set1_pd(2.);
         let r = _mm512_mask_mul_pd(a, 0, a, b);
@@ -1301,7 +1301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_mul_pd() {
+    const fn test_mm512_maskz_mul_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_set1_pd(2.);
         let r = _mm512_maskz_mul_pd(0, a, b);
@@ -1312,7 +1312,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_mul_pd() {
+    const fn test_mm256_mask_mul_pd() {
         let a = _mm256_set_pd(0., 1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(2.);
         let r = _mm256_mask_mul_pd(a, 0, a, b);
@@ -1323,7 +1323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_mul_pd() {
+    const fn test_mm256_maskz_mul_pd() {
         let a = _mm256_set_pd(0., 1., f64::MAX, f64::MIN);
         let b = _mm256_set1_pd(2.);
         let r = _mm256_maskz_mul_pd(0, a, b);
@@ -1334,7 +1334,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_mul_pd() {
+    const fn test_mm_mask_mul_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(2.);
         let r = _mm_mask_mul_pd(a, 0, a, b);
@@ -1345,7 +1345,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_mul_pd() {
+    const fn test_mm_maskz_mul_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set1_pd(2.);
         let r = _mm_maskz_mul_pd(0, a, b);
@@ -1356,7 +1356,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_div_pd() {
+    const fn test_mm512_div_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_setr_pd(2., 2., 0., 0., 0., 0., 2., 2.);
         let r = _mm512_div_pd(a, b);
@@ -1369,7 +1369,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_div_pd() {
+    const fn test_mm512_mask_div_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_setr_pd(2., 2., 0., 0., 0., 0., 2., 2.);
         let r = _mm512_mask_div_pd(a, 0, a, b);
@@ -1384,7 +1384,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_div_pd() {
+    const fn test_mm512_maskz_div_pd() {
         let a = _mm512_setr_pd(0., 1., f64::MAX, f64::MIN, f64::MAX, f64::MIN, -100., -32.);
         let b = _mm512_setr_pd(2., 2., 0., 0., 0., 0., 2., 2.);
         let r = _mm512_maskz_div_pd(0, a, b);
@@ -1395,7 +1395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_div_pd() {
+    const fn test_mm256_mask_div_pd() {
         let a = _mm256_set_pd(0., 1., f64::MAX, f64::MIN);
         let b = _mm256_set_pd(2., 2., 0., 0.);
         let r = _mm256_mask_div_pd(a, 0, a, b);
@@ -1406,7 +1406,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_div_pd() {
+    const fn test_mm256_maskz_div_pd() {
         let a = _mm256_set_pd(0., 1., f64::MAX, f64::MIN);
         let b = _mm256_set_pd(2., 2., 0., 0.);
         let r = _mm256_maskz_div_pd(0, a, b);
@@ -1417,7 +1417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_div_pd() {
+    const fn test_mm_mask_div_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set_pd(0., 0.);
         let r = _mm_mask_div_pd(a, 0, a, b);
@@ -1428,7 +1428,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_div_pd() {
+    const fn test_mm_maskz_div_pd() {
         let a = _mm_set_pd(f64::MAX, f64::MIN);
         let b = _mm_set_pd(0., 0.);
         let r = _mm_maskz_div_pd(0, a, b);
@@ -1439,7 +1439,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_max_epi64() {
+    const fn test_mm512_max_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_max_epi64(a, b);
@@ -1448,7 +1448,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_max_epi64() {
+    const fn test_mm512_mask_max_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_max_epi64(a, 0, a, b);
@@ -1459,7 +1459,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_max_epi64() {
+    const fn test_mm512_maskz_max_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_max_epi64(0, a, b);
@@ -1470,7 +1470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_max_epi64() {
+    const fn test_mm256_max_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_max_epi64(a, b);
@@ -1479,7 +1479,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epi64() {
+    const fn test_mm256_mask_max_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_mask_max_epi64(a, 0, a, b);
@@ -1490,7 +1490,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epi64() {
+    const fn test_mm256_maskz_max_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_maskz_max_epi64(0, a, b);
@@ -1501,7 +1501,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_max_epi64() {
+    const fn test_mm_max_epi64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_max_epi64(a, b);
@@ -1510,7 +1510,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_max_epi64() {
+    const fn test_mm_mask_max_epi64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_mask_max_epi64(a, 0, a, b);
@@ -1521,7 +1521,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epi64() {
+    const fn test_mm_maskz_max_epi64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_maskz_max_epi64(0, a, b);
@@ -1532,7 +1532,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_max_pd() {
+    fn test_mm512_max_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_max_pd(a, b);
@@ -1541,7 +1541,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_max_pd() {
+    fn test_mm512_mask_max_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_mask_max_pd(a, 0, a, b);
@@ -1552,7 +1552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_max_pd() {
+    fn test_mm512_maskz_max_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_maskz_max_pd(0, a, b);
@@ -1563,7 +1563,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_max_pd() {
+    fn test_mm256_mask_max_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_mask_max_pd(a, 0, a, b);
@@ -1574,7 +1574,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_max_pd() {
+    fn test_mm256_maskz_max_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_maskz_max_pd(0, a, b);
@@ -1585,7 +1585,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_max_pd() {
+    fn test_mm_mask_max_pd() {
         let a = _mm_set_pd(2., 3.);
         let b = _mm_set_pd(3., 2.);
         let r = _mm_mask_max_pd(a, 0, a, b);
@@ -1596,7 +1596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_max_pd() {
+    fn test_mm_maskz_max_pd() {
         let a = _mm_set_pd(2., 3.);
         let b = _mm_set_pd(3., 2.);
         let r = _mm_maskz_max_pd(0, a, b);
@@ -1607,7 +1607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_max_epu64() {
+    const fn test_mm512_max_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_max_epu64(a, b);
@@ -1616,7 +1616,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_max_epu64() {
+    const fn test_mm512_mask_max_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_max_epu64(a, 0, a, b);
@@ -1627,7 +1627,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_max_epu64() {
+    const fn test_mm512_maskz_max_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_max_epu64(0, a, b);
@@ -1638,7 +1638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_max_epu64() {
+    const fn test_mm256_max_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_max_epu64(a, b);
@@ -1647,7 +1647,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_max_epu64() {
+    const fn test_mm256_mask_max_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_mask_max_epu64(a, 0, a, b);
@@ -1658,7 +1658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_max_epu64() {
+    const fn test_mm256_maskz_max_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_maskz_max_epu64(0, a, b);
@@ -1669,7 +1669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_max_epu64() {
+    const fn test_mm_max_epu64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_max_epu64(a, b);
@@ -1678,7 +1678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_max_epu64() {
+    const fn test_mm_mask_max_epu64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_mask_max_epu64(a, 0, a, b);
@@ -1689,7 +1689,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_max_epu64() {
+    const fn test_mm_maskz_max_epu64() {
         let a = _mm_set_epi64x(2, 3);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_maskz_max_epu64(0, a, b);
@@ -1700,7 +1700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_min_epi64() {
+    const fn test_mm512_min_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_min_epi64(a, b);
@@ -1709,7 +1709,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_min_epi64() {
+    const fn test_mm512_mask_min_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_min_epi64(a, 0, a, b);
@@ -1720,7 +1720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_min_epi64() {
+    const fn test_mm512_maskz_min_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_min_epi64(0, a, b);
@@ -1731,7 +1731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_min_epi64() {
+    const fn test_mm256_min_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_min_epi64(a, b);
@@ -1740,7 +1740,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epi64() {
+    const fn test_mm256_mask_min_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_mask_min_epi64(a, 0, a, b);
@@ -1751,7 +1751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epi64() {
+    const fn test_mm256_maskz_min_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_maskz_min_epi64(0, a, b);
@@ -1762,7 +1762,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_min_epi64() {
+    const fn test_mm_min_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_min_epi64(a, b);
@@ -1776,7 +1776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_min_epi64() {
+    const fn test_mm_mask_min_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_mask_min_epi64(a, 0, a, b);
@@ -1787,7 +1787,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epi64() {
+    const fn test_mm_maskz_min_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(3, 2);
         let r = _mm_maskz_min_epi64(0, a, b);
@@ -1798,7 +1798,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_min_pd() {
+    fn test_mm512_min_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_min_pd(a, b);
@@ -1807,7 +1807,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_min_pd() {
+    fn test_mm512_mask_min_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_mask_min_pd(a, 0, a, b);
@@ -1818,7 +1818,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_min_pd() {
+    fn test_mm512_maskz_min_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_maskz_min_pd(0, a, b);
@@ -1829,7 +1829,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_min_pd() {
+    fn test_mm256_mask_min_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_mask_min_pd(a, 0, a, b);
@@ -1840,7 +1840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_min_pd() {
+    fn test_mm256_maskz_min_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_maskz_min_pd(0, a, b);
@@ -1851,7 +1851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_min_pd() {
+    fn test_mm_mask_min_pd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(1., 0.);
         let r = _mm_mask_min_pd(a, 0, a, b);
@@ -1862,7 +1862,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_min_pd() {
+    fn test_mm_maskz_min_pd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set_pd(1., 0.);
         let r = _mm_maskz_min_pd(0, a, b);
@@ -1873,7 +1873,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_min_epu64() {
+    const fn test_mm512_min_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_min_epu64(a, b);
@@ -1882,7 +1882,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_min_epu64() {
+    const fn test_mm512_mask_min_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_mask_min_epu64(a, 0, a, b);
@@ -1893,7 +1893,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_min_epu64() {
+    const fn test_mm512_maskz_min_epu64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let b = _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0);
         let r = _mm512_maskz_min_epu64(0, a, b);
@@ -1904,7 +1904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_min_epu64() {
+    const fn test_mm256_min_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_min_epu64(a, b);
@@ -1913,7 +1913,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_min_epu64() {
+    const fn test_mm256_mask_min_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_mask_min_epu64(a, 0, a, b);
@@ -1924,7 +1924,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_min_epu64() {
+    const fn test_mm256_maskz_min_epu64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_maskz_min_epu64(0, a, b);
@@ -1935,7 +1935,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_min_epu64() {
+    const fn test_mm_min_epu64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(1, 0);
         let r = _mm_min_epu64(a, b);
@@ -1944,7 +1944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_min_epu64() {
+    const fn test_mm_mask_min_epu64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(1, 0);
         let r = _mm_mask_min_epu64(a, 0, a, b);
@@ -1955,7 +1955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_min_epu64() {
+    const fn test_mm_maskz_min_epu64() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(1, 0);
         let r = _mm_maskz_min_epu64(0, a, b);
@@ -1966,7 +1966,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sqrt_pd() {
+    fn test_mm512_sqrt_pd() {
         let a = _mm512_setr_pd(0., 1., 4., 9., 16., 25., 36., 49.);
         let r = _mm512_sqrt_pd(a);
         let e = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
@@ -1974,7 +1974,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sqrt_pd() {
+    fn test_mm512_mask_sqrt_pd() {
         let a = _mm512_setr_pd(0., 1., 4., 9., 16., 25., 36., 49.);
         let r = _mm512_mask_sqrt_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -1984,7 +1984,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sqrt_pd() {
+    fn test_mm512_maskz_sqrt_pd() {
         let a = _mm512_setr_pd(0., 1., 4., 9., 16., 25., 36., 49.);
         let r = _mm512_maskz_sqrt_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -1994,7 +1994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sqrt_pd() {
+    fn test_mm256_mask_sqrt_pd() {
         let a = _mm256_set_pd(0., 1., 4., 9.);
         let r = _mm256_mask_sqrt_pd(a, 0, a);
         assert_eq_m256d(r, a);
@@ -2004,7 +2004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sqrt_pd() {
+    fn test_mm256_maskz_sqrt_pd() {
         let a = _mm256_set_pd(0., 1., 4., 9.);
         let r = _mm256_maskz_sqrt_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -2014,7 +2014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sqrt_pd() {
+    fn test_mm_mask_sqrt_pd() {
         let a = _mm_set_pd(0., 1.);
         let r = _mm_mask_sqrt_pd(a, 0, a);
         assert_eq_m128d(r, a);
@@ -2024,7 +2024,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sqrt_pd() {
+    fn test_mm_maskz_sqrt_pd() {
         let a = _mm_set_pd(0., 1.);
         let r = _mm_maskz_sqrt_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -2034,7 +2034,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmadd_pd() {
+    const fn test_mm512_fmadd_pd() {
         let a = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
@@ -2044,7 +2044,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmadd_pd() {
+    const fn test_mm512_mask_fmadd_pd() {
         let a = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
@@ -2056,7 +2056,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmadd_pd() {
+    const fn test_mm512_maskz_fmadd_pd() {
         let a = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
@@ -2068,7 +2068,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmadd_pd() {
+    const fn test_mm512_mask3_fmadd_pd() {
         let a = _mm512_setr_pd(1., 1., 1., 1., 1., 1., 1., 1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2080,7 +2080,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmadd_pd() {
+    const fn test_mm256_mask_fmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2092,7 +2092,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmadd_pd() {
+    const fn test_mm256_maskz_fmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2104,7 +2104,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmadd_pd() {
+    const fn test_mm256_mask3_fmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2116,7 +2116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmadd_pd() {
+    const fn test_mm_mask_fmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2128,7 +2128,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmadd_pd() {
+    const fn test_mm_maskz_fmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2140,7 +2140,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmadd_pd() {
+    const fn test_mm_mask3_fmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2152,7 +2152,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmsub_pd() {
+    const fn test_mm512_fmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2162,7 +2162,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmsub_pd() {
+    const fn test_mm512_mask_fmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2174,7 +2174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmsub_pd() {
+    const fn test_mm512_maskz_fmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2186,7 +2186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmsub_pd() {
+    const fn test_mm512_mask3_fmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2198,7 +2198,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsub_pd() {
+    const fn test_mm256_mask_fmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2210,7 +2210,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsub_pd() {
+    const fn test_mm256_maskz_fmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2222,7 +2222,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsub_pd() {
+    const fn test_mm256_mask3_fmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2234,7 +2234,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmsub_pd() {
+    const fn test_mm_mask_fmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2246,7 +2246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsub_pd() {
+    const fn test_mm_maskz_fmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2258,7 +2258,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsub_pd() {
+    const fn test_mm_mask3_fmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2270,7 +2270,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmaddsub_pd() {
+    const fn test_mm512_fmaddsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2280,7 +2280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmaddsub_pd() {
+    const fn test_mm512_mask_fmaddsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2292,7 +2292,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmaddsub_pd() {
+    const fn test_mm512_maskz_fmaddsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2304,7 +2304,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmaddsub_pd() {
+    const fn test_mm512_mask3_fmaddsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2316,7 +2316,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmaddsub_pd() {
+    const fn test_mm256_mask_fmaddsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2328,7 +2328,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmaddsub_pd() {
+    const fn test_mm256_maskz_fmaddsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2340,7 +2340,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmaddsub_pd() {
+    const fn test_mm256_mask3_fmaddsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2352,7 +2352,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmaddsub_pd() {
+    const fn test_mm_mask_fmaddsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2364,7 +2364,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmaddsub_pd() {
+    const fn test_mm_maskz_fmaddsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2376,7 +2376,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmaddsub_pd() {
+    const fn test_mm_mask3_fmaddsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2388,7 +2388,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fmsubadd_pd() {
+    const fn test_mm512_fmsubadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2398,7 +2398,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fmsubadd_pd() {
+    const fn test_mm512_mask_fmsubadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2410,7 +2410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fmsubadd_pd() {
+    const fn test_mm512_maskz_fmsubadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2422,7 +2422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fmsubadd_pd() {
+    const fn test_mm512_mask3_fmsubadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2434,7 +2434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fmsubadd_pd() {
+    const fn test_mm256_mask_fmsubadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2446,7 +2446,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fmsubadd_pd() {
+    const fn test_mm256_maskz_fmsubadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2458,7 +2458,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fmsubadd_pd() {
+    const fn test_mm256_mask3_fmsubadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2470,7 +2470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fmsubadd_pd() {
+    const fn test_mm_mask_fmsubadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2482,7 +2482,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fmsubadd_pd() {
+    const fn test_mm_maskz_fmsubadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2494,7 +2494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fmsubadd_pd() {
+    const fn test_mm_mask3_fmsubadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2506,7 +2506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fnmadd_pd() {
+    const fn test_mm512_fnmadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2516,7 +2516,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fnmadd_pd() {
+    const fn test_mm512_mask_fnmadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2528,7 +2528,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fnmadd_pd() {
+    const fn test_mm512_maskz_fnmadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2540,7 +2540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fnmadd_pd() {
+    const fn test_mm512_mask3_fnmadd_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2552,7 +2552,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmadd_pd() {
+    const fn test_mm256_mask_fnmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2564,7 +2564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmadd_pd() {
+    const fn test_mm256_maskz_fnmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2576,7 +2576,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmadd_pd() {
+    const fn test_mm256_mask3_fnmadd_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2588,7 +2588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fnmadd_pd() {
+    const fn test_mm_mask_fnmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2600,7 +2600,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmadd_pd() {
+    const fn test_mm_maskz_fnmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2612,7 +2612,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmadd_pd() {
+    const fn test_mm_mask3_fnmadd_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2624,7 +2624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_fnmsub_pd() {
+    const fn test_mm512_fnmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2634,7 +2634,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_fnmsub_pd() {
+    const fn test_mm512_mask_fnmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2646,7 +2646,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_fnmsub_pd() {
+    const fn test_mm512_maskz_fnmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_set1_pd(1.);
@@ -2658,7 +2658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask3_fnmsub_pd() {
+    const fn test_mm512_mask3_fnmsub_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let c = _mm512_setr_pd(1., 1., 1., 1., 2., 2., 2., 2.);
@@ -2670,7 +2670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_fnmsub_pd() {
+    const fn test_mm256_mask_fnmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2682,7 +2682,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_fnmsub_pd() {
+    const fn test_mm256_maskz_fnmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2694,7 +2694,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask3_fnmsub_pd() {
+    const fn test_mm256_mask3_fnmsub_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set_pd(0., 1., 2., 3.);
         let c = _mm256_set1_pd(1.);
@@ -2706,7 +2706,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_fnmsub_pd() {
+    const fn test_mm_mask_fnmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2718,7 +2718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_fnmsub_pd() {
+    const fn test_mm_maskz_fnmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2730,7 +2730,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask3_fnmsub_pd() {
+    const fn test_mm_mask3_fnmsub_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set_pd(0., 1.);
         let c = _mm_set1_pd(1.);
@@ -2742,7 +2742,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_rcp14_pd() {
+    fn test_mm512_rcp14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_rcp14_pd(a);
         let e = _mm512_set1_pd(0.3333320617675781);
@@ -2750,7 +2750,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_rcp14_pd() {
+    fn test_mm512_mask_rcp14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_mask_rcp14_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -2764,7 +2764,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_rcp14_pd() {
+    fn test_mm512_maskz_rcp14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_maskz_rcp14_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -2778,7 +2778,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_rcp14_pd() {
+    fn test_mm256_rcp14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_rcp14_pd(a);
         let e = _mm256_set1_pd(0.3333320617675781);
@@ -2786,7 +2786,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_rcp14_pd() {
+    fn test_mm256_mask_rcp14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_mask_rcp14_pd(a, 0, a);
         assert_eq_m256d(r, a);
@@ -2796,7 +2796,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_rcp14_pd() {
+    fn test_mm256_maskz_rcp14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_maskz_rcp14_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -2806,7 +2806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_rcp14_pd() {
+    fn test_mm_rcp14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_rcp14_pd(a);
         let e = _mm_set1_pd(0.3333320617675781);
@@ -2814,7 +2814,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_rcp14_pd() {
+    fn test_mm_mask_rcp14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_mask_rcp14_pd(a, 0, a);
         assert_eq_m128d(r, a);
@@ -2824,7 +2824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_rcp14_pd() {
+    fn test_mm_maskz_rcp14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_maskz_rcp14_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -2834,7 +2834,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_rsqrt14_pd() {
+    fn test_mm512_rsqrt14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_rsqrt14_pd(a);
         let e = _mm512_set1_pd(0.5773391723632813);
@@ -2842,7 +2842,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_rsqrt14_pd() {
+    fn test_mm512_mask_rsqrt14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_mask_rsqrt14_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -2856,7 +2856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_rsqrt14_pd() {
+    fn test_mm512_maskz_rsqrt14_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_maskz_rsqrt14_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -2870,7 +2870,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_rsqrt14_pd() {
+    fn test_mm256_rsqrt14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_rsqrt14_pd(a);
         let e = _mm256_set1_pd(0.5773391723632813);
@@ -2878,7 +2878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_rsqrt14_pd() {
+    fn test_mm256_mask_rsqrt14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_mask_rsqrt14_pd(a, 0, a);
         assert_eq_m256d(r, a);
@@ -2888,7 +2888,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_rsqrt14_pd() {
+    fn test_mm256_maskz_rsqrt14_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_maskz_rsqrt14_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -2898,7 +2898,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_rsqrt14_pd() {
+    fn test_mm_rsqrt14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_rsqrt14_pd(a);
         let e = _mm_set1_pd(0.5773391723632813);
@@ -2906,7 +2906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_rsqrt14_pd() {
+    fn test_mm_mask_rsqrt14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_mask_rsqrt14_pd(a, 0, a);
         assert_eq_m128d(r, a);
@@ -2916,7 +2916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_rsqrt14_pd() {
+    fn test_mm_maskz_rsqrt14_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_maskz_rsqrt14_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -2926,7 +2926,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getexp_pd() {
+    fn test_mm512_getexp_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_getexp_pd(a);
         let e = _mm512_set1_pd(1.);
@@ -2934,7 +2934,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getexp_pd() {
+    fn test_mm512_mask_getexp_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_mask_getexp_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -2944,7 +2944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getexp_pd() {
+    fn test_mm512_maskz_getexp_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_maskz_getexp_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -2954,7 +2954,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_getexp_pd() {
+    fn test_mm256_getexp_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_getexp_pd(a);
         let e = _mm256_set1_pd(1.);
@@ -2962,7 +2962,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_getexp_pd() {
+    fn test_mm256_mask_getexp_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_mask_getexp_pd(a, 0, a);
         assert_eq_m256d(r, a);
@@ -2972,7 +2972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_getexp_pd() {
+    fn test_mm256_maskz_getexp_pd() {
         let a = _mm256_set1_pd(3.);
         let r = _mm256_maskz_getexp_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -2982,7 +2982,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_getexp_pd() {
+    fn test_mm_getexp_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_getexp_pd(a);
         let e = _mm_set1_pd(1.);
@@ -2990,7 +2990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_getexp_pd() {
+    fn test_mm_mask_getexp_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_mask_getexp_pd(a, 0, a);
         assert_eq_m128d(r, a);
@@ -3000,7 +3000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_getexp_pd() {
+    fn test_mm_maskz_getexp_pd() {
         let a = _mm_set1_pd(3.);
         let r = _mm_maskz_getexp_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -3010,7 +3010,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_roundscale_pd() {
+    fn test_mm512_roundscale_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_roundscale_pd::<0b00_00_00_00>(a);
         let e = _mm512_set1_pd(1.0);
@@ -3018,7 +3018,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_roundscale_pd() {
+    fn test_mm512_mask_roundscale_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_mask_roundscale_pd::<0b00_00_00_00>(a, 0, a);
         let e = _mm512_set1_pd(1.1);
@@ -3029,7 +3029,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_roundscale_pd() {
+    fn test_mm512_maskz_roundscale_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_maskz_roundscale_pd::<0b00_00_00_00>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -3039,7 +3039,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_roundscale_pd() {
+    fn test_mm256_roundscale_pd() {
         let a = _mm256_set1_pd(1.1);
         let r = _mm256_roundscale_pd::<0b00_00_00_00>(a);
         let e = _mm256_set1_pd(1.0);
@@ -3047,7 +3047,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_roundscale_pd() {
+    fn test_mm256_mask_roundscale_pd() {
         let a = _mm256_set1_pd(1.1);
         let r = _mm256_mask_roundscale_pd::<0b00_00_00_00>(a, 0, a);
         assert_eq_m256d(r, a);
@@ -3057,7 +3057,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_roundscale_pd() {
+    fn test_mm256_maskz_roundscale_pd() {
         let a = _mm256_set1_pd(1.1);
         let r = _mm256_maskz_roundscale_pd::<0b00_00_00_00>(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -3067,7 +3067,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_roundscale_pd() {
+    fn test_mm_roundscale_pd() {
         let a = _mm_set1_pd(1.1);
         let r = _mm_roundscale_pd::<0b00_00_00_00>(a);
         let e = _mm_set1_pd(1.0);
@@ -3075,7 +3075,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_roundscale_pd() {
+    fn test_mm_mask_roundscale_pd() {
         let a = _mm_set1_pd(1.1);
         let r = _mm_mask_roundscale_pd::<0b00_00_00_00>(a, 0, a);
         let e = _mm_set1_pd(1.1);
@@ -3086,7 +3086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_roundscale_pd() {
+    fn test_mm_maskz_roundscale_pd() {
         let a = _mm_set1_pd(1.1);
         let r = _mm_maskz_roundscale_pd::<0b00_00_00_00>(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -3096,7 +3096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_scalef_pd() {
+    fn test_mm512_scalef_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_scalef_pd(a, b);
@@ -3105,7 +3105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_scalef_pd() {
+    fn test_mm512_mask_scalef_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_mask_scalef_pd(a, 0, a, b);
@@ -3116,7 +3116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_scalef_pd() {
+    fn test_mm512_maskz_scalef_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_maskz_scalef_pd(0, a, b);
@@ -3127,7 +3127,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_scalef_pd() {
+    fn test_mm256_scalef_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(3.);
         let r = _mm256_scalef_pd(a, b);
@@ -3136,7 +3136,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_scalef_pd() {
+    fn test_mm256_mask_scalef_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(3.);
         let r = _mm256_mask_scalef_pd(a, 0, a, b);
@@ -3147,7 +3147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_scalef_pd() {
+    fn test_mm256_maskz_scalef_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(3.);
         let r = _mm256_maskz_scalef_pd(0, a, b);
@@ -3158,7 +3158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_scalef_pd() {
+    fn test_mm_scalef_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_scalef_pd(a, b);
@@ -3167,7 +3167,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_scalef_pd() {
+    fn test_mm_mask_scalef_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_mask_scalef_pd(a, 0, a, b);
@@ -3178,7 +3178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_scalef_pd() {
+    fn test_mm_maskz_scalef_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(3.);
         let r = _mm_maskz_scalef_pd(0, a, b);
@@ -3189,7 +3189,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fixupimm_pd() {
+    fn test_mm512_fixupimm_pd() {
         let a = _mm512_set1_pd(f64::NAN);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -3199,7 +3199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fixupimm_pd() {
+    fn test_mm512_mask_fixupimm_pd() {
         let a = _mm512_set_pd(f64::NAN, f64::NAN, f64::NAN, f64::NAN, 1., 1., 1., 1.);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -3209,7 +3209,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fixupimm_pd() {
+    fn test_mm512_maskz_fixupimm_pd() {
         let a = _mm512_set_pd(f64::NAN, f64::NAN, f64::NAN, f64::NAN, 1., 1., 1., 1.);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -3219,7 +3219,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_fixupimm_pd() {
+    fn test_mm256_fixupimm_pd() {
         let a = _mm256_set1_pd(f64::NAN);
         let b = _mm256_set1_pd(f64::MAX);
         let c = _mm256_set1_epi64x(i32::MAX as i64);
@@ -3229,7 +3229,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_fixupimm_pd() {
+    fn test_mm256_mask_fixupimm_pd() {
         let a = _mm256_set1_pd(f64::NAN);
         let b = _mm256_set1_pd(f64::MAX);
         let c = _mm256_set1_epi64x(i32::MAX as i64);
@@ -3239,7 +3239,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_fixupimm_pd() {
+    fn test_mm256_maskz_fixupimm_pd() {
         let a = _mm256_set1_pd(f64::NAN);
         let b = _mm256_set1_pd(f64::MAX);
         let c = _mm256_set1_epi64x(i32::MAX as i64);
@@ -3249,7 +3249,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_fixupimm_pd() {
+    fn test_mm_fixupimm_pd() {
         let a = _mm_set1_pd(f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -3259,7 +3259,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_fixupimm_pd() {
+    fn test_mm_mask_fixupimm_pd() {
         let a = _mm_set1_pd(f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -3269,7 +3269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_fixupimm_pd() {
+    fn test_mm_maskz_fixupimm_pd() {
         let a = _mm_set1_pd(f64::NAN);
         let b = _mm_set1_pd(f64::MAX);
         let c = _mm_set1_epi64x(i32::MAX as i64);
@@ -3279,7 +3279,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_ternarylogic_epi64() {
+    fn test_mm512_ternarylogic_epi64() {
         let a = _mm512_set1_epi64(1 << 2);
         let b = _mm512_set1_epi64(1 << 1);
         let c = _mm512_set1_epi64(1 << 0);
@@ -3289,7 +3289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_ternarylogic_epi64() {
+    fn test_mm512_mask_ternarylogic_epi64() {
         let src = _mm512_set1_epi64(1 << 2);
         let a = _mm512_set1_epi64(1 << 1);
         let b = _mm512_set1_epi64(1 << 0);
@@ -3301,7 +3301,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_ternarylogic_epi64() {
+    fn test_mm512_maskz_ternarylogic_epi64() {
         let a = _mm512_set1_epi64(1 << 2);
         let b = _mm512_set1_epi64(1 << 1);
         let c = _mm512_set1_epi64(1 << 0);
@@ -3313,7 +3313,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_ternarylogic_epi64() {
+    fn test_mm256_ternarylogic_epi64() {
         let a = _mm256_set1_epi64x(1 << 2);
         let b = _mm256_set1_epi64x(1 << 1);
         let c = _mm256_set1_epi64x(1 << 0);
@@ -3323,7 +3323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_ternarylogic_epi64() {
+    fn test_mm256_mask_ternarylogic_epi64() {
         let src = _mm256_set1_epi64x(1 << 2);
         let a = _mm256_set1_epi64x(1 << 1);
         let b = _mm256_set1_epi64x(1 << 0);
@@ -3335,7 +3335,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_ternarylogic_epi64() {
+    fn test_mm256_maskz_ternarylogic_epi64() {
         let a = _mm256_set1_epi64x(1 << 2);
         let b = _mm256_set1_epi64x(1 << 1);
         let c = _mm256_set1_epi64x(1 << 0);
@@ -3347,7 +3347,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_ternarylogic_epi64() {
+    fn test_mm_ternarylogic_epi64() {
         let a = _mm_set1_epi64x(1 << 2);
         let b = _mm_set1_epi64x(1 << 1);
         let c = _mm_set1_epi64x(1 << 0);
@@ -3357,7 +3357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_ternarylogic_epi64() {
+    fn test_mm_mask_ternarylogic_epi64() {
         let src = _mm_set1_epi64x(1 << 2);
         let a = _mm_set1_epi64x(1 << 1);
         let b = _mm_set1_epi64x(1 << 0);
@@ -3369,7 +3369,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_ternarylogic_epi64() {
+    fn test_mm_maskz_ternarylogic_epi64() {
         let a = _mm_set1_epi64x(1 << 2);
         let b = _mm_set1_epi64x(1 << 1);
         let c = _mm_set1_epi64x(1 << 0);
@@ -3381,7 +3381,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getmant_pd() {
+    fn test_mm512_getmant_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a);
         let e = _mm512_set1_pd(1.25);
@@ -3389,7 +3389,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getmant_pd() {
+    fn test_mm512_mask_getmant_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_mask_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m512d(r, a);
@@ -3399,7 +3399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getmant_pd() {
+    fn test_mm512_maskz_getmant_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_maskz_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -3409,7 +3409,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_getmant_pd() {
+    fn test_mm256_getmant_pd() {
         let a = _mm256_set1_pd(10.);
         let r = _mm256_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a);
         let e = _mm256_set1_pd(1.25);
@@ -3417,7 +3417,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_getmant_pd() {
+    fn test_mm256_mask_getmant_pd() {
         let a = _mm256_set1_pd(10.);
         let r = _mm256_mask_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m256d(r, a);
@@ -3427,7 +3427,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_getmant_pd() {
+    fn test_mm256_maskz_getmant_pd() {
         let a = _mm256_set1_pd(10.);
         let r = _mm256_maskz_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -3437,7 +3437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_getmant_pd() {
+    fn test_mm_getmant_pd() {
         let a = _mm_set1_pd(10.);
         let r = _mm_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a);
         let e = _mm_set1_pd(1.25);
@@ -3445,7 +3445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_getmant_pd() {
+    fn test_mm_mask_getmant_pd() {
         let a = _mm_set1_pd(10.);
         let r = _mm_mask_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(a, 0, a);
         assert_eq_m128d(r, a);
@@ -3455,7 +3455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_getmant_pd() {
+    fn test_mm_maskz_getmant_pd() {
         let a = _mm_set1_pd(10.);
         let r = _mm_maskz_getmant_pd::<_MM_MANT_NORM_1_2, _MM_MANT_SIGN_SRC>(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -3465,7 +3465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtps_pd() {
+    fn test_mm512_cvtps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtps_pd(a);
         let e = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
@@ -3473,7 +3473,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtps_pd() {
+    fn test_mm512_mask_cvtps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm512_set1_pd(0.);
         let r = _mm512_mask_cvtps_pd(src, 0, a);
@@ -3484,7 +3484,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtps_pd() {
+    fn test_mm512_maskz_cvtps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvtps_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -3494,7 +3494,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtpslo_pd() {
+    fn test_mm512_cvtpslo_pd() {
         let v2 = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 100., 100., 100., 100., 100., 100., 100., 100.,
         );
@@ -3504,7 +3504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtpslo_pd() {
+    fn test_mm512_mask_cvtpslo_pd() {
         let v2 = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 100., 100., 100., 100., 100., 100., 100., 100.,
         );
@@ -3517,7 +3517,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtpd_ps() {
+    fn test_mm512_cvtpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtpd_ps(a);
         let e = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
@@ -3525,7 +3525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtpd_ps() {
+    fn test_mm512_mask_cvtpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_ps(0.);
         let r = _mm512_mask_cvtpd_ps(src, 0, a);
@@ -3536,7 +3536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtpd_ps() {
+    fn test_mm512_maskz_cvtpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvtpd_ps(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -3546,7 +3546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_ps() {
+    fn test_mm256_mask_cvtpd_ps() {
         let a = _mm256_set_pd(4., -5.5, 6., -7.5);
         let src = _mm_set1_ps(0.);
         let r = _mm256_mask_cvtpd_ps(src, 0, a);
@@ -3557,7 +3557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_ps() {
+    fn test_mm256_maskz_cvtpd_ps() {
         let a = _mm256_set_pd(4., -5.5, 6., -7.5);
         let r = _mm256_maskz_cvtpd_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -3567,7 +3567,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_ps() {
+    fn test_mm_mask_cvtpd_ps() {
         let a = _mm_set_pd(6., -7.5);
         let src = _mm_set1_ps(0.);
         let r = _mm_mask_cvtpd_ps(src, 0, a);
@@ -3578,7 +3578,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_ps() {
+    fn test_mm_maskz_cvtpd_ps() {
         let a = _mm_set_pd(6., -7.5);
         let r = _mm_maskz_cvtpd_ps(0, a);
         assert_eq_m128(r, _mm_setzero_ps());
@@ -3588,7 +3588,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtpd_epi32() {
+    fn test_mm512_cvtpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtpd_epi32(a);
         let e = _mm256_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8);
@@ -3596,7 +3596,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtpd_epi32() {
+    fn test_mm512_mask_cvtpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvtpd_epi32(src, 0, a);
@@ -3607,7 +3607,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtpd_epi32() {
+    fn test_mm512_maskz_cvtpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvtpd_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -3617,7 +3617,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_epi32() {
+    fn test_mm256_mask_cvtpd_epi32() {
         let a = _mm256_set_pd(4., -5.5, 6., -7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvtpd_epi32(src, 0, a);
@@ -3628,7 +3628,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_epi32() {
+    fn test_mm256_maskz_cvtpd_epi32() {
         let a = _mm256_set_pd(4., -5.5, 6., -7.5);
         let r = _mm256_maskz_cvtpd_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3638,7 +3638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_epi32() {
+    fn test_mm_mask_cvtpd_epi32() {
         let a = _mm_set_pd(6., -7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtpd_epi32(src, 0, a);
@@ -3649,7 +3649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_epi32() {
+    fn test_mm_maskz_cvtpd_epi32() {
         let a = _mm_set_pd(6., -7.5);
         let r = _mm_maskz_cvtpd_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3659,7 +3659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtpd_epu32() {
+    fn test_mm512_cvtpd_epu32() {
         let a = _mm512_setr_pd(0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5);
         let r = _mm512_cvtpd_epu32(a);
         let e = _mm256_setr_epi32(0, 2, 2, 4, 4, 6, 6, 8);
@@ -3667,7 +3667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtpd_epu32() {
+    fn test_mm512_mask_cvtpd_epu32() {
         let a = _mm512_setr_pd(0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvtpd_epu32(src, 0, a);
@@ -3678,7 +3678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtpd_epu32() {
+    fn test_mm512_maskz_cvtpd_epu32() {
         let a = _mm512_setr_pd(0., 1.5, 2., 3.5, 4., 5.5, 6., 7.5);
         let r = _mm512_maskz_cvtpd_epu32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -3688,7 +3688,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtpd_epu32() {
+    fn test_mm256_cvtpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let r = _mm256_cvtpd_epu32(a);
         let e = _mm_set_epi32(4, 6, 6, 8);
@@ -3696,7 +3696,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtpd_epu32() {
+    fn test_mm256_mask_cvtpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvtpd_epu32(src, 0, a);
@@ -3707,7 +3707,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtpd_epu32() {
+    fn test_mm256_maskz_cvtpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let r = _mm256_maskz_cvtpd_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3717,7 +3717,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtpd_epu32() {
+    fn test_mm_cvtpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let r = _mm_cvtpd_epu32(a);
         let e = _mm_set_epi32(0, 0, 6, 8);
@@ -3725,7 +3725,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtpd_epu32() {
+    fn test_mm_mask_cvtpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtpd_epu32(src, 0, a);
@@ -3736,7 +3736,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtpd_epu32() {
+    fn test_mm_maskz_cvtpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let r = _mm_maskz_cvtpd_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3746,7 +3746,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtpd_pslo() {
+    fn test_mm512_cvtpd_pslo() {
         let v2 = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtpd_pslo(v2);
         let e = _mm512_setr_ps(
@@ -3756,7 +3756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtpd_pslo() {
+    fn test_mm512_mask_cvtpd_pslo() {
         let v2 = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm512_set1_ps(0.);
         let r = _mm512_mask_cvtpd_pslo(src, 0, v2);
@@ -3769,7 +3769,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi8_epi64() {
+    const fn test_mm512_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi8_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -3777,7 +3777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi8_epi64() {
+    const fn test_mm512_mask_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepi8_epi64(src, 0, a);
@@ -3788,7 +3788,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi8_epi64() {
+    const fn test_mm512_maskz_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi8_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -3798,7 +3798,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi8_epi64() {
+    const fn test_mm256_mask_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepi8_epi64(src, 0, a);
@@ -3809,7 +3809,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi8_epi64() {
+    const fn test_mm256_maskz_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi8_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -3819,7 +3819,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi8_epi64() {
+    const fn test_mm_mask_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi64x(-1);
         let r = _mm_mask_cvtepi8_epi64(src, 0, a);
@@ -3830,7 +3830,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi8_epi64() {
+    const fn test_mm_maskz_cvtepi8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepi8_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3840,7 +3840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu8_epi64() {
+    const fn test_mm512_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu8_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -3848,7 +3848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu8_epi64() {
+    const fn test_mm512_mask_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepu8_epi64(src, 0, a);
@@ -3859,7 +3859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu8_epi64() {
+    const fn test_mm512_maskz_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu8_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -3869,7 +3869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu8_epi64() {
+    const fn test_mm256_mask_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepu8_epi64(src, 0, a);
@@ -3880,7 +3880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu8_epi64() {
+    const fn test_mm256_maskz_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu8_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -3890,7 +3890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu8_epi64() {
+    const fn test_mm_mask_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi64x(-1);
         let r = _mm_mask_cvtepu8_epi64(src, 0, a);
@@ -3901,7 +3901,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu8_epi64() {
+    const fn test_mm_maskz_cvtepu8_epi64() {
         let a = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepu8_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3911,7 +3911,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi16_epi64() {
+    const fn test_mm512_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi16_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -3919,7 +3919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi16_epi64() {
+    const fn test_mm512_mask_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepi16_epi64(src, 0, a);
@@ -3930,7 +3930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi16_epi64() {
+    const fn test_mm512_maskz_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi16_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -3940,7 +3940,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi16_epi64() {
+    const fn test_mm256_mask_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepi16_epi64(src, 0, a);
@@ -3951,7 +3951,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi16_epi64() {
+    const fn test_mm256_maskz_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi16_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -3961,7 +3961,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi16_epi64() {
+    const fn test_mm_mask_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi64x(-1);
         let r = _mm_mask_cvtepi16_epi64(src, 0, a);
@@ -3972,7 +3972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi16_epi64() {
+    const fn test_mm_maskz_cvtepi16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepi16_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -3982,7 +3982,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu16_epi64() {
+    const fn test_mm512_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu16_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -3990,7 +3990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu16_epi64() {
+    const fn test_mm512_mask_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepu16_epi64(src, 0, a);
@@ -4001,7 +4001,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu16_epi64() {
+    const fn test_mm512_maskz_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu16_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -4011,7 +4011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu16_epi64() {
+    const fn test_mm256_mask_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepu16_epi64(src, 0, a);
@@ -4022,7 +4022,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu16_epi64() {
+    const fn test_mm256_maskz_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu16_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4032,7 +4032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu16_epi64() {
+    const fn test_mm_mask_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi64x(-1);
         let r = _mm_mask_cvtepu16_epi64(src, 0, a);
@@ -4043,7 +4043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu16_epi64() {
+    const fn test_mm_maskz_cvtepu16_epi64() {
         let a = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm_maskz_cvtepu16_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4053,7 +4053,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32_epi64() {
+    const fn test_mm512_cvtepi32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -4061,7 +4061,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32_epi64() {
+    const fn test_mm512_mask_cvtepi32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepi32_epi64(src, 0, a);
@@ -4072,7 +4072,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi32_epi64() {
+    const fn test_mm512_maskz_cvtepi32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi32_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -4082,7 +4082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi32_epi64() {
+    const fn test_mm256_mask_cvtepi32_epi64() {
         let a = _mm_set_epi32(8, 9, 10, 11);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepi32_epi64(src, 0, a);
@@ -4093,7 +4093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi32_epi64() {
+    const fn test_mm256_maskz_cvtepi32_epi64() {
         let a = _mm_set_epi32(8, 9, 10, 11);
         let r = _mm256_maskz_cvtepi32_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4103,7 +4103,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi32_epi64() {
+    const fn test_mm_mask_cvtepi32_epi64() {
         let a = _mm_set_epi32(8, 9, 10, 11);
         let src = _mm_set1_epi64x(0);
         let r = _mm_mask_cvtepi32_epi64(src, 0, a);
@@ -4114,7 +4114,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi32_epi64() {
+    const fn test_mm_maskz_cvtepi32_epi64() {
         let a = _mm_set_epi32(8, 9, 10, 11);
         let r = _mm_maskz_cvtepi32_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4124,7 +4124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu32_epi64() {
+    const fn test_mm512_cvtepu32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu32_epi64(a);
         let e = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
@@ -4132,7 +4132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu32_epi64() {
+    const fn test_mm512_mask_cvtepu32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_epi64(-1);
         let r = _mm512_mask_cvtepu32_epi64(src, 0, a);
@@ -4143,7 +4143,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu32_epi64() {
+    const fn test_mm512_maskz_cvtepu32_epi64() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu32_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -4153,7 +4153,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu32_epi64() {
+    const fn test_mm256_mask_cvtepu32_epi64() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm256_set1_epi64x(-1);
         let r = _mm256_mask_cvtepu32_epi64(src, 0, a);
@@ -4164,7 +4164,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu32_epi64() {
+    const fn test_mm256_maskz_cvtepu32_epi64() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu32_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4174,7 +4174,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu32_epi64() {
+    const fn test_mm_mask_cvtepu32_epi64() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm_set1_epi64x(-1);
         let r = _mm_mask_cvtepu32_epi64(src, 0, a);
@@ -4185,7 +4185,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu32_epi64() {
+    const fn test_mm_maskz_cvtepu32_epi64() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm_maskz_cvtepu32_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4195,7 +4195,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32_pd() {
+    const fn test_mm512_cvtepi32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32_pd(a);
         let e = _mm512_set_pd(8., 9., 10., 11., 12., 13., 14., 15.);
@@ -4203,7 +4203,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32_pd() {
+    const fn test_mm512_mask_cvtepi32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_pd(-1.);
         let r = _mm512_mask_cvtepi32_pd(src, 0, a);
@@ -4214,7 +4214,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi32_pd() {
+    const fn test_mm512_maskz_cvtepi32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi32_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -4224,7 +4224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi32_pd() {
+    const fn test_mm256_mask_cvtepi32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm256_set1_pd(-1.);
         let r = _mm256_mask_cvtepi32_pd(src, 0, a);
@@ -4235,7 +4235,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi32_pd() {
+    const fn test_mm256_maskz_cvtepi32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi32_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -4245,7 +4245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepi32_pd() {
+    const fn test_mm_mask_cvtepi32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm_set1_pd(-1.);
         let r = _mm_mask_cvtepi32_pd(src, 0, a);
@@ -4256,7 +4256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepi32_pd() {
+    const fn test_mm_maskz_cvtepi32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm_maskz_cvtepi32_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -4266,7 +4266,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu32_pd() {
+    const fn test_mm512_cvtepu32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu32_pd(a);
         let e = _mm512_set_pd(8., 9., 10., 11., 12., 13., 14., 15.);
@@ -4274,7 +4274,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu32_pd() {
+    const fn test_mm512_mask_cvtepu32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_pd(-1.);
         let r = _mm512_mask_cvtepu32_pd(src, 0, a);
@@ -4285,7 +4285,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepu32_pd() {
+    const fn test_mm512_maskz_cvtepu32_pd() {
         let a = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepu32_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -4295,7 +4295,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cvtepu32_pd() {
+    const fn test_mm256_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm256_cvtepu32_pd(a);
         let e = _mm256_set_pd(12., 13., 14., 15.);
@@ -4303,7 +4303,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepu32_pd() {
+    const fn test_mm256_mask_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm256_set1_pd(-1.);
         let r = _mm256_mask_cvtepu32_pd(src, 0, a);
@@ -4314,7 +4314,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepu32_pd() {
+    const fn test_mm256_maskz_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm256_maskz_cvtepu32_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -4324,7 +4324,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cvtepu32_pd() {
+    const fn test_mm_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm_cvtepu32_pd(a);
         let e = _mm_set_pd(14., 15.);
@@ -4332,7 +4332,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cvtepu32_pd() {
+    const fn test_mm_mask_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let src = _mm_set1_pd(-1.);
         let r = _mm_mask_cvtepu32_pd(src, 0, a);
@@ -4343,7 +4343,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_cvtepu32_pd() {
+    const fn test_mm_maskz_cvtepu32_pd() {
         let a = _mm_set_epi32(12, 13, 14, 15);
         let r = _mm_maskz_cvtepu32_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -4353,7 +4353,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi32lo_pd() {
+    const fn test_mm512_cvtepi32lo_pd() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi32lo_pd(a);
         let e = _mm512_set_pd(8., 9., 10., 11., 12., 13., 14., 15.);
@@ -4361,7 +4361,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi32lo_pd() {
+    const fn test_mm512_mask_cvtepi32lo_pd() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_pd(-1.);
         let r = _mm512_mask_cvtepi32lo_pd(src, 0, a);
@@ -4372,7 +4372,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepu32lo_pd() {
+    const fn test_mm512_cvtepu32lo_pd() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepu32lo_pd(a);
         let e = _mm512_set_pd(8., 9., 10., 11., 12., 13., 14., 15.);
@@ -4380,7 +4380,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepu32lo_pd() {
+    const fn test_mm512_mask_cvtepu32lo_pd() {
         let a = _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm512_set1_pd(-1.);
         let r = _mm512_mask_cvtepu32lo_pd(src, 0, a);
@@ -4391,7 +4391,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi64_epi32() {
+    const fn test_mm512_cvtepi64_epi32() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi64_epi32(a);
         let e = _mm256_set_epi32(8, 9, 10, 11, 12, 13, 14, 15);
@@ -4399,7 +4399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi64_epi32() {
+    const fn test_mm512_mask_cvtepi64_epi32() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm256_set1_epi32(-1);
         let r = _mm512_mask_cvtepi64_epi32(src, 0, a);
@@ -4410,7 +4410,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi64_epi32() {
+    const fn test_mm512_maskz_cvtepi64_epi32() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi64_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4420,7 +4420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cvtepi64_epi32() {
+    const fn test_mm256_cvtepi64_epi32() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_cvtepi64_epi32(a);
         let e = _mm_set_epi32(1, 2, 3, 4);
@@ -4428,7 +4428,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cvtepi64_epi32() {
+    const fn test_mm256_mask_cvtepi64_epi32() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvtepi64_epi32(src, 0, a);
@@ -4439,7 +4439,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_cvtepi64_epi32() {
+    const fn test_mm256_maskz_cvtepi64_epi32() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let r = _mm256_maskz_cvtepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4449,7 +4449,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtepi64_epi32() {
+    fn test_mm_cvtepi64_epi32() {
         let a = _mm_set_epi64x(3, 4);
         let r = _mm_cvtepi64_epi32(a);
         let e = _mm_set_epi32(0, 0, 3, 4);
@@ -4457,7 +4457,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_epi32() {
+    fn test_mm_mask_cvtepi64_epi32() {
         let a = _mm_set_epi64x(3, 4);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtepi64_epi32(src, 0, a);
@@ -4468,7 +4468,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_epi32() {
+    fn test_mm_maskz_cvtepi64_epi32() {
         let a = _mm_set_epi64x(3, 4);
         let r = _mm_maskz_cvtepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4478,7 +4478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cvtepi64_epi16() {
+    const fn test_mm512_cvtepi64_epi16() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi64_epi16(a);
         let e = _mm_set_epi16(8, 9, 10, 11, 12, 13, 14, 15);
@@ -4486,7 +4486,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cvtepi64_epi16() {
+    const fn test_mm512_mask_cvtepi64_epi16() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set1_epi16(-1);
         let r = _mm512_mask_cvtepi64_epi16(src, 0, a);
@@ -4497,7 +4497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_cvtepi64_epi16() {
+    const fn test_mm512_maskz_cvtepi64_epi16() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4507,7 +4507,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtepi64_epi16() {
+    fn test_mm256_cvtepi64_epi16() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let r = _mm256_cvtepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 12, 13, 14, 15);
@@ -4515,7 +4515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi64_epi16() {
+    fn test_mm256_mask_cvtepi64_epi16() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvtepi64_epi16(src, 0, a);
@@ -4526,7 +4526,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi64_epi16() {
+    fn test_mm256_maskz_cvtepi64_epi16() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4536,7 +4536,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtepi64_epi16() {
+    fn test_mm_cvtepi64_epi16() {
         let a = _mm_set_epi64x(14, 15);
         let r = _mm_cvtepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 0, 0, 14, 15);
@@ -4544,7 +4544,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_epi16() {
+    fn test_mm_mask_cvtepi64_epi16() {
         let a = _mm_set_epi64x(14, 15);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtepi64_epi16(src, 0, a);
@@ -4555,7 +4555,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_epi16() {
+    fn test_mm_maskz_cvtepi64_epi16() {
         let a = _mm_set_epi64x(14, 15);
         let r = _mm_maskz_cvtepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4565,7 +4565,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtepi64_epi8() {
+    fn test_mm512_cvtepi64_epi8() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_cvtepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, 15);
@@ -4573,7 +4573,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtepi64_epi8() {
+    fn test_mm512_mask_cvtepi64_epi8() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
         let r = _mm512_mask_cvtepi64_epi8(src, 0, a);
@@ -4584,7 +4584,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtepi64_epi8() {
+    fn test_mm512_maskz_cvtepi64_epi8() {
         let a = _mm512_set_epi64(8, 9, 10, 11, 12, 13, 14, 15);
         let r = _mm512_maskz_cvtepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4594,7 +4594,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtepi64_epi8() {
+    fn test_mm256_cvtepi64_epi8() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let r = _mm256_cvtepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, 15);
@@ -4602,7 +4602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtepi64_epi8() {
+    fn test_mm256_mask_cvtepi64_epi8() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtepi64_epi8(src, 0, a);
@@ -4613,7 +4613,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtepi64_epi8() {
+    fn test_mm256_maskz_cvtepi64_epi8() {
         let a = _mm256_set_epi64x(12, 13, 14, 15);
         let r = _mm256_maskz_cvtepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4623,7 +4623,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtepi64_epi8() {
+    fn test_mm_cvtepi64_epi8() {
         let a = _mm_set_epi64x(14, 15);
         let r = _mm_cvtepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15);
@@ -4631,7 +4631,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtepi64_epi8() {
+    fn test_mm_mask_cvtepi64_epi8() {
         let a = _mm_set_epi64x(14, 15);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtepi64_epi8(src, 0, a);
@@ -4642,7 +4642,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtepi64_epi8() {
+    fn test_mm_maskz_cvtepi64_epi8() {
         let a = _mm_set_epi64x(14, 15);
         let r = _mm_maskz_cvtepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4652,7 +4652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtsepi64_epi32() {
+    fn test_mm512_cvtsepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_cvtsepi64_epi32(a);
         let e = _mm256_set_epi32(0, 1, 2, 3, 4, 5, i32::MIN, i32::MAX);
@@ -4660,7 +4660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtsepi64_epi32() {
+    fn test_mm512_mask_cvtsepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let src = _mm256_set1_epi32(-1);
         let r = _mm512_mask_cvtsepi64_epi32(src, 0, a);
@@ -4671,7 +4671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtsepi64_epi32() {
+    fn test_mm512_maskz_cvtsepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_maskz_cvtsepi64_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4681,7 +4681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtsepi64_epi32() {
+    fn test_mm256_cvtsepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_cvtsepi64_epi32(a);
         let e = _mm_set_epi32(4, 5, i32::MIN, i32::MAX);
@@ -4689,7 +4689,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi64_epi32() {
+    fn test_mm256_mask_cvtsepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let src = _mm_set1_epi32(-1);
         let r = _mm256_mask_cvtsepi64_epi32(src, 0, a);
@@ -4700,7 +4700,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi64_epi32() {
+    fn test_mm256_maskz_cvtsepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_maskz_cvtsepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4710,7 +4710,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtsepi64_epi32() {
+    fn test_mm_cvtsepi64_epi32() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_cvtsepi64_epi32(a);
         let e = _mm_set_epi32(0, 0, i32::MIN, i32::MAX);
@@ -4718,7 +4718,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi64_epi32() {
+    fn test_mm_mask_cvtsepi64_epi32() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtsepi64_epi32(src, 0, a);
@@ -4729,7 +4729,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi64_epi32() {
+    fn test_mm_maskz_cvtsepi64_epi32() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_maskz_cvtsepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4739,7 +4739,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtsepi64_epi16() {
+    fn test_mm512_cvtsepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_cvtsepi64_epi16(a);
         let e = _mm_set_epi16(0, 1, 2, 3, 4, 5, i16::MIN, i16::MAX);
@@ -4747,7 +4747,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtsepi64_epi16() {
+    fn test_mm512_mask_cvtsepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let src = _mm_set1_epi16(-1);
         let r = _mm512_mask_cvtsepi64_epi16(src, 0, a);
@@ -4758,7 +4758,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtsepi64_epi16() {
+    fn test_mm512_maskz_cvtsepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_maskz_cvtsepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4768,7 +4768,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtsepi64_epi16() {
+    fn test_mm256_cvtsepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_cvtsepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 4, 5, i16::MIN, i16::MAX);
@@ -4776,7 +4776,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi64_epi16() {
+    fn test_mm256_mask_cvtsepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvtsepi64_epi16(src, 0, a);
@@ -4787,7 +4787,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi64_epi16() {
+    fn test_mm256_maskz_cvtsepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_maskz_cvtsepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4797,7 +4797,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtsepi64_epi16() {
+    fn test_mm_cvtsepi64_epi16() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_cvtsepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 0, 0, i16::MIN, i16::MAX);
@@ -4805,7 +4805,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi64_epi16() {
+    fn test_mm_mask_cvtsepi64_epi16() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtsepi64_epi16(src, 0, a);
@@ -4816,7 +4816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi64_epi16() {
+    fn test_mm_maskz_cvtsepi64_epi16() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_maskz_cvtsepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4826,7 +4826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtsepi64_epi8() {
+    fn test_mm512_cvtsepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_cvtsepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, i8::MIN, i8::MAX);
@@ -4834,7 +4834,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtsepi64_epi8() {
+    fn test_mm512_mask_cvtsepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
         let r = _mm512_mask_cvtsepi64_epi8(src, 0, a);
@@ -4851,7 +4851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtsepi64_epi8() {
+    fn test_mm512_maskz_cvtsepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MAX);
         let r = _mm512_maskz_cvtsepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4861,7 +4861,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtsepi64_epi8() {
+    fn test_mm256_cvtsepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_cvtsepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, i8::MIN, i8::MAX);
@@ -4869,7 +4869,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtsepi64_epi8() {
+    fn test_mm256_mask_cvtsepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtsepi64_epi8(src, 0, a);
@@ -4880,7 +4880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtsepi64_epi8() {
+    fn test_mm256_maskz_cvtsepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, i64::MIN, i64::MAX);
         let r = _mm256_maskz_cvtsepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4890,7 +4890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtsepi64_epi8() {
+    fn test_mm_cvtsepi64_epi8() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_cvtsepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, i8::MIN, i8::MAX);
@@ -4898,7 +4898,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtsepi64_epi8() {
+    fn test_mm_mask_cvtsepi64_epi8() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtsepi64_epi8(src, 0, a);
@@ -4909,7 +4909,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtsepi64_epi8() {
+    fn test_mm_maskz_cvtsepi64_epi8() {
         let a = _mm_set_epi64x(i64::MIN, i64::MAX);
         let r = _mm_maskz_cvtsepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4919,7 +4919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtusepi64_epi32() {
+    fn test_mm512_cvtusepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_cvtusepi64_epi32(a);
         let e = _mm256_set_epi32(0, 1, 2, 3, 4, 5, -1, -1);
@@ -4927,7 +4927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtusepi64_epi32() {
+    fn test_mm512_mask_cvtusepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let src = _mm256_set1_epi32(-1);
         let r = _mm512_mask_cvtusepi64_epi32(src, 0, a);
@@ -4938,7 +4938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtusepi64_epi32() {
+    fn test_mm512_maskz_cvtusepi64_epi32() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_maskz_cvtusepi64_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -4948,7 +4948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtusepi64_epi32() {
+    fn test_mm256_cvtusepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_cvtusepi64_epi32(a);
         let e = _mm_set_epi32(4, 5, 6, u32::MAX as i32);
@@ -4956,7 +4956,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi64_epi32() {
+    fn test_mm256_mask_cvtusepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvtusepi64_epi32(src, 0, a);
@@ -4967,7 +4967,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi64_epi32() {
+    fn test_mm256_maskz_cvtusepi64_epi32() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_maskz_cvtusepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -4977,7 +4977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtusepi64_epi32() {
+    fn test_mm_cvtusepi64_epi32() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_cvtusepi64_epi32(a);
         let e = _mm_set_epi32(0, 0, 6, u32::MAX as i32);
@@ -4985,7 +4985,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi64_epi32() {
+    fn test_mm_mask_cvtusepi64_epi32() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvtusepi64_epi32(src, 0, a);
@@ -4996,7 +4996,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi64_epi32() {
+    fn test_mm_maskz_cvtusepi64_epi32() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_maskz_cvtusepi64_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5006,7 +5006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtusepi64_epi16() {
+    fn test_mm512_cvtusepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_cvtusepi64_epi16(a);
         let e = _mm_set_epi16(0, 1, 2, 3, 4, 5, -1, -1);
@@ -5014,7 +5014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtusepi64_epi16() {
+    fn test_mm512_mask_cvtusepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let src = _mm_set1_epi16(-1);
         let r = _mm512_mask_cvtusepi64_epi16(src, 0, a);
@@ -5025,7 +5025,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtusepi64_epi16() {
+    fn test_mm512_maskz_cvtusepi64_epi16() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_maskz_cvtusepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5035,7 +5035,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtusepi64_epi16() {
+    fn test_mm256_cvtusepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_cvtusepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 4, 5, 6, u16::MAX as i16);
@@ -5043,7 +5043,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi64_epi16() {
+    fn test_mm256_mask_cvtusepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let src = _mm_set1_epi16(0);
         let r = _mm256_mask_cvtusepi64_epi16(src, 0, a);
@@ -5054,7 +5054,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi64_epi16() {
+    fn test_mm256_maskz_cvtusepi64_epi16() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_maskz_cvtusepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5064,7 +5064,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtusepi64_epi16() {
+    fn test_mm_cvtusepi64_epi16() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_cvtusepi64_epi16(a);
         let e = _mm_set_epi16(0, 0, 0, 0, 0, 0, 6, u16::MAX as i16);
@@ -5072,7 +5072,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi64_epi16() {
+    fn test_mm_mask_cvtusepi64_epi16() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let src = _mm_set1_epi16(0);
         let r = _mm_mask_cvtusepi64_epi16(src, 0, a);
@@ -5083,7 +5083,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi64_epi16() {
+    fn test_mm_maskz_cvtusepi64_epi16() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_maskz_cvtusepi64_epi16(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5093,7 +5093,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtusepi64_epi8() {
+    fn test_mm512_cvtusepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_cvtusepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, -1, -1);
@@ -5101,7 +5101,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtusepi64_epi8() {
+    fn test_mm512_mask_cvtusepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let src = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
         let r = _mm512_mask_cvtusepi64_epi8(src, 0, a);
@@ -5112,7 +5112,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtusepi64_epi8() {
+    fn test_mm512_maskz_cvtusepi64_epi8() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, i64::MIN, i64::MIN);
         let r = _mm512_maskz_cvtusepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5122,7 +5122,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvtusepi64_epi8() {
+    fn test_mm256_cvtusepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_cvtusepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, u8::MAX as i8);
@@ -5130,7 +5130,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvtusepi64_epi8() {
+    fn test_mm256_mask_cvtusepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm256_mask_cvtusepi64_epi8(src, 0, a);
@@ -5141,7 +5141,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvtusepi64_epi8() {
+    fn test_mm256_maskz_cvtusepi64_epi8() {
         let a = _mm256_set_epi64x(4, 5, 6, i64::MAX);
         let r = _mm256_maskz_cvtusepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5151,7 +5151,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvtusepi64_epi8() {
+    fn test_mm_cvtusepi64_epi8() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_cvtusepi64_epi8(a);
         let e = _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, u8::MAX as i8);
@@ -5159,7 +5159,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvtusepi64_epi8() {
+    fn test_mm_mask_cvtusepi64_epi8() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let src = _mm_set1_epi8(0);
         let r = _mm_mask_cvtusepi64_epi8(src, 0, a);
@@ -5170,7 +5170,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvtusepi64_epi8() {
+    fn test_mm_maskz_cvtusepi64_epi8() {
         let a = _mm_set_epi64x(6, i64::MAX);
         let r = _mm_maskz_cvtusepi64_epi8(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5180,7 +5180,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtt_roundpd_epi32() {
+    fn test_mm512_cvtt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtt_roundpd_epi32::<_MM_FROUND_NO_EXC>(a);
         let e = _mm256_setr_epi32(0, -1, 2, -3, 4, -5, 6, -7);
@@ -5188,7 +5188,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtt_roundpd_epi32() {
+    fn test_mm512_mask_cvtt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvtt_roundpd_epi32::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -5199,7 +5199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtt_roundpd_epi32() {
+    fn test_mm512_maskz_cvtt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvtt_roundpd_epi32::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -5209,7 +5209,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvtt_roundpd_epu32() {
+    fn test_mm512_cvtt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvtt_roundpd_epu32::<_MM_FROUND_NO_EXC>(a);
         let e = _mm256_setr_epi32(0, -1, 2, -1, 4, -1, 6, -1);
@@ -5217,7 +5217,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvtt_roundpd_epu32() {
+    fn test_mm512_mask_cvtt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvtt_roundpd_epu32::<_MM_FROUND_NO_EXC>(src, 0, a);
@@ -5228,7 +5228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvtt_roundpd_epu32() {
+    fn test_mm512_maskz_cvtt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvtt_roundpd_epu32::<_MM_FROUND_NO_EXC>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -5238,7 +5238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvttpd_epi32() {
+    fn test_mm512_cvttpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvttpd_epi32(a);
         let e = _mm256_setr_epi32(0, -1, 2, -3, 4, -5, 6, -7);
@@ -5246,7 +5246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvttpd_epi32() {
+    fn test_mm512_mask_cvttpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvttpd_epi32(src, 0, a);
@@ -5257,7 +5257,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvttpd_epi32() {
+    fn test_mm512_maskz_cvttpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvttpd_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -5267,7 +5267,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvttpd_epi32() {
+    fn test_mm256_mask_cvttpd_epi32() {
         let a = _mm256_setr_pd(4., -5.5, 6., -7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvttpd_epi32(src, 0, a);
@@ -5278,7 +5278,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttpd_epi32() {
+    fn test_mm256_maskz_cvttpd_epi32() {
         let a = _mm256_setr_pd(4., -5.5, 6., -7.5);
         let r = _mm256_maskz_cvttpd_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5288,7 +5288,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvttpd_epi32() {
+    fn test_mm_mask_cvttpd_epi32() {
         let a = _mm_set_pd(6., -7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvttpd_epi32(src, 0, a);
@@ -5299,7 +5299,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvttpd_epi32() {
+    fn test_mm_maskz_cvttpd_epi32() {
         let a = _mm_set_pd(6., -7.5);
         let r = _mm_maskz_cvttpd_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5309,7 +5309,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvttpd_epu32() {
+    fn test_mm512_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvttpd_epu32(a);
         let e = _mm256_setr_epi32(0, -1, 2, -1, 4, -1, 6, -1);
@@ -5317,7 +5317,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvttpd_epu32() {
+    fn test_mm512_mask_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvttpd_epu32(src, 0, a);
@@ -5328,7 +5328,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvttpd_epu32() {
+    fn test_mm512_maskz_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvttpd_epu32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -5338,7 +5338,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cvttpd_epu32() {
+    fn test_mm256_cvttpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let r = _mm256_cvttpd_epu32(a);
         let e = _mm_set_epi32(4, 5, 6, 7);
@@ -5346,7 +5346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cvttpd_epu32() {
+    fn test_mm256_mask_cvttpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm256_mask_cvttpd_epu32(src, 0, a);
@@ -5357,7 +5357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_cvttpd_epu32() {
+    fn test_mm256_maskz_cvttpd_epu32() {
         let a = _mm256_set_pd(4., 5.5, 6., 7.5);
         let r = _mm256_maskz_cvttpd_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5367,7 +5367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cvttpd_epu32() {
+    fn test_mm_cvttpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let r = _mm_cvttpd_epu32(a);
         let e = _mm_set_epi32(0, 0, 6, 7);
@@ -5375,7 +5375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cvttpd_epu32() {
+    fn test_mm_mask_cvttpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let src = _mm_set1_epi32(0);
         let r = _mm_mask_cvttpd_epu32(src, 0, a);
@@ -5386,7 +5386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_cvttpd_epu32() {
+    fn test_mm_maskz_cvttpd_epu32() {
         let a = _mm_set_pd(6., 7.5);
         let r = _mm_maskz_cvttpd_epu32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -5396,7 +5396,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_add_round_pd() {
+    fn test_mm512_add_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(-1.);
         let r = _mm512_add_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -5408,7 +5408,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_add_round_pd() {
+    fn test_mm512_mask_add_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(-1.);
         let r = _mm512_mask_add_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -5423,7 +5423,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_add_round_pd() {
+    fn test_mm512_maskz_add_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(-1.);
         let r =
@@ -5437,7 +5437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sub_round_pd() {
+    fn test_mm512_sub_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_sub_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -5449,7 +5449,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sub_round_pd() {
+    fn test_mm512_mask_sub_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let r = _mm512_mask_sub_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -5464,7 +5464,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sub_round_pd() {
+    fn test_mm512_maskz_sub_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let r =
@@ -5478,7 +5478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mul_round_pd() {
+    fn test_mm512_mul_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.);
         let b = _mm512_set1_pd(0.1);
         let r = _mm512_mul_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -5499,7 +5499,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_mul_round_pd() {
+    fn test_mm512_mask_mul_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.);
         let b = _mm512_set1_pd(0.1);
         let r = _mm512_mask_mul_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -5523,7 +5523,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_mul_round_pd() {
+    fn test_mm512_maskz_mul_round_pd() {
         let a = _mm512_setr_pd(8., 9.5, 10., 11.5, 12., 13.5, 14., 0.);
         let b = _mm512_set1_pd(0.1);
         let r =
@@ -5546,7 +5546,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_div_round_pd() {
+    fn test_mm512_div_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_div_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -5558,7 +5558,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_div_round_pd() {
+    fn test_mm512_mask_div_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_mask_div_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -5582,7 +5582,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_div_round_pd() {
+    fn test_mm512_maskz_div_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r =
@@ -5605,7 +5605,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sqrt_round_pd() {
+    fn test_mm512_sqrt_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_sqrt_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         let e = _mm512_set1_pd(1.7320508075688772);
@@ -5616,7 +5616,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sqrt_round_pd() {
+    fn test_mm512_mask_sqrt_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r =
             _mm512_mask_sqrt_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 0, a);
@@ -5638,7 +5638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sqrt_round_pd() {
+    fn test_mm512_maskz_sqrt_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r =
             _mm512_maskz_sqrt_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(0, a);
@@ -5660,7 +5660,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmadd_round_pd() {
+    fn test_mm512_fmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5673,7 +5673,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmadd_round_pd() {
+    fn test_mm512_mask_fmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5698,7 +5698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmadd_round_pd() {
+    fn test_mm512_maskz_fmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5714,7 +5714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmadd_round_pd() {
+    fn test_mm512_mask3_fmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5730,7 +5730,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmsub_round_pd() {
+    fn test_mm512_fmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5743,7 +5743,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmsub_round_pd() {
+    fn test_mm512_mask_fmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5768,7 +5768,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmsub_round_pd() {
+    fn test_mm512_maskz_fmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5784,7 +5784,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmsub_round_pd() {
+    fn test_mm512_mask3_fmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5800,7 +5800,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmaddsub_round_pd() {
+    fn test_mm512_fmaddsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5823,7 +5823,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmaddsub_round_pd() {
+    fn test_mm512_mask_fmaddsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5848,7 +5848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmaddsub_round_pd() {
+    fn test_mm512_maskz_fmaddsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5864,7 +5864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmaddsub_round_pd() {
+    fn test_mm512_mask3_fmaddsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5880,7 +5880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fmsubadd_round_pd() {
+    fn test_mm512_fmsubadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5903,7 +5903,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fmsubadd_round_pd() {
+    fn test_mm512_mask_fmsubadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5928,7 +5928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fmsubadd_round_pd() {
+    fn test_mm512_maskz_fmsubadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5944,7 +5944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fmsubadd_round_pd() {
+    fn test_mm512_mask3_fmsubadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -5960,7 +5960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fnmadd_round_pd() {
+    fn test_mm512_fnmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5974,7 +5974,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fnmadd_round_pd() {
+    fn test_mm512_mask_fnmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -5999,7 +5999,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fnmadd_round_pd() {
+    fn test_mm512_maskz_fnmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -6015,7 +6015,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fnmadd_round_pd() {
+    fn test_mm512_mask3_fnmadd_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(1.);
@@ -6031,7 +6031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fnmsub_round_pd() {
+    fn test_mm512_fnmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -6045,7 +6045,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fnmsub_round_pd() {
+    fn test_mm512_mask_fnmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -6070,7 +6070,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fnmsub_round_pd() {
+    fn test_mm512_maskz_fnmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -6086,7 +6086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask3_fnmsub_round_pd() {
+    fn test_mm512_mask3_fnmsub_round_pd() {
         let a = _mm512_set1_pd(0.000000000000000007);
         let b = _mm512_set1_pd(1.);
         let c = _mm512_set1_pd(-1.);
@@ -6102,7 +6102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_max_round_pd() {
+    fn test_mm512_max_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_max_round_pd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -6111,7 +6111,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_max_round_pd() {
+    fn test_mm512_mask_max_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_mask_max_round_pd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -6122,7 +6122,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_max_round_pd() {
+    fn test_mm512_maskz_max_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_maskz_max_round_pd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -6133,7 +6133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_min_round_pd() {
+    fn test_mm512_min_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_min_round_pd::<_MM_FROUND_CUR_DIRECTION>(a, b);
@@ -6142,7 +6142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_min_round_pd() {
+    fn test_mm512_mask_min_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_mask_min_round_pd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a, b);
@@ -6153,7 +6153,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_min_round_pd() {
+    fn test_mm512_maskz_min_round_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_setr_pd(7., 6., 5., 4., 3., 2., 1., 0.);
         let r = _mm512_maskz_min_round_pd::<_MM_FROUND_CUR_DIRECTION>(0, a, b);
@@ -6164,7 +6164,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getexp_round_pd() {
+    fn test_mm512_getexp_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_getexp_round_pd::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm512_set1_pd(1.);
@@ -6172,7 +6172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getexp_round_pd() {
+    fn test_mm512_mask_getexp_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_mask_getexp_round_pd::<_MM_FROUND_CUR_DIRECTION>(a, 0, a);
         assert_eq_m512d(r, a);
@@ -6182,7 +6182,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getexp_round_pd() {
+    fn test_mm512_maskz_getexp_round_pd() {
         let a = _mm512_set1_pd(3.);
         let r = _mm512_maskz_getexp_round_pd::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -6192,7 +6192,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_roundscale_round_pd() {
+    fn test_mm512_roundscale_round_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_roundscale_round_pd::<0, _MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm512_set1_pd(1.0);
@@ -6200,7 +6200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_roundscale_round_pd() {
+    fn test_mm512_mask_roundscale_round_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_mask_roundscale_round_pd::<0, _MM_FROUND_CUR_DIRECTION>(a, 0, a);
         let e = _mm512_set1_pd(1.1);
@@ -6211,7 +6211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_roundscale_round_pd() {
+    fn test_mm512_maskz_roundscale_round_pd() {
         let a = _mm512_set1_pd(1.1);
         let r = _mm512_maskz_roundscale_round_pd::<0, _MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -6221,7 +6221,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_scalef_round_pd() {
+    fn test_mm512_scalef_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_scalef_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, b);
@@ -6230,7 +6230,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_scalef_round_pd() {
+    fn test_mm512_mask_scalef_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_mask_scalef_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -6245,7 +6245,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_scalef_round_pd() {
+    fn test_mm512_maskz_scalef_round_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(3.);
         let r = _mm512_maskz_scalef_round_pd::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -6260,7 +6260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_fixupimm_round_pd() {
+    fn test_mm512_fixupimm_round_pd() {
         let a = _mm512_set1_pd(f64::NAN);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -6270,7 +6270,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_fixupimm_round_pd() {
+    fn test_mm512_mask_fixupimm_round_pd() {
         let a = _mm512_set_pd(f64::NAN, f64::NAN, f64::NAN, f64::NAN, 1., 1., 1., 1.);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -6280,7 +6280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_fixupimm_round_pd() {
+    fn test_mm512_maskz_fixupimm_round_pd() {
         let a = _mm512_set_pd(f64::NAN, f64::NAN, f64::NAN, f64::NAN, 1., 1., 1., 1.);
         let b = _mm512_set1_pd(f64::MAX);
         let c = _mm512_set1_epi64(i32::MAX as i64);
@@ -6290,7 +6290,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_getmant_round_pd() {
+    fn test_mm512_getmant_round_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_getmant_round_pd::<
             _MM_MANT_NORM_1_2,
@@ -6302,7 +6302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_getmant_round_pd() {
+    fn test_mm512_mask_getmant_round_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_mask_getmant_round_pd::<
             _MM_MANT_NORM_1_2,
@@ -6320,7 +6320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_getmant_round_pd() {
+    fn test_mm512_maskz_getmant_round_pd() {
         let a = _mm512_set1_pd(10.);
         let r = _mm512_maskz_getmant_round_pd::<
             _MM_MANT_NORM_1_2,
@@ -6338,7 +6338,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundps_pd() {
+    fn test_mm512_cvt_roundps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvt_roundps_pd::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
@@ -6346,7 +6346,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundps_pd() {
+    fn test_mm512_mask_cvt_roundps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm512_set1_pd(0.);
         let r = _mm512_mask_cvt_roundps_pd::<_MM_FROUND_CUR_DIRECTION>(src, 0, a);
@@ -6357,7 +6357,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundps_pd() {
+    fn test_mm512_maskz_cvt_roundps_pd() {
         let a = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvt_roundps_pd::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -6367,7 +6367,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundpd_ps() {
+    fn test_mm512_cvt_roundpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvt_roundpd_ps::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm256_setr_ps(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
@@ -6375,7 +6375,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundpd_ps() {
+    fn test_mm512_mask_cvt_roundpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_ps(0.);
         let r = _mm512_mask_cvt_roundpd_ps::<_MM_FROUND_CUR_DIRECTION>(src, 0, a);
@@ -6386,7 +6386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_ps() {
+    fn test_mm512_maskz_cvt_roundpd_ps() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvt_roundpd_ps::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m256(r, _mm256_setzero_ps());
@@ -6396,7 +6396,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundpd_epi32() {
+    fn test_mm512_cvt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvt_roundpd_epi32::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm256_setr_epi32(0, -2, 2, -4, 4, -6, 6, -8);
@@ -6404,7 +6404,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundpd_epi32() {
+    fn test_mm512_mask_cvt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvt_roundpd_epi32::<_MM_FROUND_CUR_DIRECTION>(src, 0, a);
@@ -6415,7 +6415,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_epi32() {
+    fn test_mm512_maskz_cvt_roundpd_epi32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvt_roundpd_epi32::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -6425,7 +6425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cvt_roundpd_epu32() {
+    fn test_mm512_cvt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_cvt_roundpd_epu32::<_MM_FROUND_CUR_DIRECTION>(a);
         let e = _mm256_setr_epi32(0, -1, 2, -1, 4, -1, 6, -1);
@@ -6433,7 +6433,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cvt_roundpd_epu32() {
+    fn test_mm512_mask_cvt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
         let r = _mm512_mask_cvt_roundpd_epu32::<_MM_FROUND_CUR_DIRECTION>(src, 0, a);
@@ -6444,7 +6444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_cvt_roundpd_epu32() {
+    fn test_mm512_maskz_cvt_roundpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvt_roundpd_epu32::<_MM_FROUND_CUR_DIRECTION>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -6454,48 +6454,48 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setzero_pd() {
+    const fn test_mm512_setzero_pd() {
         assert_eq_m512d(_mm512_setzero_pd(), _mm512_set1_pd(0.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_epi64() {
+    const fn test_mm512_set1_epi64() {
         let r = _mm512_set_epi64(2, 2, 2, 2, 2, 2, 2, 2);
         assert_eq_m512i(r, _mm512_set1_epi64(2));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set1_pd() {
+    const fn test_mm512_set1_pd() {
         let expected = _mm512_set_pd(2., 2., 2., 2., 2., 2., 2., 2.);
         assert_eq_m512d(expected, _mm512_set1_pd(2.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set4_epi64() {
+    const fn test_mm512_set4_epi64() {
         let r = _mm512_set_epi64(4, 3, 2, 1, 4, 3, 2, 1);
         assert_eq_m512i(r, _mm512_set4_epi64(4, 3, 2, 1));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set4_pd() {
+    const fn test_mm512_set4_pd() {
         let r = _mm512_set_pd(4., 3., 2., 1., 4., 3., 2., 1.);
         assert_eq_m512d(r, _mm512_set4_pd(4., 3., 2., 1.));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr4_epi64() {
+    const fn test_mm512_setr4_epi64() {
         let r = _mm512_set_epi64(4, 3, 2, 1, 4, 3, 2, 1);
         assert_eq_m512i(r, _mm512_setr4_epi64(1, 2, 3, 4));
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr4_pd() {
+    const fn test_mm512_setr4_pd() {
         let r = _mm512_set_pd(4., 3., 2., 1., 4., 3., 2., 1.);
         assert_eq_m512d(r, _mm512_setr4_pd(1., 2., 3., 4.));
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmplt_pd_mask() {
+    fn test_mm512_cmplt_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6504,7 +6504,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmplt_pd_mask() {
+    fn test_mm512_mask_cmplt_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6514,7 +6514,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpnlt_pd_mask() {
+    fn test_mm512_cmpnlt_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6522,7 +6522,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpnlt_pd_mask() {
+    fn test_mm512_mask_cmpnlt_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6531,7 +6531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmple_pd_mask() {
+    fn test_mm512_cmple_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6539,7 +6539,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmple_pd_mask() {
+    fn test_mm512_mask_cmple_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6548,7 +6548,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpnle_pd_mask() {
+    fn test_mm512_cmpnle_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6557,7 +6557,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpnle_pd_mask() {
+    fn test_mm512_mask_cmpnle_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., f64::MAX, f64::NAN, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6567,7 +6567,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpeq_pd_mask() {
+    fn test_mm512_cmpeq_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, f64::NAN, -100.);
         let b = _mm512_set_pd(0., 1., 13., 42., f64::MAX, f64::MIN, f64::NAN, -100.);
         let m = _mm512_cmpeq_pd_mask(b, a);
@@ -6575,7 +6575,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpeq_pd_mask() {
+    fn test_mm512_mask_cmpeq_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, f64::NAN, -100.);
         let b = _mm512_set_pd(0., 1., 13., 42., f64::MAX, f64::MIN, f64::NAN, -100.);
         let mask = 0b01111010;
@@ -6584,7 +6584,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpneq_pd_mask() {
+    fn test_mm512_cmpneq_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, f64::NAN, -100.);
         let b = _mm512_set_pd(0., 1., 13., 42., f64::MAX, f64::MIN, f64::NAN, -100.);
         let m = _mm512_cmpneq_pd_mask(b, a);
@@ -6592,7 +6592,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpneq_pd_mask() {
+    fn test_mm512_mask_cmpneq_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, f64::NAN, -100.);
         let b = _mm512_set_pd(0., 1., 13., 42., f64::MAX, f64::MIN, f64::NAN, -100.);
         let mask = 0b01111010;
@@ -6601,7 +6601,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmp_pd_mask() {
+    fn test_mm512_cmp_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
         let m = _mm512_cmp_pd_mask::<_CMP_LT_OQ>(a, b);
@@ -6609,7 +6609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmp_pd_mask() {
+    fn test_mm512_mask_cmp_pd_mask() {
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
         let mask = 0b01100110;
@@ -6618,7 +6618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_cmp_pd_mask() {
+    fn test_mm256_cmp_pd_mask() {
         let a = _mm256_set_pd(0., 1., -1., 13.);
         let b = _mm256_set1_pd(1.);
         let m = _mm256_cmp_pd_mask::<_CMP_LT_OQ>(a, b);
@@ -6626,7 +6626,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_cmp_pd_mask() {
+    fn test_mm256_mask_cmp_pd_mask() {
         let a = _mm256_set_pd(0., 1., -1., 13.);
         let b = _mm256_set1_pd(1.);
         let mask = 0b11111111;
@@ -6635,7 +6635,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_cmp_pd_mask() {
+    fn test_mm_cmp_pd_mask() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set1_pd(1.);
         let m = _mm_cmp_pd_mask::<_CMP_LT_OQ>(a, b);
@@ -6643,7 +6643,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_cmp_pd_mask() {
+    fn test_mm_mask_cmp_pd_mask() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set1_pd(1.);
         let mask = 0b11111111;
@@ -6652,7 +6652,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmp_round_pd_mask() {
+    fn test_mm512_cmp_round_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6661,7 +6661,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmp_round_pd_mask() {
+    fn test_mm512_mask_cmp_round_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(0., 1., -1., 13., f64::MAX, f64::MIN, 100., -100.);
         let b = _mm512_set1_pd(-1.);
@@ -6671,7 +6671,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpord_pd_mask() {
+    fn test_mm512_cmpord_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(f64::NAN, f64::MAX, f64::NAN, f64::MIN, f64::NAN, -1., f64::NAN, 0.);
         #[rustfmt::skip]
@@ -6681,7 +6681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpord_pd_mask() {
+    fn test_mm512_mask_cmpord_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(f64::NAN, f64::MAX, f64::NAN, f64::MIN, f64::NAN, -1., f64::NAN, 0.);
         #[rustfmt::skip]
@@ -6692,7 +6692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_cmpunord_pd_mask() {
+    fn test_mm512_cmpunord_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(f64::NAN, f64::MAX, f64::NAN, f64::MIN, f64::NAN, -1., f64::NAN, 0.);
         #[rustfmt::skip]
@@ -6703,7 +6703,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_cmpunord_pd_mask() {
+    fn test_mm512_mask_cmpunord_pd_mask() {
         #[rustfmt::skip]
         let a = _mm512_set_pd(f64::NAN, f64::MAX, f64::NAN, f64::MIN, f64::NAN, -1., f64::NAN, 0.);
         #[rustfmt::skip]
@@ -6714,7 +6714,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmplt_epu64_mask() {
+    const fn test_mm512_cmplt_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmplt_epu64_mask(a, b);
@@ -6722,7 +6722,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmplt_epu64_mask() {
+    const fn test_mm512_mask_cmplt_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01111010;
@@ -6731,7 +6731,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epu64_mask() {
+    const fn test_mm256_cmplt_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 100);
         let b = _mm256_set1_epi64x(2);
         let r = _mm256_cmplt_epu64_mask(a, b);
@@ -6739,7 +6739,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epu64_mask() {
+    const fn test_mm256_mask_cmplt_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 100);
         let b = _mm256_set1_epi64x(2);
         let mask = 0b11111111;
@@ -6748,7 +6748,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmplt_epu64_mask() {
+    const fn test_mm_cmplt_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(2);
         let r = _mm_cmplt_epu64_mask(a, b);
@@ -6756,7 +6756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epu64_mask() {
+    const fn test_mm_mask_cmplt_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(2);
         let mask = 0b11111111;
@@ -6765,7 +6765,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpgt_epu64_mask() {
+    const fn test_mm512_cmpgt_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmpgt_epu64_mask(b, a);
@@ -6773,7 +6773,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpgt_epu64_mask() {
+    const fn test_mm512_mask_cmpgt_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01111010;
@@ -6782,7 +6782,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epu64_mask() {
+    const fn test_mm256_cmpgt_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_cmpgt_epu64_mask(a, b);
@@ -6790,7 +6790,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epu64_mask() {
+    const fn test_mm256_mask_cmpgt_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let b = _mm256_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6799,7 +6799,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epu64_mask() {
+    const fn test_mm_cmpgt_epu64_mask() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set1_epi64x(1);
         let r = _mm_cmpgt_epu64_mask(a, b);
@@ -6807,7 +6807,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epu64_mask() {
+    const fn test_mm_mask_cmpgt_epu64_mask() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6816,7 +6816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmple_epu64_mask() {
+    const fn test_mm512_cmple_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         assert_eq!(
@@ -6826,7 +6826,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmple_epu64_mask() {
+    const fn test_mm512_mask_cmple_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01111010;
@@ -6834,7 +6834,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmple_epu64_mask() {
+    const fn test_mm256_cmple_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 1);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_cmple_epu64_mask(a, b);
@@ -6842,7 +6842,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epu64_mask() {
+    const fn test_mm256_mask_cmple_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, 1);
         let b = _mm256_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6851,7 +6851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmple_epu64_mask() {
+    const fn test_mm_cmple_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let r = _mm_cmple_epu64_mask(a, b);
@@ -6859,7 +6859,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epu64_mask() {
+    const fn test_mm_mask_cmple_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6868,7 +6868,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpge_epu64_mask() {
+    const fn test_mm512_cmpge_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         assert_eq!(
@@ -6878,7 +6878,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpge_epu64_mask() {
+    const fn test_mm512_mask_cmpge_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b11111111;
@@ -6887,7 +6887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epu64_mask() {
+    const fn test_mm256_cmpge_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, u64::MAX as i64);
         let b = _mm256_set1_epi64x(1);
         let r = _mm256_cmpge_epu64_mask(a, b);
@@ -6895,7 +6895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epu64_mask() {
+    const fn test_mm256_mask_cmpge_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, 2, u64::MAX as i64);
         let b = _mm256_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6904,7 +6904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpge_epu64_mask() {
+    const fn test_mm_cmpge_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let r = _mm_cmpge_epu64_mask(a, b);
@@ -6912,7 +6912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epu64_mask() {
+    const fn test_mm_mask_cmpge_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -6921,7 +6921,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpeq_epu64_mask() {
+    const fn test_mm512_cmpeq_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let m = _mm512_cmpeq_epu64_mask(b, a);
@@ -6929,7 +6929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpeq_epu64_mask() {
+    const fn test_mm512_mask_cmpeq_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let mask = 0b01111010;
@@ -6938,7 +6938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epu64_mask() {
+    const fn test_mm256_cmpeq_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, u64::MAX as i64);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let m = _mm256_cmpeq_epu64_mask(b, a);
@@ -6946,7 +6946,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epu64_mask() {
+    const fn test_mm256_mask_cmpeq_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, u64::MAX as i64);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -6955,7 +6955,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epu64_mask() {
+    const fn test_mm_cmpeq_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(0, 1);
         let m = _mm_cmpeq_epu64_mask(b, a);
@@ -6963,7 +6963,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epu64_mask() {
+    const fn test_mm_mask_cmpeq_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(0, 1);
         let mask = 0b11111111;
@@ -6972,7 +6972,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpneq_epu64_mask() {
+    const fn test_mm512_cmpneq_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let m = _mm512_cmpneq_epu64_mask(b, a);
@@ -6980,7 +6980,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpneq_epu64_mask() {
+    const fn test_mm512_mask_cmpneq_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, -100, 100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let mask = 0b01111010;
@@ -6989,7 +6989,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epu64_mask() {
+    const fn test_mm256_cmpneq_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, u64::MAX as i64);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let r = _mm256_cmpneq_epu64_mask(b, a);
@@ -6997,7 +6997,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epu64_mask() {
+    const fn test_mm256_mask_cmpneq_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, u64::MAX as i64);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -7006,7 +7006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epu64_mask() {
+    const fn test_mm_cmpneq_epu64_mask() {
         let a = _mm_set_epi64x(-1, u64::MAX as i64);
         let b = _mm_set_epi64x(13, 42);
         let r = _mm_cmpneq_epu64_mask(b, a);
@@ -7014,7 +7014,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epu64_mask() {
+    const fn test_mm_mask_cmpneq_epu64_mask() {
         let a = _mm_set_epi64x(-1, u64::MAX as i64);
         let b = _mm_set_epi64x(13, 42);
         let mask = 0b11111111;
@@ -7023,7 +7023,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmp_epu64_mask() {
+    const fn test_mm512_cmp_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmp_epu64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7031,7 +7031,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmp_epu64_mask() {
+    const fn test_mm512_mask_cmp_epu64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01111010;
@@ -7040,7 +7040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmp_epu64_mask() {
+    const fn test_mm256_cmp_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 100);
         let b = _mm256_set1_epi64x(1);
         let m = _mm256_cmp_epu64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7048,7 +7048,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epu64_mask() {
+    const fn test_mm256_mask_cmp_epu64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 100);
         let b = _mm256_set1_epi64x(1);
         let mask = 0b11111111;
@@ -7057,7 +7057,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmp_epu64_mask() {
+    const fn test_mm_cmp_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let m = _mm_cmp_epu64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7065,7 +7065,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epu64_mask() {
+    const fn test_mm_mask_cmp_epu64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -7074,7 +7074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmplt_epi64_mask() {
+    const fn test_mm512_cmplt_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmplt_epi64_mask(a, b);
@@ -7082,7 +7082,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmplt_epi64_mask() {
+    const fn test_mm512_mask_cmplt_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01100110;
@@ -7091,7 +7091,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmplt_epi64_mask() {
+    const fn test_mm256_cmplt_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, -13);
         let b = _mm256_set1_epi64x(-1);
         let r = _mm256_cmplt_epi64_mask(a, b);
@@ -7099,7 +7099,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmplt_epi64_mask() {
+    const fn test_mm256_mask_cmplt_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, -13);
         let b = _mm256_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7108,7 +7108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmplt_epi64_mask() {
+    const fn test_mm_cmplt_epi64_mask() {
         let a = _mm_set_epi64x(-1, -13);
         let b = _mm_set1_epi64x(-1);
         let r = _mm_cmplt_epi64_mask(a, b);
@@ -7116,7 +7116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmplt_epi64_mask() {
+    const fn test_mm_mask_cmplt_epi64_mask() {
         let a = _mm_set_epi64x(-1, -13);
         let b = _mm_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7125,7 +7125,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpgt_epi64_mask() {
+    const fn test_mm512_cmpgt_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmpgt_epi64_mask(b, a);
@@ -7133,7 +7133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpgt_epi64_mask() {
+    const fn test_mm512_mask_cmpgt_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01100110;
@@ -7142,7 +7142,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpgt_epi64_mask() {
+    const fn test_mm256_cmpgt_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set1_epi64x(-1);
         let r = _mm256_cmpgt_epi64_mask(a, b);
@@ -7150,7 +7150,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpgt_epi64_mask() {
+    const fn test_mm256_mask_cmpgt_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7159,7 +7159,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpgt_epi64_mask() {
+    const fn test_mm_cmpgt_epi64_mask() {
         let a = _mm_set_epi64x(0, -1);
         let b = _mm_set1_epi64x(-1);
         let r = _mm_cmpgt_epi64_mask(a, b);
@@ -7167,7 +7167,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpgt_epi64_mask() {
+    const fn test_mm_mask_cmpgt_epi64_mask() {
         let a = _mm_set_epi64x(0, -1);
         let b = _mm_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7176,7 +7176,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmple_epi64_mask() {
+    const fn test_mm512_cmple_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         assert_eq!(
@@ -7186,7 +7186,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmple_epi64_mask() {
+    const fn test_mm512_mask_cmple_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01111010;
@@ -7194,7 +7194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmple_epi64_mask() {
+    const fn test_mm256_cmple_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, i64::MAX);
         let b = _mm256_set1_epi64x(-1);
         let r = _mm256_cmple_epi64_mask(a, b);
@@ -7202,7 +7202,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmple_epi64_mask() {
+    const fn test_mm256_mask_cmple_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, i64::MAX);
         let b = _mm256_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7211,7 +7211,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmple_epi64_mask() {
+    const fn test_mm_cmple_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let r = _mm_cmple_epi64_mask(a, b);
@@ -7219,7 +7219,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmple_epi64_mask() {
+    const fn test_mm_mask_cmple_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -7228,7 +7228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpge_epi64_mask() {
+    const fn test_mm512_cmpge_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         assert_eq!(
@@ -7238,7 +7238,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpge_epi64_mask() {
+    const fn test_mm512_mask_cmpge_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, u64::MAX as i64, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b11111111;
@@ -7247,7 +7247,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpge_epi64_mask() {
+    const fn test_mm256_cmpge_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, i64::MAX);
         let b = _mm256_set1_epi64x(-1);
         let r = _mm256_cmpge_epi64_mask(a, b);
@@ -7255,7 +7255,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpge_epi64_mask() {
+    const fn test_mm256_mask_cmpge_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, i64::MAX);
         let b = _mm256_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7264,7 +7264,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpge_epi64_mask() {
+    const fn test_mm_cmpge_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(-1);
         let r = _mm_cmpge_epi64_mask(a, b);
@@ -7272,7 +7272,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpge_epi64_mask() {
+    const fn test_mm_mask_cmpge_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(-1);
         let mask = 0b11111111;
@@ -7281,7 +7281,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpeq_epi64_mask() {
+    const fn test_mm512_cmpeq_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let m = _mm512_cmpeq_epi64_mask(b, a);
@@ -7289,7 +7289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpeq_epi64_mask() {
+    const fn test_mm512_mask_cmpeq_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let mask = 0b01111010;
@@ -7298,7 +7298,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpeq_epi64_mask() {
+    const fn test_mm256_cmpeq_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let m = _mm256_cmpeq_epi64_mask(b, a);
@@ -7306,7 +7306,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpeq_epi64_mask() {
+    const fn test_mm256_mask_cmpeq_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -7315,7 +7315,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpeq_epi64_mask() {
+    const fn test_mm_cmpeq_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(0, 1);
         let m = _mm_cmpeq_epi64_mask(b, a);
@@ -7323,7 +7323,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpeq_epi64_mask() {
+    const fn test_mm_mask_cmpeq_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set_epi64x(0, 1);
         let mask = 0b11111111;
@@ -7332,19 +7332,19 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_set_epi64() {
+    const fn test_mm512_set_epi64() {
         let r = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         assert_eq_m512i(r, _mm512_set_epi64(7, 6, 5, 4, 3, 2, 1, 0))
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_setr_epi64() {
+    const fn test_mm512_setr_epi64() {
         let r = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         assert_eq_m512i(r, _mm512_setr_epi64(7, 6, 5, 4, 3, 2, 1, 0))
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmpneq_epi64_mask() {
+    const fn test_mm512_cmpneq_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let m = _mm512_cmpneq_epi64_mask(b, a);
@@ -7352,7 +7352,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmpneq_epi64_mask() {
+    const fn test_mm512_mask_cmpneq_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, -100, 100);
         let b = _mm512_set_epi64(0, 1, 13, 42, i64::MAX, i64::MIN, 100, -100);
         let mask = 0b01111010;
@@ -7361,7 +7361,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmpneq_epi64_mask() {
+    const fn test_mm256_cmpneq_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let r = _mm256_cmpneq_epi64_mask(b, a);
@@ -7369,7 +7369,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmpneq_epi64_mask() {
+    const fn test_mm256_mask_cmpneq_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set_epi64x(0, 1, 13, 42);
         let mask = 0b11111111;
@@ -7378,7 +7378,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmpneq_epi64_mask() {
+    const fn test_mm_cmpneq_epi64_mask() {
         let a = _mm_set_epi64x(-1, 13);
         let b = _mm_set_epi64x(13, 42);
         let r = _mm_cmpneq_epi64_mask(b, a);
@@ -7386,7 +7386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmpneq_epi64_mask() {
+    const fn test_mm_mask_cmpneq_epi64_mask() {
         let a = _mm_set_epi64x(-1, 13);
         let b = _mm_set_epi64x(13, 42);
         let mask = 0b11111111;
@@ -7395,7 +7395,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_cmp_epi64_mask() {
+    const fn test_mm512_cmp_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let m = _mm512_cmp_epi64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7403,7 +7403,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_cmp_epi64_mask() {
+    const fn test_mm512_mask_cmp_epi64_mask() {
         let a = _mm512_set_epi64(0, 1, -1, 13, i64::MAX, i64::MIN, 100, -100);
         let b = _mm512_set1_epi64(-1);
         let mask = 0b01100110;
@@ -7412,7 +7412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_cmp_epi64_mask() {
+    const fn test_mm256_cmp_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set1_epi64x(1);
         let m = _mm256_cmp_epi64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7420,7 +7420,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_cmp_epi64_mask() {
+    const fn test_mm256_mask_cmp_epi64_mask() {
         let a = _mm256_set_epi64x(0, 1, -1, 13);
         let b = _mm256_set1_epi64x(1);
         let mask = 0b11111111;
@@ -7429,7 +7429,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_cmp_epi64_mask() {
+    const fn test_mm_cmp_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let m = _mm_cmp_epi64_mask::<_MM_CMPINT_LT>(a, b);
@@ -7437,7 +7437,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_cmp_epi64_mask() {
+    const fn test_mm_mask_cmp_epi64_mask() {
         let a = _mm_set_epi64x(0, 1);
         let b = _mm_set1_epi64x(1);
         let mask = 0b11111111;
@@ -8318,7 +8318,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rol_epi64() {
+    const fn test_mm512_rol_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -8334,7 +8334,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rol_epi64() {
+    const fn test_mm512_mask_rol_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -8352,7 +8352,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rol_epi64() {
+    const fn test_mm512_maskz_rol_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8366,7 +8366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rol_epi64() {
+    const fn test_mm256_rol_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_rol_epi64::<1>(a);
         let e = _mm256_set_epi64x(1 << 0, 1 << 33, 1 << 33, 1 << 33);
@@ -8374,7 +8374,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rol_epi64() {
+    const fn test_mm256_mask_rol_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_mask_rol_epi64::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -8384,7 +8384,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rol_epi64() {
+    const fn test_mm256_maskz_rol_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_maskz_rol_epi64::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -8394,7 +8394,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rol_epi64() {
+    const fn test_mm_rol_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let r = _mm_rol_epi64::<1>(a);
         let e = _mm_set_epi64x(1 << 0, 1 << 33);
@@ -8402,7 +8402,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rol_epi64() {
+    const fn test_mm_mask_rol_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let r = _mm_mask_rol_epi64::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -8412,7 +8412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rol_epi64() {
+    const fn test_mm_maskz_rol_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let r = _mm_maskz_rol_epi64::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -8422,7 +8422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_ror_epi64() {
+    const fn test_mm512_ror_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0,  1 << 32, 1 << 32, 1 << 32,
@@ -8438,7 +8438,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_ror_epi64() {
+    const fn test_mm512_mask_ror_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0,  1 << 32, 1 << 32, 1 << 32,
@@ -8456,7 +8456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_ror_epi64() {
+    const fn test_mm512_maskz_ror_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8470,7 +8470,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_ror_epi64() {
+    const fn test_mm256_ror_epi64() {
         let a = _mm256_set_epi64x(1 << 0, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_ror_epi64::<1>(a);
         let e = _mm256_set_epi64x(1 << 63, 1 << 31, 1 << 31, 1 << 31);
@@ -8478,7 +8478,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_ror_epi64() {
+    const fn test_mm256_mask_ror_epi64() {
         let a = _mm256_set_epi64x(1 << 0, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_mask_ror_epi64::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -8488,7 +8488,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_ror_epi64() {
+    const fn test_mm256_maskz_ror_epi64() {
         let a = _mm256_set_epi64x(1 << 0, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_maskz_ror_epi64::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -8498,7 +8498,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_ror_epi64() {
+    const fn test_mm_ror_epi64() {
         let a = _mm_set_epi64x(1 << 0, 1 << 32);
         let r = _mm_ror_epi64::<1>(a);
         let e = _mm_set_epi64x(1 << 63, 1 << 31);
@@ -8506,7 +8506,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_ror_epi64() {
+    const fn test_mm_mask_ror_epi64() {
         let a = _mm_set_epi64x(1 << 0, 1 << 32);
         let r = _mm_mask_ror_epi64::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -8516,7 +8516,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_ror_epi64() {
+    const fn test_mm_maskz_ror_epi64() {
         let a = _mm_set_epi64x(1 << 0, 1 << 32);
         let r = _mm_maskz_ror_epi64::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -8526,7 +8526,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_slli_epi64() {
+    const fn test_mm512_slli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -8542,7 +8542,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_slli_epi64() {
+    const fn test_mm512_mask_slli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -8560,7 +8560,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_slli_epi64() {
+    const fn test_mm512_maskz_slli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8574,7 +8574,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_slli_epi64() {
+    const fn test_mm256_mask_slli_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_mask_slli_epi64::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -8584,7 +8584,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_slli_epi64() {
+    const fn test_mm256_maskz_slli_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let r = _mm256_maskz_slli_epi64::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -8594,7 +8594,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_slli_epi64() {
+    const fn test_mm_mask_slli_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let r = _mm_mask_slli_epi64::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -8604,7 +8604,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_slli_epi64() {
+    const fn test_mm_maskz_slli_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let r = _mm_maskz_slli_epi64::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -8614,7 +8614,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srli_epi64() {
+    const fn test_mm512_srli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0, 1 << 32, 1 << 32, 1 << 32,
@@ -8630,7 +8630,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srli_epi64() {
+    const fn test_mm512_mask_srli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0, 1 << 32, 1 << 32, 1 << 32,
@@ -8648,7 +8648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srli_epi64() {
+    const fn test_mm512_maskz_srli_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8662,7 +8662,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srli_epi64() {
+    const fn test_mm256_mask_srli_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let r = _mm256_mask_srli_epi64::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -8672,7 +8672,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srli_epi64() {
+    const fn test_mm256_maskz_srli_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let r = _mm256_maskz_srli_epi64::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -8682,7 +8682,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srli_epi64() {
+    const fn test_mm_mask_srli_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let r = _mm_mask_srli_epi64::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -8692,7 +8692,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srli_epi64() {
+    const fn test_mm_maskz_srli_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let r = _mm_maskz_srli_epi64::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -8702,7 +8702,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rolv_epi64() {
+    const fn test_mm512_rolv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 63, 1 << 32, 1 << 32,
@@ -8719,7 +8719,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rolv_epi64() {
+    const fn test_mm512_mask_rolv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 63, 1 << 32, 1 << 32,
@@ -8738,7 +8738,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rolv_epi64() {
+    const fn test_mm512_maskz_rolv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8753,7 +8753,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rolv_epi64() {
+    const fn test_mm256_rolv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 63, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_rolv_epi64(a, b);
@@ -8762,7 +8762,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rolv_epi64() {
+    const fn test_mm256_mask_rolv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 63, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_rolv_epi64(a, 0, a, b);
@@ -8773,7 +8773,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rolv_epi64() {
+    const fn test_mm256_maskz_rolv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 63, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_rolv_epi64(0, a, b);
@@ -8784,7 +8784,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rolv_epi64() {
+    const fn test_mm_rolv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 63);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_rolv_epi64(a, b);
@@ -8793,7 +8793,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rolv_epi64() {
+    const fn test_mm_mask_rolv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 63);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_mask_rolv_epi64(a, 0, a, b);
@@ -8804,7 +8804,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rolv_epi64() {
+    const fn test_mm_maskz_rolv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 63);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_rolv_epi64(0, a, b);
@@ -8815,7 +8815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_rorv_epi64() {
+    const fn test_mm512_rorv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 0, 1 << 32, 1 << 32,
@@ -8832,7 +8832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_rorv_epi64() {
+    const fn test_mm512_mask_rorv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 0, 1 << 32, 1 << 32,
@@ -8851,7 +8851,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_rorv_epi64() {
+    const fn test_mm512_maskz_rorv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8866,7 +8866,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_rorv_epi64() {
+    const fn test_mm256_rorv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 0, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_rorv_epi64(a, b);
@@ -8875,7 +8875,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_rorv_epi64() {
+    const fn test_mm256_mask_rorv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 0, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_rorv_epi64(a, 0, a, b);
@@ -8886,7 +8886,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_rorv_epi64() {
+    const fn test_mm256_maskz_rorv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 0, 1 << 32, 1 << 32);
         let b = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_rorv_epi64(0, a, b);
@@ -8897,7 +8897,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_rorv_epi64() {
+    const fn test_mm_rorv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 0);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_rorv_epi64(a, b);
@@ -8906,7 +8906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_rorv_epi64() {
+    const fn test_mm_mask_rorv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 0);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_mask_rorv_epi64(a, 0, a, b);
@@ -8917,7 +8917,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_rorv_epi64() {
+    const fn test_mm_maskz_rorv_epi64() {
         let a = _mm_set_epi64x(1 << 32, 1 << 0);
         let b = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_rorv_epi64(0, a, b);
@@ -8928,7 +8928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_sllv_epi64() {
+    const fn test_mm512_sllv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 63, 1 << 32, 1 << 32,
@@ -8945,7 +8945,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_sllv_epi64() {
+    const fn test_mm512_mask_sllv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 63, 1 << 32,
@@ -8964,7 +8964,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_sllv_epi64() {
+    const fn test_mm512_maskz_sllv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -8979,7 +8979,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_sllv_epi64() {
+    const fn test_mm256_mask_sllv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 32, 1 << 63, 1 << 32);
         let count = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_sllv_epi64(a, 0, a, count);
@@ -8990,7 +8990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_sllv_epi64() {
+    const fn test_mm256_maskz_sllv_epi64() {
         let a = _mm256_set_epi64x(1 << 32, 1 << 32, 1 << 63, 1 << 32);
         let count = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_sllv_epi64(0, a, count);
@@ -9001,7 +9001,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_sllv_epi64() {
+    const fn test_mm_mask_sllv_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let count = _mm_set_epi64x(2, 3);
         let r = _mm_mask_sllv_epi64(a, 0, a, count);
@@ -9012,7 +9012,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_sllv_epi64() {
+    const fn test_mm_maskz_sllv_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let count = _mm_set_epi64x(2, 3);
         let r = _mm_maskz_sllv_epi64(0, a, count);
@@ -9023,7 +9023,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srlv_epi64() {
+    const fn test_mm512_srlv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 0, 1 << 32, 1 << 32,
@@ -9040,7 +9040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srlv_epi64() {
+    const fn test_mm512_mask_srlv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 0, 1 << 32, 1 << 32,
@@ -9059,7 +9059,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srlv_epi64() {
+    const fn test_mm512_maskz_srlv_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -9074,7 +9074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srlv_epi64() {
+    const fn test_mm256_mask_srlv_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_mask_srlv_epi64(a, 0, a, count);
@@ -9085,7 +9085,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srlv_epi64() {
+    const fn test_mm256_maskz_srlv_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_srlv_epi64(0, a, count);
@@ -9096,7 +9096,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srlv_epi64() {
+    const fn test_mm_mask_srlv_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set1_epi64x(1);
         let r = _mm_mask_srlv_epi64(a, 0, a, count);
@@ -9107,7 +9107,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srlv_epi64() {
+    const fn test_mm_maskz_srlv_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set1_epi64x(1);
         let r = _mm_maskz_srlv_epi64(0, a, count);
@@ -9118,7 +9118,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sll_epi64() {
+    fn test_mm512_sll_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -9138,7 +9138,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sll_epi64() {
+    fn test_mm512_mask_sll_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 63, 1 << 32, 1 << 32, 1 << 32,
@@ -9157,7 +9157,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sll_epi64() {
+    fn test_mm512_maskz_sll_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -9172,7 +9172,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sll_epi64() {
+    fn test_mm256_mask_sll_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_mask_sll_epi64(a, 0, a, count);
@@ -9183,7 +9183,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sll_epi64() {
+    fn test_mm256_maskz_sll_epi64() {
         let a = _mm256_set_epi64x(1 << 63, 1 << 32, 1 << 32, 1 << 32);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_maskz_sll_epi64(0, a, count);
@@ -9194,7 +9194,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sll_epi64() {
+    fn test_mm_mask_sll_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_mask_sll_epi64(a, 0, a, count);
@@ -9205,7 +9205,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sll_epi64() {
+    fn test_mm_maskz_sll_epi64() {
         let a = _mm_set_epi64x(1 << 63, 1 << 32);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_sll_epi64(0, a, count);
@@ -9216,7 +9216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_srl_epi64() {
+    fn test_mm512_srl_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0, 1 << 32, 1 << 32, 1 << 32,
@@ -9233,7 +9233,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_srl_epi64() {
+    fn test_mm512_mask_srl_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 0, 1 << 32, 1 << 32, 1 << 32,
@@ -9252,7 +9252,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_srl_epi64() {
+    fn test_mm512_maskz_srl_epi64() {
         #[rustfmt::skip]
         let a = _mm512_set_epi64(
             1 << 32, 1 << 32, 1 << 32, 1 << 32,
@@ -9267,7 +9267,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_srl_epi64() {
+    fn test_mm256_mask_srl_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_mask_srl_epi64(a, 0, a, count);
@@ -9278,7 +9278,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_srl_epi64() {
+    fn test_mm256_maskz_srl_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_maskz_srl_epi64(0, a, count);
@@ -9289,7 +9289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_srl_epi64() {
+    fn test_mm_mask_srl_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_mask_srl_epi64(a, 0, a, count);
@@ -9300,7 +9300,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_srl_epi64() {
+    fn test_mm_maskz_srl_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_srl_epi64(0, a, count);
@@ -9311,7 +9311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_sra_epi64() {
+    fn test_mm512_sra_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm_set_epi64x(0, 2);
         let r = _mm512_sra_epi64(a, count);
@@ -9320,7 +9320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_sra_epi64() {
+    fn test_mm512_mask_sra_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm_set_epi64x(0, 2);
         let r = _mm512_mask_sra_epi64(a, 0, a, count);
@@ -9331,7 +9331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_sra_epi64() {
+    fn test_mm512_maskz_sra_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm_set_epi64x(0, 2);
         let r = _mm512_maskz_sra_epi64(0, a, count);
@@ -9342,7 +9342,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_sra_epi64() {
+    fn test_mm256_sra_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_sra_epi64(a, count);
@@ -9351,7 +9351,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_sra_epi64() {
+    fn test_mm256_mask_sra_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_mask_sra_epi64(a, 0, a, count);
@@ -9362,7 +9362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_sra_epi64() {
+    fn test_mm256_maskz_sra_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm256_maskz_sra_epi64(0, a, count);
@@ -9373,7 +9373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_sra_epi64() {
+    fn test_mm_sra_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_sra_epi64(a, count);
@@ -9382,7 +9382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_sra_epi64() {
+    fn test_mm_mask_sra_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_mask_sra_epi64(a, 0, a, count);
@@ -9393,7 +9393,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_sra_epi64() {
+    fn test_mm_maskz_sra_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_sra_epi64(0, a, count);
@@ -9404,7 +9404,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srav_epi64() {
+    const fn test_mm512_srav_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm512_set_epi64(2, 2, 0, 0, 0, 0, 2, 1);
         let r = _mm512_srav_epi64(a, count);
@@ -9413,7 +9413,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srav_epi64() {
+    const fn test_mm512_mask_srav_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm512_set_epi64(2, 2, 0, 0, 0, 0, 2, 1);
         let r = _mm512_mask_srav_epi64(a, 0, a, count);
@@ -9424,7 +9424,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srav_epi64() {
+    const fn test_mm512_maskz_srav_epi64() {
         let a = _mm512_set_epi64(1, -8, 0, 0, 0, 0, 15, -16);
         let count = _mm512_set_epi64(2, 2, 0, 0, 0, 0, 2, 1);
         let r = _mm512_maskz_srav_epi64(0, a, count);
@@ -9435,7 +9435,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_srav_epi64() {
+    const fn test_mm256_srav_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_srav_epi64(a, count);
@@ -9444,7 +9444,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srav_epi64() {
+    const fn test_mm256_mask_srav_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_mask_srav_epi64(a, 0, a, count);
@@ -9455,7 +9455,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srav_epi64() {
+    const fn test_mm256_maskz_srav_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let count = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_srav_epi64(0, a, count);
@@ -9466,7 +9466,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_srav_epi64() {
+    const fn test_mm_srav_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set1_epi64x(1);
         let r = _mm_srav_epi64(a, count);
@@ -9475,7 +9475,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srav_epi64() {
+    const fn test_mm_mask_srav_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set1_epi64x(1);
         let r = _mm_mask_srav_epi64(a, 0, a, count);
@@ -9486,7 +9486,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srav_epi64() {
+    const fn test_mm_maskz_srav_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let count = _mm_set1_epi64x(1);
         let r = _mm_maskz_srav_epi64(0, a, count);
@@ -9497,7 +9497,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_srai_epi64() {
+    const fn test_mm512_srai_epi64() {
         let a = _mm512_set_epi64(1, -4, 15, 0, 0, 0, 0, -16);
         let r = _mm512_srai_epi64::<2>(a);
         let e = _mm512_set_epi64(0, -1, 3, 0, 0, 0, 0, -4);
@@ -9505,7 +9505,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_srai_epi64() {
+    const fn test_mm512_mask_srai_epi64() {
         let a = _mm512_set_epi64(1, -4, 15, 0, 0, 0, 0, -16);
         let r = _mm512_mask_srai_epi64::<2>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -9515,7 +9515,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_srai_epi64() {
+    const fn test_mm512_maskz_srai_epi64() {
         let a = _mm512_set_epi64(1, -4, 15, 0, 0, 0, 0, -16);
         let r = _mm512_maskz_srai_epi64::<2>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -9525,7 +9525,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_srai_epi64() {
+    const fn test_mm256_srai_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let r = _mm256_srai_epi64::<1>(a);
         let e = _mm256_set_epi64x(1 << 4, 0, 0, 0);
@@ -9533,7 +9533,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_srai_epi64() {
+    const fn test_mm256_mask_srai_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let r = _mm256_mask_srai_epi64::<1>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -9543,7 +9543,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_srai_epi64() {
+    const fn test_mm256_maskz_srai_epi64() {
         let a = _mm256_set_epi64x(1 << 5, 0, 0, 0);
         let r = _mm256_maskz_srai_epi64::<1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -9553,7 +9553,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_srai_epi64() {
+    const fn test_mm_srai_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let r = _mm_srai_epi64::<1>(a);
         let e = _mm_set_epi64x(1 << 4, 0);
@@ -9561,7 +9561,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_srai_epi64() {
+    const fn test_mm_mask_srai_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let r = _mm_mask_srai_epi64::<1>(a, 0, a);
         assert_eq_m128i(r, a);
@@ -9571,7 +9571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_srai_epi64() {
+    const fn test_mm_maskz_srai_epi64() {
         let a = _mm_set_epi64x(1 << 5, 0);
         let r = _mm_maskz_srai_epi64::<1>(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -9581,7 +9581,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_permute_pd() {
+    const fn test_mm512_permute_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_permute_pd::<0b11_11_11_11>(a);
         let e = _mm512_setr_pd(1., 1., 3., 3., 5., 5., 7., 7.);
@@ -9589,7 +9589,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_permute_pd() {
+    const fn test_mm512_mask_permute_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_mask_permute_pd::<0b11_11_11_11>(a, 0, a);
         assert_eq_m512d(r, a);
@@ -9599,7 +9599,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_permute_pd() {
+    const fn test_mm512_maskz_permute_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_maskz_permute_pd::<0b11_11_11_11>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -9609,7 +9609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_permute_pd() {
+    const fn test_mm256_mask_permute_pd() {
         let a = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_mask_permute_pd::<0b11_11>(a, 0, a);
         assert_eq_m256d(r, a);
@@ -9619,7 +9619,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_permute_pd() {
+    const fn test_mm256_maskz_permute_pd() {
         let a = _mm256_set_pd(3., 2., 1., 0.);
         let r = _mm256_maskz_permute_pd::<0b11_11>(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -9629,7 +9629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_permute_pd() {
+    const fn test_mm_mask_permute_pd() {
         let a = _mm_set_pd(1., 0.);
         let r = _mm_mask_permute_pd::<0b11>(a, 0, a);
         assert_eq_m128d(r, a);
@@ -9639,7 +9639,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_permute_pd() {
+    const fn test_mm_maskz_permute_pd() {
         let a = _mm_set_pd(1., 0.);
         let r = _mm_maskz_permute_pd::<0b11>(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -9649,7 +9649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_permutex_epi64() {
+    const fn test_mm512_permutex_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_permutex_epi64::<0b11_11_11_11>(a);
         let e = _mm512_setr_epi64(3, 3, 3, 3, 7, 7, 7, 7);
@@ -9657,7 +9657,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_permutex_epi64() {
+    const fn test_mm512_mask_permutex_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_mask_permutex_epi64::<0b11_11_11_11>(a, 0, a);
         assert_eq_m512i(r, a);
@@ -9667,7 +9667,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_permutex_epi64() {
+    const fn test_mm512_maskz_permutex_epi64() {
         let a = _mm512_setr_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_maskz_permutex_epi64::<0b11_11_11_11>(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -9677,7 +9677,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_permutex_epi64() {
+    const fn test_mm256_permutex_epi64() {
         let a = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_permutex_epi64::<0b11_11_11_11>(a);
         let e = _mm256_set_epi64x(3, 3, 3, 3);
@@ -9685,7 +9685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_permutex_epi64() {
+    const fn test_mm256_mask_permutex_epi64() {
         let a = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_mask_permutex_epi64::<0b11_11_11_11>(a, 0, a);
         assert_eq_m256i(r, a);
@@ -9695,7 +9695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_permutex_epi64() {
+    const fn test_mm256_maskz_permutex_epi64() {
         let a = _mm256_set_epi64x(3, 2, 1, 0);
         let r = _mm256_maskz_permutex_epi64::<0b11_11_11_11>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -9705,7 +9705,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_permutex_pd() {
+    const fn test_mm512_permutex_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_permutex_pd::<0b11_11_11_11>(a);
         let e = _mm512_setr_pd(3., 3., 3., 3., 7., 7., 7., 7.);
@@ -9713,7 +9713,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_permutex_pd() {
+    const fn test_mm512_mask_permutex_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_mask_permutex_pd::<0b11_11_11_11>(a, 0, a);
         assert_eq_m512d(r, a);
@@ -9723,7 +9723,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_permutex_pd() {
+    const fn test_mm512_maskz_permutex_pd() {
         let a = _mm512_setr_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_maskz_permutex_pd::<0b11_11_11_11>(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -9733,7 +9733,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_permutex_pd() {
+    const fn test_mm256_permutex_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_permutex_pd::<0b11_11_11_11>(a);
         let e = _mm256_set_pd(0., 0., 0., 0.);
@@ -9741,7 +9741,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_permutex_pd() {
+    const fn test_mm256_mask_permutex_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_mask_permutex_pd::<0b11_11_11_11>(a, 0, a);
         assert_eq_m256d(r, a);
@@ -9751,7 +9751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_permutex_pd() {
+    const fn test_mm256_maskz_permutex_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_maskz_permutex_pd::<0b11_11_11_11>(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -9761,7 +9761,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutevar_pd() {
+    fn test_mm512_permutevar_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_set1_epi64(0b1);
         let r = _mm512_permutevar_pd(a, b);
@@ -9770,7 +9770,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutevar_pd() {
+    fn test_mm512_mask_permutevar_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_set1_epi64(0b1);
         let r = _mm512_mask_permutevar_pd(a, 0, a, b);
@@ -9781,7 +9781,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutevar_pd() {
+    fn test_mm512_maskz_permutevar_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let b = _mm512_set1_epi64(0b1);
         let r = _mm512_maskz_permutevar_pd(0, a, b);
@@ -9792,7 +9792,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutevar_pd() {
+    fn test_mm256_mask_permutevar_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set1_epi64x(0b1);
         let r = _mm256_mask_permutevar_pd(a, 0, a, b);
@@ -9803,7 +9803,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutevar_pd() {
+    fn test_mm256_maskz_permutevar_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let b = _mm256_set1_epi64x(0b1);
         let r = _mm256_maskz_permutevar_pd(0, a, b);
@@ -9814,7 +9814,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutevar_pd() {
+    fn test_mm_mask_permutevar_pd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set1_epi64x(0b1);
         let r = _mm_mask_permutevar_pd(a, 0, a, b);
@@ -9825,7 +9825,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutevar_pd() {
+    fn test_mm_maskz_permutevar_pd() {
         let a = _mm_set_pd(0., 1.);
         let b = _mm_set1_epi64x(0b1);
         let r = _mm_maskz_permutevar_pd(0, a, b);
@@ -9836,7 +9836,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutexvar_epi64() {
+    fn test_mm512_permutexvar_epi64() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_permutexvar_epi64(idx, a);
@@ -9845,7 +9845,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutexvar_epi64() {
+    fn test_mm512_mask_permutexvar_epi64() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_mask_permutexvar_epi64(a, 0, idx, a);
@@ -9856,7 +9856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutexvar_epi64() {
+    fn test_mm512_maskz_permutexvar_epi64() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_maskz_permutexvar_epi64(0, idx, a);
@@ -9867,7 +9867,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutexvar_epi64() {
+    fn test_mm256_permutexvar_epi64() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_permutexvar_epi64(idx, a);
@@ -9876,7 +9876,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_epi64() {
+    fn test_mm256_mask_permutexvar_epi64() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_permutexvar_epi64(a, 0, idx, a);
@@ -9887,7 +9887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_epi64() {
+    fn test_mm256_maskz_permutexvar_epi64() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_permutexvar_epi64(0, idx, a);
@@ -9898,7 +9898,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutexvar_pd() {
+    fn test_mm512_permutexvar_pd() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_permutexvar_pd(idx, a);
@@ -9907,7 +9907,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutexvar_pd() {
+    fn test_mm512_mask_permutexvar_pd() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_mask_permutexvar_pd(a, 0, idx, a);
@@ -9918,7 +9918,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutexvar_pd() {
+    fn test_mm512_maskz_permutexvar_pd() {
         let idx = _mm512_set1_epi64(1);
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_maskz_permutexvar_pd(0, idx, a);
@@ -9929,7 +9929,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutexvar_pd() {
+    fn test_mm256_permutexvar_pd() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_permutexvar_pd(idx, a);
@@ -9938,7 +9938,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutexvar_pd() {
+    fn test_mm256_mask_permutexvar_pd() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_mask_permutexvar_pd(a, 0, idx, a);
@@ -9949,7 +9949,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutexvar_pd() {
+    fn test_mm256_maskz_permutexvar_pd() {
         let idx = _mm256_set1_epi64x(1);
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_maskz_permutexvar_pd(0, idx, a);
@@ -9960,7 +9960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutex2var_epi64() {
+    fn test_mm512_permutex2var_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_epi64(100);
@@ -9970,7 +9970,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutex2var_epi64() {
+    fn test_mm512_mask_permutex2var_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_epi64(100);
@@ -9982,7 +9982,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutex2var_epi64() {
+    fn test_mm512_maskz_permutex2var_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_epi64(100);
@@ -9994,7 +9994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask2_permutex2var_epi64() {
+    fn test_mm512_mask2_permutex2var_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let idx = _mm512_set_epi64(1000, 1 << 3, 2000, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_epi64(100);
@@ -10006,7 +10006,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutex2var_epi64() {
+    fn test_mm256_permutex2var_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_epi64x(100);
@@ -10016,7 +10016,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_epi64() {
+    fn test_mm256_mask_permutex2var_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_epi64x(100);
@@ -10028,7 +10028,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_epi64() {
+    fn test_mm256_maskz_permutex2var_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_epi64x(100);
@@ -10040,7 +10040,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_epi64() {
+    fn test_mm256_mask2_permutex2var_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_epi64x(100);
@@ -10052,7 +10052,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_permutex2var_epi64() {
+    fn test_mm_permutex2var_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_epi64x(100);
@@ -10062,7 +10062,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_epi64() {
+    fn test_mm_mask_permutex2var_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_epi64x(100);
@@ -10074,7 +10074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_epi64() {
+    fn test_mm_maskz_permutex2var_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_epi64x(100);
@@ -10086,7 +10086,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_epi64() {
+    fn test_mm_mask2_permutex2var_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_epi64x(100);
@@ -10098,7 +10098,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_permutex2var_pd() {
+    fn test_mm512_permutex2var_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_pd(100.);
@@ -10108,7 +10108,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_permutex2var_pd() {
+    fn test_mm512_mask_permutex2var_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_pd(100.);
@@ -10120,7 +10120,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_permutex2var_pd() {
+    fn test_mm512_maskz_permutex2var_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_pd(100.);
@@ -10132,7 +10132,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask2_permutex2var_pd() {
+    fn test_mm512_mask2_permutex2var_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let idx = _mm512_set_epi64(1, 1 << 3, 2, 1 << 3, 3, 1 << 3, 4, 1 << 3);
         let b = _mm512_set1_pd(100.);
@@ -10144,7 +10144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_permutex2var_pd() {
+    fn test_mm256_permutex2var_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_pd(100.);
@@ -10154,7 +10154,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_permutex2var_pd() {
+    fn test_mm256_mask_permutex2var_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_pd(100.);
@@ -10166,7 +10166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_permutex2var_pd() {
+    fn test_mm256_maskz_permutex2var_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_pd(100.);
@@ -10178,7 +10178,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask2_permutex2var_pd() {
+    fn test_mm256_mask2_permutex2var_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let idx = _mm256_set_epi64x(1, 1 << 2, 2, 1 << 2);
         let b = _mm256_set1_pd(100.);
@@ -10190,7 +10190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_permutex2var_pd() {
+    fn test_mm_permutex2var_pd() {
         let a = _mm_set_pd(0., 1.);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_pd(100.);
@@ -10200,7 +10200,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_permutex2var_pd() {
+    fn test_mm_mask_permutex2var_pd() {
         let a = _mm_set_pd(0., 1.);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_pd(100.);
@@ -10212,7 +10212,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_permutex2var_pd() {
+    fn test_mm_maskz_permutex2var_pd() {
         let a = _mm_set_pd(0., 1.);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_pd(100.);
@@ -10224,7 +10224,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask2_permutex2var_pd() {
+    fn test_mm_mask2_permutex2var_pd() {
         let a = _mm_set_pd(0., 1.);
         let idx = _mm_set_epi64x(1, 1 << 1);
         let b = _mm_set1_pd(100.);
@@ -10236,7 +10236,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_pd() {
+    const fn test_mm256_mask_shuffle_pd() {
         let a = _mm256_set_pd(1., 4., 5., 8.);
         let b = _mm256_set_pd(2., 3., 6., 7.);
         let r = _mm256_mask_shuffle_pd::<0b11_11_11_11>(a, 0, a, b);
@@ -10247,7 +10247,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_pd() {
+    const fn test_mm256_maskz_shuffle_pd() {
         let a = _mm256_set_pd(1., 4., 5., 8.);
         let b = _mm256_set_pd(2., 3., 6., 7.);
         let r = _mm256_maskz_shuffle_pd::<0b11_11_11_11>(0, a, b);
@@ -10258,7 +10258,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_shuffle_pd() {
+    const fn test_mm_mask_shuffle_pd() {
         let a = _mm_set_pd(1., 4.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_mask_shuffle_pd::<0b11_11_11_11>(a, 0, a, b);
@@ -10269,7 +10269,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_shuffle_pd() {
+    const fn test_mm_maskz_shuffle_pd() {
         let a = _mm_set_pd(1., 4.);
         let b = _mm_set_pd(2., 3.);
         let r = _mm_maskz_shuffle_pd::<0b11_11_11_11>(0, a, b);
@@ -10280,7 +10280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_i64x2() {
+    const fn test_mm512_shuffle_i64x2() {
         let a = _mm512_setr_epi64(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi64(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_shuffle_i64x2::<0b00_00_00_00>(a, b);
@@ -10289,7 +10289,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_i64x2() {
+    const fn test_mm512_mask_shuffle_i64x2() {
         let a = _mm512_setr_epi64(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi64(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_mask_shuffle_i64x2::<0b00_00_00_00>(a, 0, a, b);
@@ -10300,7 +10300,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_i64x2() {
+    const fn test_mm512_maskz_shuffle_i64x2() {
         let a = _mm512_setr_epi64(1, 4, 5, 8, 9, 12, 13, 16);
         let b = _mm512_setr_epi64(2, 3, 6, 7, 10, 11, 14, 15);
         let r = _mm512_maskz_shuffle_i64x2::<0b00_00_00_00>(0, a, b);
@@ -10311,7 +10311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_shuffle_i64x2() {
+    const fn test_mm256_shuffle_i64x2() {
         let a = _mm256_set_epi64x(1, 4, 5, 8);
         let b = _mm256_set_epi64x(2, 3, 6, 7);
         let r = _mm256_shuffle_i64x2::<0b00>(a, b);
@@ -10320,7 +10320,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_i64x2() {
+    const fn test_mm256_mask_shuffle_i64x2() {
         let a = _mm256_set_epi64x(1, 4, 5, 8);
         let b = _mm256_set_epi64x(2, 3, 6, 7);
         let r = _mm256_mask_shuffle_i64x2::<0b00>(a, 0, a, b);
@@ -10331,7 +10331,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_i64x2() {
+    const fn test_mm256_maskz_shuffle_i64x2() {
         let a = _mm256_set_epi64x(1, 4, 5, 8);
         let b = _mm256_set_epi64x(2, 3, 6, 7);
         let r = _mm256_maskz_shuffle_i64x2::<0b00>(0, a, b);
@@ -10342,7 +10342,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_shuffle_f64x2() {
+    const fn test_mm512_shuffle_f64x2() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm512_shuffle_f64x2::<0b00_00_00_00>(a, b);
@@ -10351,7 +10351,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_shuffle_f64x2() {
+    const fn test_mm512_mask_shuffle_f64x2() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm512_mask_shuffle_f64x2::<0b00_00_00_00>(a, 0, a, b);
@@ -10362,7 +10362,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_shuffle_f64x2() {
+    const fn test_mm512_maskz_shuffle_f64x2() {
         let a = _mm512_setr_pd(1., 4., 5., 8., 9., 12., 13., 16.);
         let b = _mm512_setr_pd(2., 3., 6., 7., 10., 11., 14., 15.);
         let r = _mm512_maskz_shuffle_f64x2::<0b00_00_00_00>(0, a, b);
@@ -10373,7 +10373,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_shuffle_f64x2() {
+    const fn test_mm256_shuffle_f64x2() {
         let a = _mm256_set_pd(1., 4., 5., 8.);
         let b = _mm256_set_pd(2., 3., 6., 7.);
         let r = _mm256_shuffle_f64x2::<0b00>(a, b);
@@ -10382,7 +10382,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_shuffle_f64x2() {
+    const fn test_mm256_mask_shuffle_f64x2() {
         let a = _mm256_set_pd(1., 4., 5., 8.);
         let b = _mm256_set_pd(2., 3., 6., 7.);
         let r = _mm256_mask_shuffle_f64x2::<0b00>(a, 0, a, b);
@@ -10393,7 +10393,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_shuffle_f64x2() {
+    const fn test_mm256_maskz_shuffle_f64x2() {
         let a = _mm256_set_pd(1., 4., 5., 8.);
         let b = _mm256_set_pd(2., 3., 6., 7.);
         let r = _mm256_maskz_shuffle_f64x2::<0b00>(0, a, b);
@@ -10404,7 +10404,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_movedup_pd() {
+    const fn test_mm512_movedup_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_movedup_pd(a);
         let e = _mm512_setr_pd(1., 1., 3., 3., 5., 5., 7., 7.);
@@ -10412,7 +10412,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_movedup_pd() {
+    const fn test_mm512_mask_movedup_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_mask_movedup_pd(a, 0, a);
         assert_eq_m512d(r, a);
@@ -10422,7 +10422,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_movedup_pd() {
+    const fn test_mm512_maskz_movedup_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_movedup_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -10432,7 +10432,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_movedup_pd() {
+    const fn test_mm256_mask_movedup_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_mask_movedup_pd(a, 0, a);
         assert_eq_m256d(r, a);
@@ -10442,7 +10442,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_movedup_pd() {
+    const fn test_mm256_maskz_movedup_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let r = _mm256_maskz_movedup_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -10452,7 +10452,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_movedup_pd() {
+    const fn test_mm_mask_movedup_pd() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_mask_movedup_pd(a, 0, a);
         assert_eq_m128d(r, a);
@@ -10462,7 +10462,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_movedup_pd() {
+    const fn test_mm_maskz_movedup_pd() {
         let a = _mm_set_pd(1., 2.);
         let r = _mm_maskz_movedup_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -10472,7 +10472,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_inserti64x4() {
+    const fn test_mm512_inserti64x4() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_setr_epi64x(17, 18, 19, 20);
         let r = _mm512_inserti64x4::<1>(a, b);
@@ -10481,7 +10481,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_inserti64x4() {
+    const fn test_mm512_mask_inserti64x4() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_setr_epi64x(17, 18, 19, 20);
         let r = _mm512_mask_inserti64x4::<1>(a, 0, a, b);
@@ -10492,7 +10492,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_inserti64x4() {
+    const fn test_mm512_maskz_inserti64x4() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm256_setr_epi64x(17, 18, 19, 20);
         let r = _mm512_maskz_inserti64x4::<1>(0, a, b);
@@ -10503,7 +10503,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_insertf64x4() {
+    const fn test_mm512_insertf64x4() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_pd(17., 18., 19., 20.);
         let r = _mm512_insertf64x4::<1>(a, b);
@@ -10512,7 +10512,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_insertf64x4() {
+    const fn test_mm512_mask_insertf64x4() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_pd(17., 18., 19., 20.);
         let r = _mm512_mask_insertf64x4::<1>(a, 0, a, b);
@@ -10523,7 +10523,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_insertf64x4() {
+    const fn test_mm512_maskz_insertf64x4() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm256_setr_pd(17., 18., 19., 20.);
         let r = _mm512_maskz_insertf64x4::<1>(0, a, b);
@@ -10534,21 +10534,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd128_pd512() {
+    const fn test_mm512_castpd128_pd512() {
         let a = _mm_setr_pd(17., 18.);
         let r = _mm512_castpd128_pd512(a);
         assert_eq_m128d(_mm512_castpd512_pd128(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd256_pd512() {
+    const fn test_mm512_castpd256_pd512() {
         let a = _mm256_setr_pd(17., 18., 19., 20.);
         let r = _mm512_castpd256_pd512(a);
         assert_eq_m256d(_mm512_castpd512_pd256(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextpd128_pd512() {
+    const fn test_mm512_zextpd128_pd512() {
         let a = _mm_setr_pd(17., 18.);
         let r = _mm512_zextpd128_pd512(a);
         let e = _mm512_setr_pd(17., 18., 0., 0., 0., 0., 0., 0.);
@@ -10556,7 +10556,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextpd256_pd512() {
+    const fn test_mm512_zextpd256_pd512() {
         let a = _mm256_setr_pd(17., 18., 19., 20.);
         let r = _mm512_zextpd256_pd512(a);
         let e = _mm512_setr_pd(17., 18., 19., 20., 0., 0., 0., 0.);
@@ -10564,7 +10564,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd512_pd128() {
+    const fn test_mm512_castpd512_pd128() {
         let a = _mm512_setr_pd(17., 18., -1., -1., -1., -1., -1., -1.);
         let r = _mm512_castpd512_pd128(a);
         let e = _mm_setr_pd(17., 18.);
@@ -10572,7 +10572,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd512_pd256() {
+    const fn test_mm512_castpd512_pd256() {
         let a = _mm512_setr_pd(17., 18., 19., 20., -1., -1., -1., -1.);
         let r = _mm512_castpd512_pd256(a);
         let e = _mm256_setr_pd(17., 18., 19., 20.);
@@ -10580,7 +10580,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd_ps() {
+    const fn test_mm512_castpd_ps() {
         let a = _mm512_set1_pd(1.);
         let r = _mm512_castpd_ps(a);
         let e = _mm512_set_ps(
@@ -10591,7 +10591,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castpd_si512() {
+    const fn test_mm512_castpd_si512() {
         let a = _mm512_set1_pd(1.);
         let r = _mm512_castpd_si512(a);
         let e = _mm512_set_epi32(
@@ -10602,21 +10602,21 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi128_si512() {
+    const fn test_mm512_castsi128_si512() {
         let a = _mm_setr_epi64x(17, 18);
         let r = _mm512_castsi128_si512(a);
         assert_eq_m128i(_mm512_castsi512_si128(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi256_si512() {
+    const fn test_mm512_castsi256_si512() {
         let a = _mm256_setr_epi64x(17, 18, 19, 20);
         let r = _mm512_castsi256_si512(a);
         assert_eq_m256i(_mm512_castsi512_si256(r), a);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextsi128_si512() {
+    const fn test_mm512_zextsi128_si512() {
         let a = _mm_setr_epi64x(17, 18);
         let r = _mm512_zextsi128_si512(a);
         let e = _mm512_setr_epi64(17, 18, 0, 0, 0, 0, 0, 0);
@@ -10624,7 +10624,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_zextsi256_si512() {
+    const fn test_mm512_zextsi256_si512() {
         let a = _mm256_setr_epi64x(17, 18, 19, 20);
         let r = _mm512_zextsi256_si512(a);
         let e = _mm512_setr_epi64(17, 18, 19, 20, 0, 0, 0, 0);
@@ -10632,7 +10632,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi512_si128() {
+    const fn test_mm512_castsi512_si128() {
         let a = _mm512_setr_epi64(17, 18, -1, -1, -1, -1, -1, -1);
         let r = _mm512_castsi512_si128(a);
         let e = _mm_setr_epi64x(17, 18);
@@ -10640,7 +10640,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi512_si256() {
+    const fn test_mm512_castsi512_si256() {
         let a = _mm512_setr_epi64(17, 18, 19, 20, -1, -1, -1, -1);
         let r = _mm512_castsi512_si256(a);
         let e = _mm256_setr_epi64x(17, 18, 19, 20);
@@ -10648,7 +10648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi512_ps() {
+    const fn test_mm512_castsi512_ps() {
         let a = _mm512_set1_epi64(1 << 62);
         let r = _mm512_castsi512_ps(a);
         let e = _mm512_set_ps(
@@ -10658,7 +10658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_castsi512_pd() {
+    const fn test_mm512_castsi512_pd() {
         let a = _mm512_set1_epi64(1 << 62);
         let r = _mm512_castsi512_pd(a);
         let e = _mm512_set_pd(2., 2., 2., 2., 2., 2., 2., 2.);
@@ -10666,7 +10666,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcastq_epi64() {
+    const fn test_mm512_broadcastq_epi64() {
         let a = _mm_setr_epi64x(17, 18);
         let r = _mm512_broadcastq_epi64(a);
         let e = _mm512_set1_epi64(17);
@@ -10674,7 +10674,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcastq_epi64() {
+    const fn test_mm512_mask_broadcastq_epi64() {
         let src = _mm512_set1_epi64(18);
         let a = _mm_setr_epi64x(17, 18);
         let r = _mm512_mask_broadcastq_epi64(src, 0, a);
@@ -10685,7 +10685,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcastq_epi64() {
+    const fn test_mm512_maskz_broadcastq_epi64() {
         let a = _mm_setr_epi64x(17, 18);
         let r = _mm512_maskz_broadcastq_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -10695,7 +10695,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastq_epi64() {
+    const fn test_mm256_mask_broadcastq_epi64() {
         let src = _mm256_set1_epi64x(18);
         let a = _mm_set_epi64x(17, 18);
         let r = _mm256_mask_broadcastq_epi64(src, 0, a);
@@ -10706,7 +10706,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastq_epi64() {
+    const fn test_mm256_maskz_broadcastq_epi64() {
         let a = _mm_set_epi64x(17, 18);
         let r = _mm256_maskz_broadcastq_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -10716,7 +10716,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_broadcastq_epi64() {
+    const fn test_mm_mask_broadcastq_epi64() {
         let src = _mm_set1_epi64x(18);
         let a = _mm_set_epi64x(17, 18);
         let r = _mm_mask_broadcastq_epi64(src, 0, a);
@@ -10727,7 +10727,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_broadcastq_epi64() {
+    const fn test_mm_maskz_broadcastq_epi64() {
         let a = _mm_set_epi64x(17, 18);
         let r = _mm_maskz_broadcastq_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -10737,7 +10737,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcastsd_pd() {
+    const fn test_mm512_broadcastsd_pd() {
         let a = _mm_set_pd(17., 18.);
         let r = _mm512_broadcastsd_pd(a);
         let e = _mm512_set1_pd(18.);
@@ -10745,7 +10745,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcastsd_pd() {
+    const fn test_mm512_mask_broadcastsd_pd() {
         let src = _mm512_set1_pd(18.);
         let a = _mm_set_pd(17., 18.);
         let r = _mm512_mask_broadcastsd_pd(src, 0, a);
@@ -10756,7 +10756,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcastsd_pd() {
+    const fn test_mm512_maskz_broadcastsd_pd() {
         let a = _mm_set_pd(17., 18.);
         let r = _mm512_maskz_broadcastsd_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -10766,7 +10766,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_broadcastsd_pd() {
+    const fn test_mm256_mask_broadcastsd_pd() {
         let src = _mm256_set1_pd(18.);
         let a = _mm_set_pd(17., 18.);
         let r = _mm256_mask_broadcastsd_pd(src, 0, a);
@@ -10777,7 +10777,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_broadcastsd_pd() {
+    const fn test_mm256_maskz_broadcastsd_pd() {
         let a = _mm_set_pd(17., 18.);
         let r = _mm256_maskz_broadcastsd_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -10787,7 +10787,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcast_i64x4() {
+    const fn test_mm512_broadcast_i64x4() {
         let a = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm512_broadcast_i64x4(a);
         let e = _mm512_set_epi64(17, 18, 19, 20, 17, 18, 19, 20);
@@ -10795,7 +10795,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcast_i64x4() {
+    const fn test_mm512_mask_broadcast_i64x4() {
         let src = _mm512_set1_epi64(18);
         let a = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm512_mask_broadcast_i64x4(src, 0, a);
@@ -10806,7 +10806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcast_i64x4() {
+    const fn test_mm512_maskz_broadcast_i64x4() {
         let a = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm512_maskz_broadcast_i64x4(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -10816,7 +10816,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_broadcast_f64x4() {
+    const fn test_mm512_broadcast_f64x4() {
         let a = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm512_broadcast_f64x4(a);
         let e = _mm512_set_pd(17., 18., 19., 20., 17., 18., 19., 20.);
@@ -10824,7 +10824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_broadcast_f64x4() {
+    const fn test_mm512_mask_broadcast_f64x4() {
         let src = _mm512_set1_pd(18.);
         let a = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm512_mask_broadcast_f64x4(src, 0, a);
@@ -10835,7 +10835,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_broadcast_f64x4() {
+    const fn test_mm512_maskz_broadcast_f64x4() {
         let a = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm512_maskz_broadcast_f64x4(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -10845,7 +10845,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_blend_epi64() {
+    const fn test_mm512_mask_blend_epi64() {
         let a = _mm512_set1_epi64(1);
         let b = _mm512_set1_epi64(2);
         let r = _mm512_mask_blend_epi64(0b11110000, a, b);
@@ -10854,7 +10854,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_epi64() {
+    const fn test_mm256_mask_blend_epi64() {
         let a = _mm256_set1_epi64x(1);
         let b = _mm256_set1_epi64x(2);
         let r = _mm256_mask_blend_epi64(0b00001111, a, b);
@@ -10863,7 +10863,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_blend_epi64() {
+    const fn test_mm_mask_blend_epi64() {
         let a = _mm_set1_epi64x(1);
         let b = _mm_set1_epi64x(2);
         let r = _mm_mask_blend_epi64(0b00000011, a, b);
@@ -10872,7 +10872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_blend_pd() {
+    const fn test_mm512_mask_blend_pd() {
         let a = _mm512_set1_pd(1.);
         let b = _mm512_set1_pd(2.);
         let r = _mm512_mask_blend_pd(0b11110000, a, b);
@@ -10881,7 +10881,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_blend_pd() {
+    const fn test_mm256_mask_blend_pd() {
         let a = _mm256_set1_pd(1.);
         let b = _mm256_set1_pd(2.);
         let r = _mm256_mask_blend_pd(0b00001111, a, b);
@@ -10890,7 +10890,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_blend_pd() {
+    const fn test_mm_mask_blend_pd() {
         let a = _mm_set1_pd(1.);
         let b = _mm_set1_pd(2.);
         let r = _mm_mask_blend_pd(0b00000011, a, b);
@@ -10899,7 +10899,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpackhi_epi64() {
+    const fn test_mm512_unpackhi_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_unpackhi_epi64(a, b);
@@ -10908,7 +10908,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpackhi_epi64() {
+    const fn test_mm512_mask_unpackhi_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_mask_unpackhi_epi64(a, 0, a, b);
@@ -10919,7 +10919,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpackhi_epi64() {
+    const fn test_mm512_maskz_unpackhi_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_maskz_unpackhi_epi64(0, a, b);
@@ -10930,7 +10930,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_epi64() {
+    const fn test_mm256_mask_unpackhi_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm256_mask_unpackhi_epi64(a, 0, a, b);
@@ -10941,7 +10941,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_epi64() {
+    const fn test_mm256_maskz_unpackhi_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm256_maskz_unpackhi_epi64(0, a, b);
@@ -10952,7 +10952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_epi64() {
+    const fn test_mm_mask_unpackhi_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(17, 18);
         let r = _mm_mask_unpackhi_epi64(a, 0, a, b);
@@ -10963,7 +10963,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_epi64() {
+    const fn test_mm_maskz_unpackhi_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(17, 18);
         let r = _mm_maskz_unpackhi_epi64(0, a, b);
@@ -10974,7 +10974,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpackhi_pd() {
+    const fn test_mm512_unpackhi_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_unpackhi_pd(a, b);
@@ -10983,7 +10983,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpackhi_pd() {
+    const fn test_mm512_mask_unpackhi_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_mask_unpackhi_pd(a, 0, a, b);
@@ -10994,7 +10994,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpackhi_pd() {
+    const fn test_mm512_maskz_unpackhi_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_maskz_unpackhi_pd(0, a, b);
@@ -11005,7 +11005,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpackhi_pd() {
+    const fn test_mm256_mask_unpackhi_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm256_mask_unpackhi_pd(a, 0, a, b);
@@ -11016,7 +11016,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpackhi_pd() {
+    const fn test_mm256_maskz_unpackhi_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm256_maskz_unpackhi_pd(0, a, b);
@@ -11027,7 +11027,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpackhi_pd() {
+    const fn test_mm_mask_unpackhi_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(17., 18.);
         let r = _mm_mask_unpackhi_pd(a, 0, a, b);
@@ -11038,7 +11038,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpackhi_pd() {
+    const fn test_mm_maskz_unpackhi_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(17., 18.);
         let r = _mm_maskz_unpackhi_pd(0, a, b);
@@ -11049,7 +11049,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpacklo_epi64() {
+    const fn test_mm512_unpacklo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_unpacklo_epi64(a, b);
@@ -11058,7 +11058,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpacklo_epi64() {
+    const fn test_mm512_mask_unpacklo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_mask_unpacklo_epi64(a, 0, a, b);
@@ -11069,7 +11069,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpacklo_epi64() {
+    const fn test_mm512_maskz_unpacklo_epi64() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let b = _mm512_set_epi64(17, 18, 19, 20, 21, 22, 23, 24);
         let r = _mm512_maskz_unpacklo_epi64(0, a, b);
@@ -11080,7 +11080,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_epi64() {
+    const fn test_mm256_mask_unpacklo_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm256_mask_unpacklo_epi64(a, 0, a, b);
@@ -11091,7 +11091,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_epi64() {
+    const fn test_mm256_maskz_unpacklo_epi64() {
         let a = _mm256_set_epi64x(1, 2, 3, 4);
         let b = _mm256_set_epi64x(17, 18, 19, 20);
         let r = _mm256_maskz_unpacklo_epi64(0, a, b);
@@ -11102,7 +11102,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_epi64() {
+    const fn test_mm_mask_unpacklo_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(17, 18);
         let r = _mm_mask_unpacklo_epi64(a, 0, a, b);
@@ -11113,7 +11113,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_epi64() {
+    const fn test_mm_maskz_unpacklo_epi64() {
         let a = _mm_set_epi64x(1, 2);
         let b = _mm_set_epi64x(17, 18);
         let r = _mm_maskz_unpacklo_epi64(0, a, b);
@@ -11124,7 +11124,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_unpacklo_pd() {
+    const fn test_mm512_unpacklo_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_unpacklo_pd(a, b);
@@ -11133,7 +11133,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_unpacklo_pd() {
+    const fn test_mm512_mask_unpacklo_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_mask_unpacklo_pd(a, 0, a, b);
@@ -11144,7 +11144,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_unpacklo_pd() {
+    const fn test_mm512_maskz_unpacklo_pd() {
         let a = _mm512_set_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let b = _mm512_set_pd(17., 18., 19., 20., 21., 22., 23., 24.);
         let r = _mm512_maskz_unpacklo_pd(0, a, b);
@@ -11155,7 +11155,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_unpacklo_pd() {
+    const fn test_mm256_mask_unpacklo_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm256_mask_unpacklo_pd(a, 0, a, b);
@@ -11166,7 +11166,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_unpacklo_pd() {
+    const fn test_mm256_maskz_unpacklo_pd() {
         let a = _mm256_set_pd(1., 2., 3., 4.);
         let b = _mm256_set_pd(17., 18., 19., 20.);
         let r = _mm256_maskz_unpacklo_pd(0, a, b);
@@ -11177,7 +11177,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_unpacklo_pd() {
+    const fn test_mm_mask_unpacklo_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(17., 18.);
         let r = _mm_mask_unpacklo_pd(a, 0, a, b);
@@ -11188,7 +11188,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_unpacklo_pd() {
+    const fn test_mm_maskz_unpacklo_pd() {
         let a = _mm_set_pd(1., 2.);
         let b = _mm_set_pd(17., 18.);
         let r = _mm_maskz_unpacklo_pd(0, a, b);
@@ -11199,7 +11199,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_alignr_epi64() {
+    const fn test_mm512_alignr_epi64() {
         let a = _mm512_set_epi64(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi64(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm512_alignr_epi64::<0>(a, b);
@@ -11212,7 +11212,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_alignr_epi64() {
+    const fn test_mm512_mask_alignr_epi64() {
         let a = _mm512_set_epi64(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi64(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm512_mask_alignr_epi64::<1>(a, 0, a, b);
@@ -11223,7 +11223,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_alignr_epi64() {
+    const fn test_mm512_maskz_alignr_epi64() {
         let a = _mm512_set_epi64(8, 7, 6, 5, 4, 3, 2, 1);
         let b = _mm512_set_epi64(16, 15, 14, 13, 12, 11, 10, 9);
         let r = _mm512_maskz_alignr_epi64::<1>(0, a, b);
@@ -11234,7 +11234,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_alignr_epi64() {
+    const fn test_mm256_alignr_epi64() {
         let a = _mm256_set_epi64x(4, 3, 2, 1);
         let b = _mm256_set_epi64x(8, 7, 6, 5);
         let r = _mm256_alignr_epi64::<0>(a, b);
@@ -11249,7 +11249,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_alignr_epi64() {
+    const fn test_mm256_mask_alignr_epi64() {
         let a = _mm256_set_epi64x(4, 3, 2, 1);
         let b = _mm256_set_epi64x(8, 7, 6, 5);
         let r = _mm256_mask_alignr_epi64::<1>(a, 0, a, b);
@@ -11260,7 +11260,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_alignr_epi64() {
+    const fn test_mm256_maskz_alignr_epi64() {
         let a = _mm256_set_epi64x(4, 3, 2, 1);
         let b = _mm256_set_epi64x(8, 7, 6, 5);
         let r = _mm256_maskz_alignr_epi64::<1>(0, a, b);
@@ -11271,7 +11271,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_alignr_epi64() {
+    const fn test_mm_alignr_epi64() {
         let a = _mm_set_epi64x(2, 1);
         let b = _mm_set_epi64x(4, 3);
         let r = _mm_alignr_epi64::<0>(a, b);
@@ -11280,7 +11280,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_alignr_epi64() {
+    const fn test_mm_mask_alignr_epi64() {
         let a = _mm_set_epi64x(2, 1);
         let b = _mm_set_epi64x(4, 3);
         let r = _mm_mask_alignr_epi64::<1>(a, 0, a, b);
@@ -11291,7 +11291,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_alignr_epi64() {
+    const fn test_mm_maskz_alignr_epi64() {
         let a = _mm_set_epi64x(2, 1);
         let b = _mm_set_epi64x(4, 3);
         let r = _mm_maskz_alignr_epi64::<1>(0, a, b);
@@ -11302,7 +11302,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_and_epi64() {
+    const fn test_mm512_and_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_and_epi64(a, b);
@@ -11311,7 +11311,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_and_epi64() {
+    const fn test_mm512_mask_and_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_mask_and_epi64(a, 0, a, b);
@@ -11322,7 +11322,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_and_epi64() {
+    const fn test_mm512_maskz_and_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_maskz_and_epi64(0, a, b);
@@ -11333,7 +11333,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_and_epi64() {
+    const fn test_mm256_mask_and_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 0);
         let r = _mm256_mask_and_epi64(a, 0, a, b);
@@ -11344,7 +11344,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_and_epi64() {
+    const fn test_mm256_maskz_and_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 0);
         let r = _mm256_maskz_and_epi64(0, a, b);
@@ -11355,7 +11355,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_and_epi64() {
+    const fn test_mm_mask_and_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 0);
         let r = _mm_mask_and_epi64(a, 0, a, b);
@@ -11366,7 +11366,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_and_epi64() {
+    const fn test_mm_maskz_and_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 0);
         let r = _mm_maskz_and_epi64(0, a, b);
@@ -11377,7 +11377,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_and_si512() {
+    const fn test_mm512_and_si512() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_and_epi64(a, b);
@@ -11386,7 +11386,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_or_epi64() {
+    const fn test_mm512_or_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_or_epi64(a, b);
@@ -11399,7 +11399,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_or_epi64() {
+    const fn test_mm512_mask_or_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_mask_or_epi64(a, 0, a, b);
@@ -11414,7 +11414,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_or_epi64() {
+    const fn test_mm512_maskz_or_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_maskz_or_epi64(0, a, b);
@@ -11425,7 +11425,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_or_epi64() {
+    const fn test_mm256_or_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_or_epi64(a, b);
@@ -11434,7 +11434,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_or_epi64() {
+    const fn test_mm256_mask_or_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_mask_or_epi64(a, 0, a, b);
@@ -11445,7 +11445,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_or_epi64() {
+    const fn test_mm256_maskz_or_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_maskz_or_epi64(0, a, b);
@@ -11456,7 +11456,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_or_epi64() {
+    const fn test_mm_or_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_or_epi64(a, b);
@@ -11465,7 +11465,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_or_epi64() {
+    const fn test_mm_mask_or_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_mask_or_epi64(a, 0, a, b);
@@ -11476,7 +11476,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_or_epi64() {
+    const fn test_mm_maskz_or_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_maskz_or_epi64(0, a, b);
@@ -11487,7 +11487,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_or_si512() {
+    const fn test_mm512_or_si512() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_or_epi64(a, b);
@@ -11500,7 +11500,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_xor_epi64() {
+    const fn test_mm512_xor_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_xor_epi64(a, b);
@@ -11509,7 +11509,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_xor_epi64() {
+    const fn test_mm512_mask_xor_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_mask_xor_epi64(a, 0, a, b);
@@ -11520,7 +11520,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_xor_epi64() {
+    const fn test_mm512_maskz_xor_epi64() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_maskz_xor_epi64(0, a, b);
@@ -11531,7 +11531,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_xor_epi64() {
+    const fn test_mm256_xor_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_xor_epi64(a, b);
@@ -11540,7 +11540,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_xor_epi64() {
+    const fn test_mm256_mask_xor_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_mask_xor_epi64(a, 0, a, b);
@@ -11551,7 +11551,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_xor_epi64() {
+    const fn test_mm256_maskz_xor_epi64() {
         let a = _mm256_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm256_set1_epi64x(1 << 13);
         let r = _mm256_maskz_xor_epi64(0, a, b);
@@ -11562,7 +11562,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_xor_epi64() {
+    const fn test_mm_xor_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_xor_epi64(a, b);
@@ -11571,7 +11571,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_xor_epi64() {
+    const fn test_mm_mask_xor_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_mask_xor_epi64(a, 0, a, b);
@@ -11582,7 +11582,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_xor_epi64() {
+    const fn test_mm_maskz_xor_epi64() {
         let a = _mm_set1_epi64x(1 << 0 | 1 << 15);
         let b = _mm_set1_epi64x(1 << 13);
         let r = _mm_maskz_xor_epi64(0, a, b);
@@ -11593,7 +11593,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_xor_si512() {
+    const fn test_mm512_xor_si512() {
         let a = _mm512_set_epi64(1 << 0 | 1 << 15, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let b = _mm512_set_epi64(1 << 13, 0, 0, 0, 0, 0, 0, 1 << 1 | 1 << 2 | 1 << 3);
         let r = _mm512_xor_epi64(a, b);
@@ -11602,7 +11602,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_andnot_epi64() {
+    const fn test_mm512_andnot_epi64() {
         let a = _mm512_set1_epi64(0);
         let b = _mm512_set1_epi64(1 << 3 | 1 << 4);
         let r = _mm512_andnot_epi64(a, b);
@@ -11611,7 +11611,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_andnot_epi64() {
+    const fn test_mm512_mask_andnot_epi64() {
         let a = _mm512_set1_epi64(1 << 1 | 1 << 2);
         let b = _mm512_set1_epi64(1 << 3 | 1 << 4);
         let r = _mm512_mask_andnot_epi64(a, 0, a, b);
@@ -11622,7 +11622,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_andnot_epi64() {
+    const fn test_mm512_maskz_andnot_epi64() {
         let a = _mm512_set1_epi64(1 << 1 | 1 << 2);
         let b = _mm512_set1_epi64(1 << 3 | 1 << 4);
         let r = _mm512_maskz_andnot_epi64(0, a, b);
@@ -11637,7 +11637,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_andnot_epi64() {
+    const fn test_mm256_mask_andnot_epi64() {
         let a = _mm256_set1_epi64x(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi64x(1 << 3 | 1 << 4);
         let r = _mm256_mask_andnot_epi64(a, 0, a, b);
@@ -11648,7 +11648,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_andnot_epi64() {
+    const fn test_mm256_maskz_andnot_epi64() {
         let a = _mm256_set1_epi64x(1 << 1 | 1 << 2);
         let b = _mm256_set1_epi64x(1 << 3 | 1 << 4);
         let r = _mm256_maskz_andnot_epi64(0, a, b);
@@ -11659,7 +11659,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_andnot_epi64() {
+    const fn test_mm_mask_andnot_epi64() {
         let a = _mm_set1_epi64x(1 << 1 | 1 << 2);
         let b = _mm_set1_epi64x(1 << 3 | 1 << 4);
         let r = _mm_mask_andnot_epi64(a, 0, a, b);
@@ -11670,7 +11670,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_andnot_epi64() {
+    const fn test_mm_maskz_andnot_epi64() {
         let a = _mm_set1_epi64x(1 << 1 | 1 << 2);
         let b = _mm_set1_epi64x(1 << 3 | 1 << 4);
         let r = _mm_maskz_andnot_epi64(0, a, b);
@@ -11681,7 +11681,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_andnot_si512() {
+    const fn test_mm512_andnot_si512() {
         let a = _mm512_set1_epi64(0);
         let b = _mm512_set1_epi64(1 << 3 | 1 << 4);
         let r = _mm512_andnot_si512(a, b);
@@ -11690,175 +11690,175 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_add_epi64() {
+    const fn test_mm512_reduce_add_epi64() {
         let a = _mm512_set1_epi64(1);
         let e: i64 = _mm512_reduce_add_epi64(a);
         assert_eq!(8, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_add_epi64() {
+    const fn test_mm512_mask_reduce_add_epi64() {
         let a = _mm512_set1_epi64(1);
         let e: i64 = _mm512_mask_reduce_add_epi64(0b11110000, a);
         assert_eq!(4, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_add_pd() {
+    const fn test_mm512_reduce_add_pd() {
         let a = _mm512_set1_pd(1.);
         let e: f64 = _mm512_reduce_add_pd(a);
         assert_eq!(8., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_add_pd() {
+    const fn test_mm512_mask_reduce_add_pd() {
         let a = _mm512_set1_pd(1.);
         let e: f64 = _mm512_mask_reduce_add_pd(0b11110000, a);
         assert_eq!(4., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_mul_epi64() {
+    const fn test_mm512_reduce_mul_epi64() {
         let a = _mm512_set1_epi64(2);
         let e: i64 = _mm512_reduce_mul_epi64(a);
         assert_eq!(256, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_mul_epi64() {
+    const fn test_mm512_mask_reduce_mul_epi64() {
         let a = _mm512_set1_epi64(2);
         let e: i64 = _mm512_mask_reduce_mul_epi64(0b11110000, a);
         assert_eq!(16, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_mul_pd() {
+    const fn test_mm512_reduce_mul_pd() {
         let a = _mm512_set1_pd(2.);
         let e: f64 = _mm512_reduce_mul_pd(a);
         assert_eq!(256., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_mul_pd() {
+    const fn test_mm512_mask_reduce_mul_pd() {
         let a = _mm512_set1_pd(2.);
         let e: f64 = _mm512_mask_reduce_mul_pd(0b11110000, a);
         assert_eq!(16., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_max_epi64() {
+    const fn test_mm512_reduce_max_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i64 = _mm512_reduce_max_epi64(a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_max_epi64() {
+    const fn test_mm512_mask_reduce_max_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i64 = _mm512_mask_reduce_max_epi64(0b11110000, a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_max_epu64() {
+    const fn test_mm512_reduce_max_epu64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u64 = _mm512_reduce_max_epu64(a);
         assert_eq!(7, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_max_epu64() {
+    const fn test_mm512_mask_reduce_max_epu64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u64 = _mm512_mask_reduce_max_epu64(0b11110000, a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_reduce_max_pd() {
+    fn test_mm512_reduce_max_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let e: f64 = _mm512_reduce_max_pd(a);
         assert_eq!(7., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_reduce_max_pd() {
+    fn test_mm512_mask_reduce_max_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let e: f64 = _mm512_mask_reduce_max_pd(0b11110000, a);
         assert_eq!(3., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_min_epi64() {
+    const fn test_mm512_reduce_min_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i64 = _mm512_reduce_min_epi64(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_min_epi64() {
+    const fn test_mm512_mask_reduce_min_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: i64 = _mm512_mask_reduce_min_epi64(0b11110000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_min_epu64() {
+    const fn test_mm512_reduce_min_epu64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u64 = _mm512_reduce_min_epu64(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_min_epu64() {
+    const fn test_mm512_mask_reduce_min_epu64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let e: u64 = _mm512_mask_reduce_min_epu64(0b11110000, a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_reduce_min_pd() {
+    fn test_mm512_reduce_min_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let e: f64 = _mm512_reduce_min_pd(a);
         assert_eq!(0., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_reduce_min_pd() {
+    fn test_mm512_mask_reduce_min_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let e: f64 = _mm512_mask_reduce_min_pd(0b11110000, a);
         assert_eq!(0., e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_and_epi64() {
+    const fn test_mm512_reduce_and_epi64() {
         let a = _mm512_set_epi64(1, 1, 1, 1, 2, 2, 2, 2);
         let e: i64 = _mm512_reduce_and_epi64(a);
         assert_eq!(0, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_and_epi64() {
+    const fn test_mm512_mask_reduce_and_epi64() {
         let a = _mm512_set_epi64(1, 1, 1, 1, 2, 2, 2, 2);
         let e: i64 = _mm512_mask_reduce_and_epi64(0b11110000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_reduce_or_epi64() {
+    const fn test_mm512_reduce_or_epi64() {
         let a = _mm512_set_epi64(1, 1, 1, 1, 2, 2, 2, 2);
         let e: i64 = _mm512_reduce_or_epi64(a);
         assert_eq!(3, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_reduce_or_epi64() {
+    const fn test_mm512_mask_reduce_or_epi64() {
         let a = _mm512_set_epi64(1, 1, 1, 1, 2, 2, 2, 2);
         let e: i64 = _mm512_mask_reduce_or_epi64(0b11110000, a);
         assert_eq!(1, e);
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_extractf64x4_pd() {
+    const fn test_mm512_extractf64x4_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_extractf64x4_pd::<1>(a);
         let e = _mm256_setr_pd(5., 6., 7., 8.);
@@ -11866,7 +11866,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_extractf64x4_pd() {
+    const fn test_mm512_mask_extractf64x4_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let src = _mm256_set1_pd(100.);
         let r = _mm512_mask_extractf64x4_pd::<1>(src, 0, a);
@@ -11877,7 +11877,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_extractf64x4_pd() {
+    const fn test_mm512_maskz_extractf64x4_pd() {
         let a = _mm512_setr_pd(1., 2., 3., 4., 5., 6., 7., 8.);
         let r = _mm512_maskz_extractf64x4_pd::<1>(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -11887,7 +11887,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_extracti64x4_epi64() {
+    const fn test_mm512_extracti64x4_epi64() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_extracti64x4_epi64::<0x1>(a);
         let e = _mm256_setr_epi64x(5, 6, 7, 8);
@@ -11895,7 +11895,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_extracti64x4_epi64() {
+    const fn test_mm512_mask_extracti64x4_epi64() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm256_set1_epi64x(100);
         let r = _mm512_mask_extracti64x4_epi64::<0x1>(src, 0, a);
@@ -11906,7 +11906,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_extracti64x4_epi64() {
+    const fn test_mm512_maskz_extracti64x4_epi64() {
         let a = _mm512_setr_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_extracti64x4_epi64::<0x1>(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -11916,7 +11916,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_compress_epi64() {
+    fn test_mm512_mask_compress_epi64() {
         let src = _mm512_set1_epi64(200);
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_mask_compress_epi64(src, 0, a);
@@ -11927,7 +11927,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_compress_epi64() {
+    fn test_mm512_maskz_compress_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_maskz_compress_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -11937,7 +11937,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_compress_epi64() {
+    fn test_mm256_mask_compress_epi64() {
         let src = _mm256_set1_epi64x(200);
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_compress_epi64(src, 0, a);
@@ -11948,7 +11948,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_epi64() {
+    fn test_mm256_maskz_compress_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_compress_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -11958,7 +11958,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_compress_epi64() {
+    fn test_mm_mask_compress_epi64() {
         let src = _mm_set1_epi64x(200);
         let a = _mm_set_epi64x(0, 1);
         let r = _mm_mask_compress_epi64(src, 0, a);
@@ -11969,7 +11969,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_compress_epi64() {
+    fn test_mm_maskz_compress_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_compress_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -11979,7 +11979,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_compress_pd() {
+    fn test_mm512_mask_compress_pd() {
         let src = _mm512_set1_pd(200.);
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_mask_compress_pd(src, 0, a);
@@ -11990,7 +11990,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_compress_pd() {
+    fn test_mm512_maskz_compress_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_maskz_compress_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -12000,7 +12000,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_compress_pd() {
+    fn test_mm256_mask_compress_pd() {
         let src = _mm256_set1_pd(200.);
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_mask_compress_pd(src, 0, a);
@@ -12011,7 +12011,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_compress_pd() {
+    fn test_mm256_maskz_compress_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_maskz_compress_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -12021,7 +12021,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_compress_pd() {
+    fn test_mm_mask_compress_pd() {
         let src = _mm_set1_pd(200.);
         let a = _mm_set_pd(0., 1.);
         let r = _mm_mask_compress_pd(src, 0, a);
@@ -12032,7 +12032,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_compress_pd() {
+    fn test_mm_maskz_compress_pd() {
         let a = _mm_set_pd(0., 1.);
         let r = _mm_maskz_compress_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -12042,7 +12042,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_expand_epi64() {
+    fn test_mm512_mask_expand_epi64() {
         let src = _mm512_set1_epi64(200);
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_mask_expand_epi64(src, 0, a);
@@ -12053,7 +12053,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_expand_epi64() {
+    fn test_mm512_maskz_expand_epi64() {
         let a = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
         let r = _mm512_maskz_expand_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -12063,7 +12063,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_expand_epi64() {
+    fn test_mm256_mask_expand_epi64() {
         let src = _mm256_set1_epi64x(200);
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_mask_expand_epi64(src, 0, a);
@@ -12074,7 +12074,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_epi64() {
+    fn test_mm256_maskz_expand_epi64() {
         let a = _mm256_set_epi64x(0, 1, 2, 3);
         let r = _mm256_maskz_expand_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -12084,7 +12084,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_expand_epi64() {
+    fn test_mm_mask_expand_epi64() {
         let src = _mm_set1_epi64x(200);
         let a = _mm_set_epi64x(0, 1);
         let r = _mm_mask_expand_epi64(src, 0, a);
@@ -12095,7 +12095,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_expand_epi64() {
+    fn test_mm_maskz_expand_epi64() {
         let a = _mm_set_epi64x(0, 1);
         let r = _mm_maskz_expand_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -12105,7 +12105,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_mask_expand_pd() {
+    fn test_mm512_mask_expand_pd() {
         let src = _mm512_set1_pd(200.);
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_mask_expand_pd(src, 0, a);
@@ -12116,7 +12116,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm512_maskz_expand_pd() {
+    fn test_mm512_maskz_expand_pd() {
         let a = _mm512_set_pd(0., 1., 2., 3., 4., 5., 6., 7.);
         let r = _mm512_maskz_expand_pd(0, a);
         assert_eq_m512d(r, _mm512_setzero_pd());
@@ -12126,7 +12126,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_mask_expand_pd() {
+    fn test_mm256_mask_expand_pd() {
         let src = _mm256_set1_pd(200.);
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_mask_expand_pd(src, 0, a);
@@ -12137,7 +12137,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm256_maskz_expand_pd() {
+    fn test_mm256_maskz_expand_pd() {
         let a = _mm256_set_pd(0., 1., 2., 3.);
         let r = _mm256_maskz_expand_pd(0, a);
         assert_eq_m256d(r, _mm256_setzero_pd());
@@ -12147,7 +12147,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_mask_expand_pd() {
+    fn test_mm_mask_expand_pd() {
         let src = _mm_set1_pd(200.);
         let a = _mm_set_pd(0., 1.);
         let r = _mm_mask_expand_pd(src, 0, a);
@@ -12158,7 +12158,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    unsafe fn test_mm_maskz_expand_pd() {
+    fn test_mm_maskz_expand_pd() {
         let a = _mm_set_pd(0., 1.);
         let r = _mm_maskz_expand_pd(0, a);
         assert_eq_m128d(r, _mm_setzero_pd());
@@ -12589,7 +12589,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_test_epi64_mask() {
+    const fn test_mm512_test_epi64_mask() {
         let a = _mm512_set1_epi64(1 << 0);
         let b = _mm512_set1_epi64(1 << 0 | 1 << 1);
         let r = _mm512_test_epi64_mask(a, b);
@@ -12598,7 +12598,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_test_epi64_mask() {
+    const fn test_mm512_mask_test_epi64_mask() {
         let a = _mm512_set1_epi64(1 << 0);
         let b = _mm512_set1_epi64(1 << 0 | 1 << 1);
         let r = _mm512_mask_test_epi64_mask(0, a, b);
@@ -12609,7 +12609,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_test_epi64_mask() {
+    const fn test_mm256_test_epi64_mask() {
         let a = _mm256_set1_epi64x(1 << 0);
         let b = _mm256_set1_epi64x(1 << 0 | 1 << 1);
         let r = _mm256_test_epi64_mask(a, b);
@@ -12618,7 +12618,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_test_epi64_mask() {
+    const fn test_mm256_mask_test_epi64_mask() {
         let a = _mm256_set1_epi64x(1 << 0);
         let b = _mm256_set1_epi64x(1 << 0 | 1 << 1);
         let r = _mm256_mask_test_epi64_mask(0, a, b);
@@ -12629,7 +12629,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_test_epi64_mask() {
+    const fn test_mm_test_epi64_mask() {
         let a = _mm_set1_epi64x(1 << 0);
         let b = _mm_set1_epi64x(1 << 0 | 1 << 1);
         let r = _mm_test_epi64_mask(a, b);
@@ -12638,7 +12638,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_test_epi64_mask() {
+    const fn test_mm_mask_test_epi64_mask() {
         let a = _mm_set1_epi64x(1 << 0);
         let b = _mm_set1_epi64x(1 << 0 | 1 << 1);
         let r = _mm_mask_test_epi64_mask(0, a, b);
@@ -12649,7 +12649,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_testn_epi64_mask() {
+    const fn test_mm512_testn_epi64_mask() {
         let a = _mm512_set1_epi64(1 << 0);
         let b = _mm512_set1_epi64(1 << 0 | 1 << 1);
         let r = _mm512_testn_epi64_mask(a, b);
@@ -12658,7 +12658,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_testn_epi64_mask() {
+    const fn test_mm512_mask_testn_epi64_mask() {
         let a = _mm512_set1_epi64(1 << 0);
         let b = _mm512_set1_epi64(1 << 1);
         let r = _mm512_mask_testn_epi64_mask(0, a, b);
@@ -12669,7 +12669,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_testn_epi64_mask() {
+    const fn test_mm256_testn_epi64_mask() {
         let a = _mm256_set1_epi64x(1 << 0);
         let b = _mm256_set1_epi64x(1 << 1);
         let r = _mm256_testn_epi64_mask(a, b);
@@ -12678,7 +12678,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_testn_epi64_mask() {
+    const fn test_mm256_mask_testn_epi64_mask() {
         let a = _mm256_set1_epi64x(1 << 0);
         let b = _mm256_set1_epi64x(1 << 1);
         let r = _mm256_mask_testn_epi64_mask(0, a, b);
@@ -12689,7 +12689,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_testn_epi64_mask() {
+    const fn test_mm_testn_epi64_mask() {
         let a = _mm_set1_epi64x(1 << 0);
         let b = _mm_set1_epi64x(1 << 1);
         let r = _mm_testn_epi64_mask(a, b);
@@ -12698,7 +12698,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_testn_epi64_mask() {
+    const fn test_mm_mask_testn_epi64_mask() {
         let a = _mm_set1_epi64x(1 << 0);
         let b = _mm_set1_epi64x(1 << 1);
         let r = _mm_mask_testn_epi64_mask(0, a, b);
@@ -12709,7 +12709,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_mask_set1_epi64() {
+    const fn test_mm512_mask_set1_epi64() {
         let src = _mm512_set1_epi64(2);
         let a: i64 = 11;
         let r = _mm512_mask_set1_epi64(src, 0, a);
@@ -12720,7 +12720,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm512_maskz_set1_epi64() {
+    const fn test_mm512_maskz_set1_epi64() {
         let a: i64 = 11;
         let r = _mm512_maskz_set1_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -12730,7 +12730,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_mask_set1_epi64() {
+    const fn test_mm256_mask_set1_epi64() {
         let src = _mm256_set1_epi64x(2);
         let a: i64 = 11;
         let r = _mm256_mask_set1_epi64(src, 0, a);
@@ -12741,7 +12741,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm256_maskz_set1_epi64() {
+    const fn test_mm256_maskz_set1_epi64() {
         let a: i64 = 11;
         let r = _mm256_maskz_set1_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -12751,7 +12751,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_mask_set1_epi64() {
+    const fn test_mm_mask_set1_epi64() {
         let src = _mm_set1_epi64x(2);
         let a: i64 = 11;
         let r = _mm_mask_set1_epi64(src, 0, a);
@@ -12762,7 +12762,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
-    const unsafe fn test_mm_maskz_set1_epi64() {
+    const fn test_mm_maskz_set1_epi64() {
         let a: i64 = 11;
         let r = _mm_maskz_set1_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -12772,7 +12772,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtsd_i64() {
+    fn test_mm_cvtsd_i64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtsd_i64(a);
         let e: i64 = -2;
@@ -12780,7 +12780,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtss_i64() {
+    fn test_mm_cvtss_i64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtss_i64(a);
         let e: i64 = -2;
@@ -12788,7 +12788,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundi64_ss() {
+    fn test_mm_cvt_roundi64_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvt_roundi64_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -12797,7 +12797,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsi64_ss() {
+    fn test_mm_cvt_roundsi64_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvt_roundsi64_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -12806,7 +12806,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvti64_ss() {
+    const fn test_mm_cvti64_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvti64_ss(a, b);
@@ -12815,7 +12815,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvti64_sd() {
+    const fn test_mm_cvti64_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvti64_sd(a, b);
@@ -12824,7 +12824,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_si64() {
+    fn test_mm_cvt_roundsd_si64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvt_roundsd_si64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i64 = -1;
@@ -12832,7 +12832,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_i64() {
+    fn test_mm_cvt_roundsd_i64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvt_roundsd_i64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i64 = -1;
@@ -12840,7 +12840,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsd_u64() {
+    fn test_mm_cvt_roundsd_u64() {
         let a = _mm_set_pd(1., f64::MAX);
         let r = _mm_cvt_roundsd_u64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: u64 = u64::MAX;
@@ -12848,7 +12848,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtsd_u64() {
+    fn test_mm_cvtsd_u64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtsd_u64(a);
         let e: u64 = u64::MAX;
@@ -12856,7 +12856,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_i64() {
+    fn test_mm_cvt_roundss_i64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_i64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i64 = -1;
@@ -12864,7 +12864,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_si64() {
+    fn test_mm_cvt_roundss_si64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_si64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: i64 = -1;
@@ -12872,7 +12872,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundss_u64() {
+    fn test_mm_cvt_roundss_u64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvt_roundss_u64::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a);
         let e: u64 = u64::MAX;
@@ -12880,7 +12880,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtss_u64() {
+    fn test_mm_cvtss_u64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtss_u64(a);
         let e: u64 = u64::MAX;
@@ -12888,7 +12888,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttsd_i64() {
+    fn test_mm_cvttsd_i64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvttsd_i64(a);
         let e: i64 = -1;
@@ -12896,7 +12896,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_i64() {
+    fn test_mm_cvtt_roundsd_i64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_i64::<_MM_FROUND_NO_EXC>(a);
         let e: i64 = -1;
@@ -12904,7 +12904,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_si64() {
+    fn test_mm_cvtt_roundsd_si64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_si64::<_MM_FROUND_NO_EXC>(a);
         let e: i64 = -1;
@@ -12912,7 +12912,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundsd_u64() {
+    fn test_mm_cvtt_roundsd_u64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvtt_roundsd_u64::<_MM_FROUND_NO_EXC>(a);
         let e: u64 = u64::MAX;
@@ -12920,7 +12920,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttsd_u64() {
+    fn test_mm_cvttsd_u64() {
         let a = _mm_set_pd(1., -1.5);
         let r = _mm_cvttsd_u64(a);
         let e: u64 = u64::MAX;
@@ -12928,7 +12928,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttss_i64() {
+    fn test_mm_cvttss_i64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvttss_i64(a);
         let e: i64 = -1;
@@ -12936,7 +12936,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_i64() {
+    fn test_mm_cvtt_roundss_i64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_i64::<_MM_FROUND_NO_EXC>(a);
         let e: i64 = -1;
@@ -12944,7 +12944,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_si64() {
+    fn test_mm_cvtt_roundss_si64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_si64::<_MM_FROUND_NO_EXC>(a);
         let e: i64 = -1;
@@ -12952,7 +12952,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvtt_roundss_u64() {
+    fn test_mm_cvtt_roundss_u64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvtt_roundss_u64::<_MM_FROUND_NO_EXC>(a);
         let e: u64 = u64::MAX;
@@ -12960,7 +12960,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvttss_u64() {
+    fn test_mm_cvttss_u64() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let r = _mm_cvttss_u64(a);
         let e: u64 = u64::MAX;
@@ -12968,7 +12968,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvtu64_ss() {
+    const fn test_mm_cvtu64_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: u64 = 9;
         let r = _mm_cvtu64_ss(a, b);
@@ -12977,7 +12977,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    const unsafe fn test_mm_cvtu64_sd() {
+    const fn test_mm_cvtu64_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: u64 = 9;
         let r = _mm_cvtu64_sd(a, b);
@@ -12986,7 +12986,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundu64_ss() {
+    fn test_mm_cvt_roundu64_ss() {
         let a = _mm_set_ps(0., -0.5, 1., -1.5);
         let b: u64 = 9;
         let r = _mm_cvt_roundu64_ss::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -12995,7 +12995,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundu64_sd() {
+    fn test_mm_cvt_roundu64_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: u64 = 9;
         let r = _mm_cvt_roundu64_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -13004,7 +13004,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundi64_sd() {
+    fn test_mm_cvt_roundi64_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvt_roundi64_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
@@ -13013,7 +13013,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512f")]
-    unsafe fn test_mm_cvt_roundsi64_sd() {
+    fn test_mm_cvt_roundsi64_sd() {
         let a = _mm_set_pd(1., -1.5);
         let b: i64 = 9;
         let r = _mm_cvt_roundsi64_sd::<{ _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC }>(a, b);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx512fp16.rs b/library/stdarch/crates/core_arch/src/x86_64/avx512fp16.rs
index 955c6ccc7526..87e3651ba744 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx512fp16.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx512fp16.rs
@@ -10,7 +10,7 @@ use stdarch_test::assert_instr;
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsi2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvti64_sh(a: __m128h, b: i64) -> __m128h {
     unsafe { vcvtsi642sh(a, b, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -32,7 +32,7 @@ pub fn _mm_cvti64_sh(a: __m128h, b: i64) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsi2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundi64_sh<const ROUNDING: i32>(a: __m128h, b: i64) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -48,7 +48,7 @@ pub fn _mm_cvt_roundi64_sh<const ROUNDING: i32>(a: __m128h, b: i64) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtusi2sh))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtu64_sh(a: __m128h, b: u64) -> __m128h {
     unsafe { vcvtusi642sh(a, b, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -70,7 +70,7 @@ pub fn _mm_cvtu64_sh(a: __m128h, b: u64) -> __m128h {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtusi2sh, ROUNDING = 8))]
 #[rustc_legacy_const_generics(2)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundu64_sh<const ROUNDING: i32>(a: __m128h, b: u64) -> __m128h {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -85,7 +85,7 @@ pub fn _mm_cvt_roundu64_sh<const ROUNDING: i32>(a: __m128h, b: u64) -> __m128h {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2si))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_i64(a: __m128h) -> i64 {
     unsafe { vcvtsh2si64(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -106,7 +106,7 @@ pub fn _mm_cvtsh_i64(a: __m128h) -> i64 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2si, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_i64<const ROUNDING: i32>(a: __m128h) -> i64 {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -121,7 +121,7 @@ pub fn _mm_cvt_roundsh_i64<const ROUNDING: i32>(a: __m128h) -> i64 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2usi))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtsh_u64(a: __m128h) -> u64 {
     unsafe { vcvtsh2usi64(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -142,7 +142,7 @@ pub fn _mm_cvtsh_u64(a: __m128h) -> u64 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvtsh2usi, ROUNDING = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvt_roundsh_u64<const ROUNDING: i32>(a: __m128h) -> u64 {
     unsafe {
         static_assert_rounding!(ROUNDING);
@@ -157,7 +157,7 @@ pub fn _mm_cvt_roundsh_u64<const ROUNDING: i32>(a: __m128h) -> u64 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2si))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttsh_i64(a: __m128h) -> i64 {
     unsafe { vcvttsh2si64(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -172,7 +172,7 @@ pub fn _mm_cvttsh_i64(a: __m128h) -> i64 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2si, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtt_roundsh_i64<const SAE: i32>(a: __m128h) -> i64 {
     unsafe {
         static_assert_sae!(SAE);
@@ -187,7 +187,7 @@ pub fn _mm_cvtt_roundsh_i64<const SAE: i32>(a: __m128h) -> i64 {
 #[inline]
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2usi))]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvttsh_u64(a: __m128h) -> u64 {
     unsafe { vcvttsh2usi64(a, _MM_FROUND_CUR_DIRECTION) }
 }
@@ -202,7 +202,7 @@ pub fn _mm_cvttsh_u64(a: __m128h) -> u64 {
 #[target_feature(enable = "avx512fp16")]
 #[cfg_attr(test, assert_instr(vcvttsh2usi, SAE = 8))]
 #[rustc_legacy_const_generics(1)]
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub fn _mm_cvtt_roundsh_u64<const SAE: i32>(a: __m128h) -> u64 {
     unsafe {
         static_assert_sae!(SAE);
@@ -232,7 +232,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvti64_sh() {
+    fn test_mm_cvti64_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvti64_sh(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -240,7 +240,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundi64_sh() {
+    fn test_mm_cvt_roundi64_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundi64_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -248,7 +248,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvtu64_sh() {
+    fn test_mm_cvtu64_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtu64_sh(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -256,7 +256,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16,avx512vl")]
-    unsafe fn test_mm_cvt_roundu64_sh() {
+    fn test_mm_cvt_roundu64_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundu64_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
         let e = _mm_setr_ph(10.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
@@ -264,56 +264,56 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_i64() {
+    fn test_mm_cvtsh_i64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtsh_i64(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_i64() {
+    fn test_mm_cvt_roundsh_i64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundsh_i64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtsh_u64() {
+    fn test_mm_cvtsh_u64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtsh_u64(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvt_roundsh_u64() {
+    fn test_mm_cvt_roundsh_u64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundsh_u64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvttsh_i64() {
+    fn test_mm_cvttsh_i64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttsh_i64(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtt_roundsh_i64() {
+    fn test_mm_cvtt_roundsh_i64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtt_roundsh_i64::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvttsh_u64() {
+    fn test_mm_cvttsh_u64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvttsh_u64(a);
         assert_eq!(r, 1);
     }
 
     #[simd_test(enable = "avx512fp16")]
-    unsafe fn test_mm_cvtt_roundsh_u64() {
+    fn test_mm_cvtt_roundsh_u64() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtt_roundsh_u64::<_MM_FROUND_NO_EXC>(a);
         assert_eq!(r, 1);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/bmi.rs b/library/stdarch/crates/core_arch/src/x86_64/bmi.rs
index d5fd97583fb1..8d2b22089ac1 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/bmi.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/bmi.rs
@@ -135,13 +135,13 @@ mod tests {
     use crate::core_arch::{x86::*, x86_64::*};
 
     #[simd_test(enable = "bmi1")]
-    unsafe fn test_bextr_u64() {
+    fn test_bextr_u64() {
         let r = _bextr_u64(0b0101_0000u64, 4, 4);
         assert_eq!(r, 0b0000_0101u64);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_andn_u64() {
+    const fn test_andn_u64() {
         assert_eq!(_andn_u64(0, 0), 0);
         assert_eq!(_andn_u64(0, 1), 1);
         assert_eq!(_andn_u64(1, 0), 0);
@@ -164,25 +164,25 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsi_u64() {
+    const fn test_blsi_u64() {
         assert_eq!(_blsi_u64(0b1101_0000u64), 0b0001_0000u64);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsmsk_u64() {
+    const fn test_blsmsk_u64() {
         let r = _blsmsk_u64(0b0011_0000u64);
         assert_eq!(r, 0b0001_1111u64);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_blsr_u64() {
+    const fn test_blsr_u64() {
         // TODO: test the behavior when the input is `0`.
         let r = _blsr_u64(0b0011_0000u64);
         assert_eq!(r, 0b0010_0000u64);
     }
 
     #[simd_test(enable = "bmi1")]
-    const unsafe fn test_tzcnt_u64() {
+    const fn test_tzcnt_u64() {
         assert_eq!(_tzcnt_u64(0b0000_0001u64), 0u64);
         assert_eq!(_tzcnt_u64(0b0000_0000u64), 64u64);
         assert_eq!(_tzcnt_u64(0b1001_0000u64), 4u64);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/bmi2.rs b/library/stdarch/crates/core_arch/src/x86_64/bmi2.rs
index be12465c8147..6151eee8bdbb 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/bmi2.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/bmi2.rs
@@ -86,7 +86,7 @@ mod tests {
     use crate::core_arch::x86_64::*;
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_pext_u64() {
+    fn test_pext_u64() {
         let n = 0b1011_1110_1001_0011u64;
 
         let m0 = 0b0110_0011_1000_0101u64;
@@ -100,7 +100,7 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_pdep_u64() {
+    fn test_pdep_u64() {
         let n = 0b1011_1110_1001_0011u64;
 
         let m0 = 0b0110_0011_1000_0101u64;
@@ -114,7 +114,7 @@ mod tests {
     }
 
     #[simd_test(enable = "bmi2")]
-    unsafe fn test_bzhi_u64() {
+    fn test_bzhi_u64() {
         let n = 0b1111_0010u64;
         let s = 0b0001_0010u64;
         assert_eq!(_bzhi_u64(n, 5), s);
@@ -122,7 +122,7 @@ mod tests {
 
     #[simd_test(enable = "bmi2")]
     #[rustfmt::skip]
-const     unsafe fn test_mulx_u64() {
+    const fn test_mulx_u64() {
         let a: u64 = 9_223_372_036_854_775_800;
         let b: u64 = 100;
         let mut hi = 0;
diff --git a/library/stdarch/crates/core_arch/src/x86_64/mod.rs b/library/stdarch/crates/core_arch/src/x86_64/mod.rs
index 7d681882bef0..c6dc7a85e785 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/mod.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/mod.rs
@@ -75,7 +75,7 @@ mod bt;
 pub use self::bt::*;
 
 mod avx512fp16;
-#[unstable(feature = "stdarch_x86_avx512_f16", issue = "127213")]
+#[stable(feature = "stdarch_x86_avx512fp16", since = "CURRENT_RUSTC_VERSION")]
 pub use self::avx512fp16::*;
 
 mod amx;
diff --git a/library/stdarch/crates/core_arch/src/x86_64/sse.rs b/library/stdarch/crates/core_arch/src/x86_64/sse.rs
index e5c1f7915342..81e1070b5569 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/sse.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/sse.rs
@@ -74,7 +74,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_cvtss_si64() {
+    fn test_mm_cvtss_si64() {
         let inputs = &[
             (42.0f32, 42i64),
             (-31.4, -31),
@@ -98,7 +98,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    unsafe fn test_mm_cvttss_si64() {
+    fn test_mm_cvttss_si64() {
         let inputs = &[
             (42.0f32, 42i64),
             (-31.4, -31),
@@ -125,7 +125,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse")]
-    const unsafe fn test_mm_cvtsi64_ss() {
+    const fn test_mm_cvtsi64_ss() {
         let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
 
         let r = _mm_cvtsi64_ss(a, 4555);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/sse2.rs b/library/stdarch/crates/core_arch/src/x86_64/sse2.rs
index 9f350f236840..b156af078a32 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/sse2.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/sse2.rs
@@ -172,7 +172,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvtsd_si64() {
+    fn test_mm_cvtsd_si64() {
         let r = _mm_cvtsd_si64(_mm_setr_pd(-2.0, 5.0));
         assert_eq!(r, -2_i64);
 
@@ -181,20 +181,20 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvtsd_si64x() {
+    fn test_mm_cvtsd_si64x() {
         let r = _mm_cvtsd_si64x(_mm_setr_pd(f64::NAN, f64::NAN));
         assert_eq!(r, i64::MIN);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvttsd_si64() {
+    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);
     }
 
     #[simd_test(enable = "sse2")]
-    unsafe fn test_mm_cvttsd_si64x() {
+    fn test_mm_cvttsd_si64x() {
         let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
         let r = _mm_cvttsd_si64x(a);
         assert_eq!(r, i64::MIN);
@@ -213,19 +213,19 @@ mod tests {
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi64_si128() {
+    const fn test_mm_cvtsi64_si128() {
         let r = _mm_cvtsi64_si128(5);
         assert_eq_m128i(r, _mm_setr_epi64x(5, 0));
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi128_si64() {
+    const fn test_mm_cvtsi128_si64() {
         let r = _mm_cvtsi128_si64(_mm_setr_epi64x(5, 0));
         assert_eq!(r, 5);
     }
 
     #[simd_test(enable = "sse2")]
-    const unsafe fn test_mm_cvtsi64_sd() {
+    const fn test_mm_cvtsi64_sd() {
         let a = _mm_set1_pd(3.5);
         let r = _mm_cvtsi64_sd(a, 5);
         assert_eq_m128d(r, _mm_setr_pd(5.0, 3.5));
diff --git a/library/stdarch/crates/core_arch/src/x86_64/sse41.rs b/library/stdarch/crates/core_arch/src/x86_64/sse41.rs
index 3b1c88ad8cb2..7732264e207d 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/sse41.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/sse41.rs
@@ -41,7 +41,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_extract_epi64() {
+    const fn test_mm_extract_epi64() {
         let a = _mm_setr_epi64x(0, 1);
         let r = _mm_extract_epi64::<1>(a);
         assert_eq!(r, 1);
@@ -50,7 +50,7 @@ mod tests {
     }
 
     #[simd_test(enable = "sse4.1")]
-    const unsafe fn test_mm_insert_epi64() {
+    const fn test_mm_insert_epi64() {
         let a = _mm_set1_epi64x(0);
         let e = _mm_setr_epi64x(0, 32);
         let r = _mm_insert_epi64::<1>(a, 32);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/sse42.rs b/library/stdarch/crates/core_arch/src/x86_64/sse42.rs
index 64a23b2b1921..cd32c149aff5 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/sse42.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/sse42.rs
@@ -28,7 +28,7 @@ mod tests {
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "sse4.2")]
-    unsafe fn test_mm_crc32_u64() {
+    fn test_mm_crc32_u64() {
         let crc = 0x7819dccd3e824;
         let v = 0x2a22b845fed;
         let i = _mm_crc32_u64(crc, v);
diff --git a/library/stdarch/crates/core_arch/src/x86_64/tbm.rs b/library/stdarch/crates/core_arch/src/x86_64/tbm.rs
index 031bd320713e..fe12538b07a0 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/tbm.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/tbm.rs
@@ -154,18 +154,18 @@ mod tests {
     use crate::core_arch::x86_64::*;
 
     #[simd_test(enable = "tbm")]
-    unsafe fn test_bextri_u64() {
+    fn test_bextri_u64() {
         assert_eq!(_bextri_u64::<0x0404>(0b0101_0000u64), 0b0000_0101u64);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcfill_u64() {
+    const fn test_blcfill_u64() {
         assert_eq!(_blcfill_u64(0b0101_0111u64), 0b0101_0000u64);
         assert_eq!(_blcfill_u64(0b1111_1111u64), 0u64);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blci_u64() {
+    const fn test_blci_u64() {
         assert_eq!(
             _blci_u64(0b0101_0000u64),
             0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110u64
@@ -177,25 +177,25 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcic_u64() {
+    const fn test_blcic_u64() {
         assert_eq!(_blcic_u64(0b0101_0001u64), 0b0000_0010u64);
         assert_eq!(_blcic_u64(0b1111_1111u64), 0b1_0000_0000u64);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcmsk_u64() {
+    const fn test_blcmsk_u64() {
         assert_eq!(_blcmsk_u64(0b0101_0001u64), 0b0000_0011u64);
         assert_eq!(_blcmsk_u64(0b1111_1111u64), 0b1_1111_1111u64);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blcs_u64() {
+    const fn test_blcs_u64() {
         assert_eq!(_blcs_u64(0b0101_0001u64), 0b0101_0011u64);
         assert_eq!(_blcs_u64(0b1111_1111u64), 0b1_1111_1111u64);
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blsfill_u64() {
+    const fn test_blsfill_u64() {
         assert_eq!(_blsfill_u64(0b0101_0100u64), 0b0101_0111u64);
         assert_eq!(
             _blsfill_u64(0u64),
@@ -204,7 +204,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_blsic_u64() {
+    const fn test_blsic_u64() {
         assert_eq!(
             _blsic_u64(0b0101_0100u64),
             0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1011u64
@@ -216,7 +216,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_t1mskc_u64() {
+    const fn test_t1mskc_u64() {
         assert_eq!(
             _t1mskc_u64(0b0101_0111u64),
             0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1000u64
@@ -228,7 +228,7 @@ mod tests {
     }
 
     #[simd_test(enable = "tbm")]
-    const unsafe fn test_tzmsk_u64() {
+    const fn test_tzmsk_u64() {
         assert_eq!(_tzmsk_u64(0b0101_1000u64), 0b0000_0111u64);
         assert_eq!(_tzmsk_u64(0b0101_1001u64), 0b0000_0000u64);
     }
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
index 2890ac632d93..8f36c525fae9 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
@@ -13,6 +13,10 @@ auto_llvm_sign_conversion: false
 neon-stable: &neon-stable
   FnCall: [stable, ['feature = "neon_intrinsics"', 'since = "1.59.0"']]
 
+# #[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
+neon-stable-fp16: &neon-stable-fp16
+  FnCall: [stable, ['feature = "stdarch_neon_fp16"', 'since = "CURRENT_RUSTC_VERSION"']]
+
 # #[cfg(not(target_arch = "arm64ec"))]
 target-not-arm64ec: &target-not-arm64ec
   FnCall: [cfg, [{ FnCall: [not, ['target_arch = "arm64ec"']]}]]
@@ -1506,7 +1510,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtn2]]}]]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1523,7 +1527,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtl2]]}]]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1807,7 +1811,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtas]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1977,7 +1981,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtns]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1998,7 +2002,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtnu]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -2112,7 +2116,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtms]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -2133,7 +2137,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtmu]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -2328,7 +2332,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtps]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -2349,7 +2353,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtpu]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -3032,7 +3036,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frintx]
     safety: safe
@@ -3081,7 +3085,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frinta]
     safety: safe
@@ -3181,7 +3185,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frintm]
     safety: safe
@@ -3231,7 +3235,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frintp]
     safety: safe
@@ -3277,7 +3281,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frintz]
     safety: safe
@@ -3330,7 +3334,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [frinti]
     safety: safe
@@ -5268,7 +5272,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmulx]
     safety: safe
@@ -5450,7 +5454,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmulx, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -5651,7 +5655,7 @@ intrinsics:
     return_type: "{neon_type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fdiv]
     safety: safe
@@ -6000,7 +6004,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fcma
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcadd]
     safety: safe
@@ -6021,7 +6025,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fcma
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcadd]
     safety: safe
@@ -6062,7 +6066,7 @@ intrinsics:
     attr:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
@@ -6103,7 +6107,7 @@ intrinsics:
     attr:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
@@ -6145,7 +6149,7 @@ intrinsics:
     attr:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
@@ -6190,7 +6194,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6236,7 +6240,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6282,7 +6286,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6325,7 +6329,7 @@ intrinsics:
     attr:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
@@ -6371,7 +6375,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6419,7 +6423,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6467,7 +6471,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6514,7 +6518,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6558,7 +6562,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-unstable-fcma
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6969,7 +6973,7 @@ intrinsics:
     return_type: "{type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [faddp]
     safety: safe
@@ -6989,7 +6993,7 @@ intrinsics:
     return_type: "{type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmaxp]
     safety: safe
@@ -7010,7 +7014,7 @@ intrinsics:
     return_type: "{type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmaxnmp]
     safety: safe
@@ -7031,7 +7035,7 @@ intrinsics:
     return_type: "{type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fminp]
     safety: safe
@@ -7052,7 +7056,7 @@ intrinsics:
     return_type: "{type}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fminnmp]
     safety: safe
@@ -8478,7 +8482,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fsqrt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8791,7 +8795,7 @@ intrinsics:
     arguments: ["a: {type[0]}"]
     return_type: "{type[1]}"
     attr:
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
@@ -9691,7 +9695,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [trn1]]}]]
     safety: safe
@@ -9753,7 +9757,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [trn2]]}]]
     safety: safe
@@ -9822,7 +9826,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [zip2]]}]]
     safety: safe
@@ -9873,7 +9877,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [zip1]]}]]
     safety: safe
@@ -9935,7 +9939,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [uzp1]]}]]
     safety: safe
@@ -10001,7 +10005,7 @@ intrinsics:
     return_type: "{neon_type[0]}"
     attr:
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [uzp2]]}]]
     safety: safe
@@ -10291,7 +10295,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmla, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -10318,7 +10322,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmls, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -10658,7 +10662,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmeq]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11248,7 +11252,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmul, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -11862,7 +11866,7 @@ intrinsics:
     attr:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtau]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     safety: safe
     types:
@@ -13770,7 +13774,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fhm
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmlal2]
     safety: safe
@@ -13794,7 +13798,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -13819,7 +13823,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fhm
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmlal]
     safety: safe
@@ -13843,7 +13847,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -13868,7 +13872,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fhm
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmlsl2]
     safety: safe
@@ -13891,7 +13895,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
@@ -13916,7 +13920,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *enable-fhm
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     assert_instr: [fmlsl]
     safety: safe
@@ -13939,7 +13943,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
-      - *neon-unstable-f16
+      - *neon-stable-fp16
       - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index e8b31d73f939..c7a333d7f75e 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
@@ -10,6 +10,10 @@ auto_big_endian: true
 neon-stable: &neon-stable
   FnCall: [stable, ['feature = "neon_intrinsics"', 'since = "1.59.0"']]
 
+# #[stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION")]
+neon-stable-fp16: &neon-stable-fp16
+  FnCall: [stable, ['feature = "stdarch_neon_fp16"', 'since = "CURRENT_RUSTC_VERSION"']]
+
 # #[cfg_attr(target_arch = "arm", unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800"))]
 neon-cfg-arm-unstable: &neon-cfg-arm-unstable
   FnCall: ['cfg_attr', ['target_arch = "arm"', {FnCall: ['unstable', ['feature = "stdarch_arm_neon_intrinsics"', 'issue = "111800"']]}]]
@@ -51,6 +55,10 @@ neon-target-aarch64-arm64ec: &neon-target-aarch64-arm64ec
 neon-not-arm-stable: &neon-not-arm-stable
   FnCall: [cfg_attr, [{ FnCall: [not, ['target_arch = "arm"']]}, {FnCall: [stable, ['feature = "neon_intrinsics"', 'since = "1.59.0"']]}]]
 
+# #[cfg_attr(not(target_arch = "arm"), stable(feature = "stdarch_neon_fp16", since = "CURRENT_RUSTC_VERSION"))]
+neon-not-arm-stable-fp16: &neon-not-arm-stable-fp16
+  FnCall: [cfg_attr, [{ FnCall: [not, ['target_arch = "arm"']]}, {FnCall: [stable, ['feature = "stdarch_neon_fp16"', 'since = "CURRENT_RUSTC_VERSION"']]}]]
+
 # #[cfg_attr(all(test, not(target_env = "msvc"))]
 msvc-disabled: &msvc-disabled
   FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]
@@ -285,7 +293,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vabd.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fabd]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -404,7 +413,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vceq.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmeq]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -466,7 +476,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vabs]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fabs]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -566,7 +577,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcgt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -585,7 +597,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcgt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -664,7 +677,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcge.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -682,7 +696,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcle.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmle]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -864,7 +879,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vacgt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -911,7 +927,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vacge.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -952,7 +969,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vacgt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -988,7 +1006,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vacge.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1023,7 +1042,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [scvtf]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1058,7 +1078,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ucvtf]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -1130,7 +1151,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ucvtf, 'N = 1']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1162,7 +1184,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzs, 'N = 1']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1194,7 +1217,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzu, 'N = 1']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1253,7 +1277,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [scvtf, 'N = 1']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1507,7 +1532,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [dup, 'N = 4']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1546,7 +1572,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [dup, 'N = 2']]}]]
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1768,7 +1795,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ext, 'N = 3']]}]]
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -1787,7 +1815,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ext, 'N = 7']]}]]
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
@@ -2237,7 +2266,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vneg.{type[1]}"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fneg]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -2501,7 +2531,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrintn]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frintn]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -6368,7 +6399,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vmul.{type[0]}"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmul]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -6418,7 +6450,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmul, 'LANE = 1']]}]]
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
@@ -6622,7 +6655,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vfma]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmla]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -6732,7 +6766,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vsub.{type[0]}"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fsub]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -6751,7 +6786,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vadd.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fadd]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -7253,7 +7289,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vmax]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmax]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -7296,7 +7333,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vmaxnm]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmaxnm]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -7315,7 +7353,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vminnm]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fminnm]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -7402,7 +7441,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vmin]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmin]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -7467,7 +7507,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vpadd]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [faddp]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8311,7 +8352,8 @@ intrinsics:
       - *neon-fp16
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrsqrts]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frsqrts]]}]]
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8360,7 +8402,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrecpe]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frecpe]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8409,7 +8452,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrecps]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frecps]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8742,7 +8786,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8805,7 +8850,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -8828,7 +8874,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrev64]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [rev64]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -9144,7 +9191,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -9650,7 +9698,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [trn1]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [trn2]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -9806,7 +9855,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [zip1]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [zip2]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -9877,7 +9927,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [uzp1]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [uzp2]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -10456,7 +10507,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcge.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -10475,7 +10527,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcge.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -10715,7 +10768,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzu]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -10735,7 +10789,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtn]]}]]
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -10752,7 +10807,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtl]]}]]
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11227,7 +11283,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vcgt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11246,7 +11303,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vclt.f16"']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmlt]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11359,7 +11417,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmls]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11475,7 +11534,8 @@ intrinsics:
       - *neon-fp16
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrsqrte]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frsqrte]]}]]
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11589,7 +11649,8 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vcvt]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzs]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
@@ -11839,7 +11900,7 @@ intrinsics:
       - *enable-v7
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-arm-unstable
       - *target-not-arm64ec
     safety:
       unsafe: [neon]
@@ -13784,7 +13845,7 @@ intrinsics:
       - *target-is-arm
       - *neon-v7
       - *neon-fp16
-      - *neon-unstable-f16
+      - *neon-arm-unstable
       - *target-not-arm64ec
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vst1.{type[4]}"']]}]]
     types:
@@ -14060,7 +14121,8 @@ intrinsics:
     attr:
       - *neon-v7
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
@@ -14076,7 +14138,8 @@ intrinsics:
     attr:
       - *neon-v7
       - *arm-fp16
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
@@ -14731,7 +14794,8 @@ intrinsics:
       - *neon-v7
       - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['vbsl']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, ['bsl']]}]]
-      - *neon-unstable-f16
+      - *neon-not-arm-stable-fp16
+      - *neon-cfg-arm-unstable
       - *target-not-arm64ec
     safety: safe
     types:
diff --git a/library/stdarch/rust-version b/library/stdarch/rust-version
index 04d41c96f5c0..df8693cd1ca8 100644
--- a/library/stdarch/rust-version
+++ b/library/stdarch/rust-version
@@ -1 +1 @@
-8401398e1f14a24670ee1a3203713dc2f0f8b3a8
+48622726c4a91c87bf6cd4dbe1000c95df59906e
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index eec8c461b6db..a18868082916 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -20,7 +20,7 @@ test = { path = "../test", public = true }
 
 # Forward features to the `std` crate as necessary
 [features]
-default = ["std_detect_file_io", "std_detect_dlsym_getauxval", "panic-unwind"]
+default = ["panic-unwind"]
 backtrace = ["std/backtrace"]
 backtrace-trace-only = ["std/backtrace-trace-only"]
 compiler-builtins-c = ["std/compiler-builtins-c"]
@@ -32,7 +32,5 @@ system-llvm-libunwind = ["std/system-llvm-libunwind"]
 optimize_for_size = ["std/optimize_for_size"]
 panic-unwind = ["std/panic-unwind"]
 profiler = ["dep:profiler_builtins"]
-std_detect_file_io = ["std/std_detect_file_io"]
-std_detect_dlsym_getauxval = ["std/std_detect_dlsym_getauxval"]
 windows_raw_dylib = ["std/windows_raw_dylib"]
 llvm_enzyme = ["std/llvm_enzyme"]
diff --git a/package.json b/package.json
index 007e2c116321..0cba589d23f5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "browser-ui-test": "^0.22.2",
+    "browser-ui-test": "^0.23.1",
     "es-check": "^9.4.4",
     "eslint": "^8.57.1",
     "typescript": "^5.8.3"
diff --git a/rust-bors.toml b/rust-bors.toml
index 384343e431dc..0d59918e3f77 100644
--- a/rust-bors.toml
+++ b/rust-bors.toml
@@ -29,8 +29,7 @@ labels_blocking_approval = [
 # If CI runs quicker than this duration, consider it to be a failure
 min_ci_time = 600
 
-# Flip this once new bors is used for actual merges on this repository
-merge_queue_enabled = false
+merge_queue_enabled = true
 report_merge_conflicts = true
 
 [labels]
@@ -55,7 +54,9 @@ try_failed = [
     "-S-waiting-on-review",
     "-S-waiting-on-crater"
 ]
-auto_build_succeeded = ["+merged-by-bors"]
+auto_build_succeeded = [
+    "+merged-by-bors"
+]
 auto_build_failed = [
     "+S-waiting-on-review",
     "-S-blocked",
diff --git a/rustfmt.toml b/rustfmt.toml
index 6172a2bb3bf9..910eea103798 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -21,7 +21,7 @@ ignore = [
     "/tests/pretty/",                 # These tests are very sensitive to source code layout.
     "/tests/run-make/export",         # These tests contain syntax errors.
     "/tests/run-make/translation/test.rs", # This test contains syntax errors.
-    "/tests/rustdoc/",                # Some have syntax errors, some are whitespace-sensitive.
+    "/tests/rustdoc-html/",           # Some have syntax errors, some are whitespace-sensitive.
     "/tests/rustdoc-gui/",            # Some tests are sensitive to source code layout.
     "/tests/rustdoc-ui/",             # Some have syntax errors, some are whitespace-sensitive.
     "/tests/ui/",                     # Some have syntax errors, some are whitespace-sensitive.
diff --git a/src/bootstrap/download-ci-gcc-stamp b/src/bootstrap/download-ci-gcc-stamp
index bbe26afc9526..ec8d0fa3135d 100644
--- a/src/bootstrap/download-ci-gcc-stamp
+++ b/src/bootstrap/download-ci-gcc-stamp
@@ -1,4 +1,4 @@
 Change this file to make users of the `download-ci-gcc` configuration download
 a new version of GCC from CI, even if the GCC submodule hasn’t changed.
 
-Last change is for: https://github.com/rust-lang/rust/pull/138051
+Last change is for: https://github.com/rust-lang/rust/pull/150873
diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index df82b7baa9f9..f983c59f9bf8 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -4,7 +4,8 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use crate::core::build_steps::compile::{
-    add_to_sysroot, run_cargo, rustc_cargo, rustc_cargo_env, std_cargo, std_crates_for_run_make,
+    ArtifactKeepMode, add_to_sysroot, run_cargo, rustc_cargo, rustc_cargo_env, std_cargo,
+    std_crates_for_run_make,
 };
 use crate::core::build_steps::tool;
 use crate::core::build_steps::tool::{
@@ -111,8 +112,7 @@ impl Step for Std {
             builder.config.free_args.clone(),
             &check_stamp,
             vec![],
-            true,
-            false,
+            ArtifactKeepMode::OnlyRmeta,
         );
 
         drop(_guard);
@@ -148,7 +148,14 @@ impl Step for Std {
             build_compiler,
             target,
         );
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
+        run_cargo(
+            builder,
+            cargo,
+            builder.config.free_args.clone(),
+            &stamp,
+            vec![],
+            ArtifactKeepMode::OnlyRmeta,
+        );
         check_stamp
     }
 
@@ -368,7 +375,14 @@ impl Step for Rustc {
         let stamp =
             build_stamp::librustc_stamp(builder, build_compiler, target).with_prefix("check");
 
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
+        run_cargo(
+            builder,
+            cargo,
+            builder.config.free_args.clone(),
+            &stamp,
+            vec![],
+            ArtifactKeepMode::OnlyRmeta,
+        );
 
         stamp
     }
@@ -568,7 +582,14 @@ impl Step for CraneliftCodegenBackend {
         )
         .with_prefix("check");
 
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
+        run_cargo(
+            builder,
+            cargo,
+            builder.config.free_args.clone(),
+            &stamp,
+            vec![],
+            ArtifactKeepMode::OnlyRmeta,
+        );
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -639,7 +660,14 @@ impl Step for GccCodegenBackend {
         )
         .with_prefix("check");
 
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
+        run_cargo(
+            builder,
+            cargo,
+            builder.config.free_args.clone(),
+            &stamp,
+            vec![],
+            ArtifactKeepMode::OnlyRmeta,
+        );
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -777,7 +805,14 @@ fn run_tool_check_step(
         .with_prefix(&format!("{display_name}-check"));
 
     let _guard = builder.msg(builder.kind, display_name, mode, build_compiler, target);
-    run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
+    run_cargo(
+        builder,
+        cargo,
+        builder.config.free_args.clone(),
+        &stamp,
+        vec![],
+        ArtifactKeepMode::OnlyRmeta,
+    );
 }
 
 tool_check_step!(Rustdoc {
@@ -793,8 +828,7 @@ tool_check_step!(Clippy { path: "src/tools/clippy", mode: Mode::ToolRustcPrivate
 tool_check_step!(Miri {
     path: "src/tools/miri",
     mode: Mode::ToolRustcPrivate,
-    enable_features: ["stack-cache"],
-    default_features: false,
+    enable_features: ["check_only"],
 });
 tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: Mode::ToolRustcPrivate });
 tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: Mode::ToolRustcPrivate });
diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index 085c2d952e30..9e5bfd2e60e9 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -15,7 +15,7 @@
 
 use build_helper::exit;
 
-use super::compile::{run_cargo, rustc_cargo, std_cargo};
+use super::compile::{ArtifactKeepMode, run_cargo, rustc_cargo, std_cargo};
 use super::tool::{SourceType, prepare_tool_cargo};
 use crate::builder::{Builder, ShouldRun};
 use crate::core::build_steps::check::{CompilerForCheck, prepare_compiler_for_check};
@@ -214,8 +214,7 @@ impl Step for Std {
             lint_args(builder, &self.config, IGNORED_RULES_FOR_STD_AND_RUSTC),
             &build_stamp::libstd_stamp(builder, build_compiler, target),
             vec![],
-            true,
-            false,
+            ArtifactKeepMode::OnlyRmeta,
         );
     }
 
@@ -309,8 +308,7 @@ impl Step for Rustc {
             lint_args(builder, &self.config, IGNORED_RULES_FOR_STD_AND_RUSTC),
             &build_stamp::librustc_stamp(builder, build_compiler, target),
             vec![],
-            true,
-            false,
+            ArtifactKeepMode::OnlyRmeta,
         );
     }
 
@@ -380,7 +378,7 @@ impl Step for CodegenGcc {
             .with_prefix("rustc_codegen_gcc-check");
 
         let args = lint_args(builder, &self.config, &[]);
-        run_cargo(builder, cargo, args.clone(), &stamp, vec![], true, false);
+        run_cargo(builder, cargo, args.clone(), &stamp, vec![], ArtifactKeepMode::OnlyRmeta);
 
         // Same but we disable the features enabled by default.
         let mut cargo = prepare_tool_cargo(
@@ -396,7 +394,7 @@ impl Step for CodegenGcc {
         self.build_compiler.configure_cargo(&mut cargo);
         println!("Now running clippy on `rustc_codegen_gcc` with `--no-default-features`");
         cargo.arg("--no-default-features");
-        run_cargo(builder, cargo, args, &stamp, vec![], true, false);
+        run_cargo(builder, cargo, args, &stamp, vec![], ArtifactKeepMode::OnlyRmeta);
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -478,8 +476,7 @@ macro_rules! lint_any {
                     lint_args(builder, &self.config, &[]),
                     &stamp,
                     vec![],
-                    true,
-                    false,
+                    ArtifactKeepMode::OnlyRmeta
                 );
             }
 
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 762aeea9f451..2808c29cc6c0 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -19,7 +19,7 @@ use serde_derive::Deserialize;
 #[cfg(feature = "tracing")]
 use tracing::span;
 
-use crate::core::build_steps::gcc::{Gcc, GccOutput, GccTargetPair, add_cg_gcc_cargo_flags};
+use crate::core::build_steps::gcc::{Gcc, GccOutput, GccTargetPair};
 use crate::core::build_steps::tool::{RustcPrivateCompilers, SourceType, copy_lld_artifacts};
 use crate::core::build_steps::{dist, llvm};
 use crate::core::builder;
@@ -296,8 +296,11 @@ impl Step for Std {
             vec![],
             &stamp,
             target_deps,
-            self.is_for_mir_opt_tests, // is_check
-            false,
+            if self.is_for_mir_opt_tests {
+                ArtifactKeepMode::OnlyRmeta
+            } else {
+                ArtifactKeepMode::OnlyRlib
+            },
         );
 
         builder.ensure(StdLink::from_std(
@@ -1167,14 +1170,28 @@ impl Step for Rustc {
             target,
         );
         let stamp = build_stamp::librustc_stamp(builder, build_compiler, target);
+
         run_cargo(
             builder,
             cargo,
             vec![],
             &stamp,
             vec![],
-            false,
-            true, // Only ship rustc_driver.so and .rmeta files, not all intermediate .rlib files.
+            ArtifactKeepMode::Custom(Box::new(|filename| {
+                if filename.contains("jemalloc_sys")
+                    || filename.contains("rustc_public_bridge")
+                    || filename.contains("rustc_public")
+                {
+                    // jemalloc_sys and rustc_public_bridge are not linked into librustc_driver.so,
+                    // so we need to distribute them as rlib to be able to use them.
+                    filename.ends_with(".rlib")
+                } else {
+                    // Distribute the rest of the rustc crates as rmeta files only to reduce
+                    // the tarball sizes by about 50%. The object files are linked into
+                    // librustc_driver.so, so it is still possible to link against them.
+                    filename.ends_with(".rmeta")
+                }
+            })),
         );
 
         let target_root_dir = stamp.path().parent().unwrap();
@@ -1569,21 +1586,29 @@ impl Step for RustcLink {
 }
 
 /// Set of `libgccjit` dylibs that can be used by `cg_gcc` to compile code for a set of targets.
+/// `libgccjit` requires a separate build for each `(host, target)` pair.
+/// So if you are on linux-x64 and build for linux-aarch64, you will need at least:
+/// - linux-x64 -> linux-x64 libgccjit (for building host code like proc macros)
+/// - linux-x64 -> linux-aarch64 libgccjit (for the aarch64 target code)
 #[derive(Clone)]
 pub struct GccDylibSet {
     dylibs: BTreeMap<GccTargetPair, GccOutput>,
-    host_pair: GccTargetPair,
 }
 
 impl GccDylibSet {
-    /// Returns the libgccjit.so dylib that corresponds to a host target on which `cg_gcc` will be
-    /// executed, and which will target the host. So e.g. if `cg_gcc` will be executed on
-    /// x86_64-unknown-linux-gnu, the host dylib will be for compilation pair
-    /// `(x86_64-unknown-linux-gnu, x86_64-unknown-linux-gnu)`.
-    fn host_dylib(&self) -> &GccOutput {
-        self.dylibs.get(&self.host_pair).unwrap_or_else(|| {
-            panic!("libgccjit.so was not built for host target {}", self.host_pair)
-        })
+    /// Build a set of libgccjit dylibs that will be executed on `host` and will generate code for
+    /// each specified target.
+    pub fn build(
+        builder: &Builder<'_>,
+        host: TargetSelection,
+        targets: Vec<TargetSelection>,
+    ) -> Self {
+        let dylibs = targets
+            .iter()
+            .map(|t| GccTargetPair::for_target_pair(host, *t))
+            .map(|target_pair| (target_pair, builder.ensure(Gcc { target_pair })))
+            .collect();
+        Self { dylibs }
     }
 
     /// Install the libgccjit dylibs to the corresponding target directories of the given compiler.
@@ -1626,39 +1651,34 @@ impl GccDylibSet {
 
 /// Output of the `compile::GccCodegenBackend` step.
 ///
-/// It contains paths to all built libgccjit libraries on which this backend depends here.
+/// It contains a build stamp with the path to the built cg_gcc dylib.
 #[derive(Clone)]
 pub struct GccCodegenBackendOutput {
     stamp: BuildStamp,
-    dylib_set: GccDylibSet,
+}
+
+impl GccCodegenBackendOutput {
+    pub fn stamp(&self) -> &BuildStamp {
+        &self.stamp
+    }
 }
 
 /// Builds the GCC codegen backend (`cg_gcc`).
-/// The `cg_gcc` backend uses `libgccjit`, which requires a separate build for each
-/// `host -> target` pair. So if you are on linux-x64 and build for linux-aarch64,
-/// you will need at least:
-/// - linux-x64 -> linux-x64 libgccjit (for building host code like proc macros)
-/// - linux-x64 -> linux-aarch64 libgccjit (for the aarch64 target code)
-///
-/// We model this by having a single cg_gcc for a given host target, which contains one
-/// libgccjit per (host, target) pair.
-/// Note that the host target is taken from `self.compilers.target_compiler.host`.
+/// Note that this **does not** build libgccjit, which is a dependency of cg_gcc.
+/// That has to be built separately, because a separate copy of libgccjit is required
+/// for each (host, target) compilation pair.
+/// cg_gcc goes to great lengths to ensure that it does not *directly* link to libgccjit,
+/// so we respect that here and allow building cg_gcc without building libgccjit itself.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GccCodegenBackend {
     compilers: RustcPrivateCompilers,
-    targets: Vec<TargetSelection>,
+    target: TargetSelection,
 }
 
 impl GccCodegenBackend {
-    /// Build `cg_gcc` that will run on host `H` (`compilers.target_compiler.host`) and will be
-    /// able to produce code target pairs (`H`, `T`) for all `T` from `targets`.
-    pub fn for_targets(
-        compilers: RustcPrivateCompilers,
-        mut targets: Vec<TargetSelection>,
-    ) -> Self {
-        // Sort targets to improve step cache hits
-        targets.sort();
-        Self { compilers, targets }
+    /// Build `cg_gcc` that will run on the given host target.
+    pub fn for_target(compilers: RustcPrivateCompilers, target: TargetSelection) -> Self {
+        Self { compilers, target }
     }
 }
 
@@ -1672,10 +1692,8 @@ impl Step for GccCodegenBackend {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        // By default, build cg_gcc that will only be able to compile native code for the given
-        // host target.
         let compilers = RustcPrivateCompilers::new(run.builder, run.builder.top_stage, run.target);
-        run.builder.ensure(GccCodegenBackend { compilers, targets: vec![run.target] });
+        run.builder.ensure(GccCodegenBackend::for_target(compilers, run.target));
     }
 
     fn run(self, builder: &Builder<'_>) -> Self::Output {
@@ -1689,19 +1707,7 @@ impl Step for GccCodegenBackend {
             &CodegenBackendKind::Gcc,
         );
 
-        let dylib_set = GccDylibSet {
-            dylibs: self
-                .targets
-                .iter()
-                .map(|&target| {
-                    let target_pair = GccTargetPair::for_target_pair(host, target);
-                    (target_pair, builder.ensure(Gcc { target_pair }))
-                })
-                .collect(),
-            host_pair: GccTargetPair::for_native_build(host),
-        };
-
-        if builder.config.keep_stage.contains(&build_compiler.stage) {
+        if builder.config.keep_stage.contains(&build_compiler.stage) && stamp.path().exists() {
             trace!("`keep-stage` requested");
             builder.info(
                 "WARNING: Using a potentially old codegen backend. \
@@ -1709,7 +1715,7 @@ impl Step for GccCodegenBackend {
             );
             // Codegen backends are linked separately from this step today, so we don't do
             // anything here.
-            return GccCodegenBackendOutput { stamp, dylib_set };
+            return GccCodegenBackendOutput { stamp };
         }
 
         let mut cargo = builder::Cargo::new(
@@ -1723,15 +1729,12 @@ impl Step for GccCodegenBackend {
         cargo.arg("--manifest-path").arg(builder.src.join("compiler/rustc_codegen_gcc/Cargo.toml"));
         rustc_cargo_env(builder, &mut cargo, host);
 
-        add_cg_gcc_cargo_flags(&mut cargo, dylib_set.host_dylib());
-
         let _guard =
             builder.msg(Kind::Build, "codegen backend gcc", Mode::Codegen, build_compiler, host);
-        let files = run_cargo(builder, cargo, vec![], &stamp, vec![], false, false);
+        let files = run_cargo(builder, cargo, vec![], &stamp, vec![], ArtifactKeepMode::OnlyRlib);
 
         GccCodegenBackendOutput {
             stamp: write_codegen_backend_stamp(stamp, files, builder.config.dry_run()),
-            dylib_set,
         }
     }
 
@@ -1804,7 +1807,7 @@ impl Step for CraneliftCodegenBackend {
             build_compiler,
             target,
         );
-        let files = run_cargo(builder, cargo, vec![], &stamp, vec![], false, false);
+        let files = run_cargo(builder, cargo, vec![], &stamp, vec![], ArtifactKeepMode::OnlyRlib);
         write_codegen_backend_stamp(stamp, files, builder.config.dry_run())
     }
 
@@ -2457,12 +2460,18 @@ impl Step for Assemble {
                         // GCC dylibs built below by taking a look at the current stage and whether
                         // cg_gcc is used as the default codegen backend.
 
+                        // First, the easy part: build cg_gcc
                         let compilers = prepare_compilers();
+                        let cg_gcc = builder
+                            .ensure(GccCodegenBackend::for_target(compilers, target_compiler.host));
+                        copy_codegen_backends_to_sysroot(builder, cg_gcc.stamp, target_compiler);
+
+                        // Then, the hard part: prepare all required libgccjit dylibs.
 
                         // The left side of the target pairs below is implied. It has to match the
-                        // host target on which cg_gcc will run, which is the host target of
+                        // host target on which libgccjit will be used, which is the host target of
                         // `target_compiler`. We only pass the right side of the target pairs to
-                        // the `GccCodegenBackend` constructor.
+                        // the `GccDylibSet` constructor.
                         let mut targets = HashSet::new();
                         // Add all host targets, so that we are able to build host code in this
                         // bootstrap invocation using cg_gcc.
@@ -2477,14 +2486,16 @@ impl Step for Assemble {
                         // host code (e.g. proc macros) using cg_gcc.
                         targets.insert(compilers.target_compiler().host);
 
-                        let output = builder.ensure(GccCodegenBackend::for_targets(
-                            compilers,
+                        // Now build all the required libgccjit dylibs
+                        let dylib_set = GccDylibSet::build(
+                            builder,
+                            compilers.target_compiler().host,
                             targets.into_iter().collect(),
-                        ));
-                        copy_codegen_backends_to_sysroot(builder, output.stamp, target_compiler);
-                        // Also copy all requires libgccjit dylibs to the corresponding
-                        // library sysroots, so that they are available for the codegen backend.
-                        output.dylib_set.install_to(builder, target_compiler);
+                        );
+
+                        // And then copy all the dylibs to the corresponding
+                        // library sysroots, so that they are available for cg_gcc.
+                        dylib_set.install_to(builder, target_compiler);
                     }
                     CodegenBackendKind::Llvm | CodegenBackendKind::Custom(_) => continue,
                 }
@@ -2626,14 +2637,26 @@ pub fn add_to_sysroot(
     }
 }
 
+/// Specifies which rlib/rmeta artifacts outputted by Cargo should be put into the resulting
+/// build stamp, and thus be included in dist archives and copied into sysroots by default.
+/// Note that some kinds of artifacts are copied automatically (e.g. native libraries).
+pub enum ArtifactKeepMode {
+    /// Only keep .rlib files, ignore .rmeta files
+    OnlyRlib,
+    /// Only keep .rmeta files, ignore .rlib files
+    OnlyRmeta,
+    /// Custom logic for keeping an artifact
+    /// It receives the filename of an artifact, and returns true if it should be kept.
+    Custom(Box<dyn Fn(&str) -> bool>),
+}
+
 pub fn run_cargo(
     builder: &Builder<'_>,
     cargo: Cargo,
     tail_args: Vec<String>,
     stamp: &BuildStamp,
     additional_target_deps: Vec<(PathBuf, DependencyType)>,
-    is_check: bool,
-    rlib_only_metadata: bool,
+    artifact_keep_mode: ArtifactKeepMode,
 ) -> Vec<PathBuf> {
     // `target_root_dir` looks like $dir/$target/release
     let target_root_dir = stamp.path().parent().unwrap();
@@ -2667,36 +2690,20 @@ pub fn run_cargo(
         };
         for filename in filenames_vec {
             // Skip files like executables
-            let mut keep = false;
-            if filename.ends_with(".lib")
+            let keep = if filename.ends_with(".lib")
                 || filename.ends_with(".a")
                 || is_debug_info(&filename)
                 || is_dylib(Path::new(&*filename))
             {
                 // Always keep native libraries, rust dylibs and debuginfo
-                keep = true;
-            }
-            if is_check && filename.ends_with(".rmeta") {
-                // During check builds we need to keep crate metadata
-                keep = true;
-            } else if rlib_only_metadata {
-                if filename.contains("jemalloc_sys")
-                    || filename.contains("rustc_public_bridge")
-                    || filename.contains("rustc_public")
-                {
-                    // jemalloc_sys and rustc_public_bridge are not linked into librustc_driver.so,
-                    // so we need to distribute them as rlib to be able to use them.
-                    keep |= filename.ends_with(".rlib");
-                } else {
-                    // Distribute the rest of the rustc crates as rmeta files only to reduce
-                    // the tarball sizes by about 50%. The object files are linked into
-                    // librustc_driver.so, so it is still possible to link against them.
-                    keep |= filename.ends_with(".rmeta");
-                }
+                true
             } else {
-                // In all other cases keep all rlibs
-                keep |= filename.ends_with(".rlib");
-            }
+                match &artifact_keep_mode {
+                    ArtifactKeepMode::OnlyRlib => filename.ends_with(".rlib"),
+                    ArtifactKeepMode::OnlyRmeta => filename.ends_with(".rmeta"),
+                    ArtifactKeepMode::Custom(func) => func(&filename),
+                }
+            };
 
             if !keep {
                 continue;
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index aa890f13f0e1..f47b0c0b0072 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -1652,23 +1652,7 @@ impl Step for CraneliftCodegenBackend {
             return None;
         }
 
-        // Get the relative path of where the codegen backend should be stored.
-        let backends_dst = builder.sysroot_codegen_backends(compilers.target_compiler());
-        let backends_rel = backends_dst
-            .strip_prefix(builder.sysroot(compilers.target_compiler()))
-            .unwrap()
-            .strip_prefix(builder.sysroot_libdir_relative(compilers.target_compiler()))
-            .unwrap();
-        // Don't use custom libdir here because ^lib/ will be resolved again with installer
-        let backends_dst = PathBuf::from("lib").join(backends_rel);
-
-        let codegen_backend_dylib = get_codegen_backend_file(&stamp);
-        tarball.add_renamed_file(
-            &codegen_backend_dylib,
-            &backends_dst,
-            &normalize_codegen_backend_name(builder, &codegen_backend_dylib),
-            FileType::NativeLibrary,
-        );
+        add_codegen_backend_to_tarball(builder, &tarball, compilers.target_compiler(), &stamp);
 
         Some(tarball.generate())
     }
@@ -1681,6 +1665,113 @@ impl Step for CraneliftCodegenBackend {
     }
 }
 
+/// Builds a dist component containing the GCC codegen backend.
+/// Note that for this backend to work, it must have a set of libgccjit dylibs available
+/// at runtime.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct GccCodegenBackend {
+    pub compilers: RustcPrivateCompilers,
+    pub target: TargetSelection,
+}
+
+impl Step for GccCodegenBackend {
+    type Output = Option<GeneratedTarball>;
+    const IS_HOST: bool = true;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.alias("rustc_codegen_gcc")
+    }
+
+    fn is_default_step(builder: &Builder<'_>) -> bool {
+        // We only want to build the gcc backend in `x dist` if the backend was enabled
+        // in rust.codegen-backends.
+        // Sadly, we don't have access to the actual target for which we're disting clif here..
+        // So we just use the host target.
+        builder
+            .config
+            .enabled_codegen_backends(builder.host_target)
+            .contains(&CodegenBackendKind::Gcc)
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(GccCodegenBackend {
+            compilers: RustcPrivateCompilers::new(run.builder, run.builder.top_stage, run.target),
+            target: run.target,
+        });
+    }
+
+    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
+        // This prevents rustc_codegen_gcc from being built for "dist"
+        // or "install" on the stable/beta channels. It is not yet stable and
+        // should not be included.
+        if !builder.build.unstable_features() {
+            return None;
+        }
+
+        let target = self.target;
+        if target != "x86_64-unknown-linux-gnu" {
+            builder
+                .info(&format!("target `{target}` not supported by rustc_codegen_gcc. skipping"));
+            return None;
+        }
+
+        let mut tarball = Tarball::new(builder, "rustc-codegen-gcc", &target.triple);
+        tarball.set_overlay(OverlayKind::RustcCodegenGcc);
+        tarball.is_preview(true);
+        tarball.add_legal_and_readme_to("share/doc/rustc_codegen_gcc");
+
+        let compilers = self.compilers;
+        let backend = builder.ensure(compile::GccCodegenBackend::for_target(compilers, target));
+
+        if builder.config.dry_run() {
+            return None;
+        }
+
+        add_codegen_backend_to_tarball(
+            builder,
+            &tarball,
+            compilers.target_compiler(),
+            backend.stamp(),
+        );
+
+        Some(tarball.generate())
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(
+            StepMetadata::dist("rustc_codegen_gcc", self.target)
+                .built_by(self.compilers.build_compiler()),
+        )
+    }
+}
+
+/// Add a codegen backend built for `compiler`, with its artifacts stored in `stamp`, to the given
+/// `tarball` at the correct place.
+fn add_codegen_backend_to_tarball(
+    builder: &Builder<'_>,
+    tarball: &Tarball<'_>,
+    compiler: Compiler,
+    stamp: &BuildStamp,
+) {
+    // Get the relative path of where the codegen backend should be stored.
+    let backends_dst = builder.sysroot_codegen_backends(compiler);
+    let backends_rel = backends_dst
+        .strip_prefix(builder.sysroot(compiler))
+        .unwrap()
+        .strip_prefix(builder.sysroot_libdir_relative(compiler))
+        .unwrap();
+    // Don't use custom libdir here because ^lib/ will be resolved again with installer
+    let backends_dst = PathBuf::from("lib").join(backends_rel);
+
+    let codegen_backend_dylib = get_codegen_backend_file(stamp);
+    tarball.add_renamed_file(
+        &codegen_backend_dylib,
+        &backends_dst,
+        &normalize_codegen_backend_name(builder, &codegen_backend_dylib),
+        FileType::NativeLibrary,
+    );
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct Rustfmt {
     pub compilers: RustcPrivateCompilers,
@@ -2871,24 +2962,26 @@ impl Step for ReproducibleArtifacts {
 /// Tarball containing a prebuilt version of the libgccjit library,
 /// needed as a dependency for the GCC codegen backend (similarly to the LLVM
 /// backend needing a prebuilt libLLVM).
+///
+/// This component is used for `download-ci-gcc`.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct Gcc {
+pub struct GccDev {
     target: TargetSelection,
 }
 
-impl Step for Gcc {
+impl Step for GccDev {
     type Output = GeneratedTarball;
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.alias("gcc")
+        run.alias("gcc-dev")
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(Gcc { target: run.target });
+        run.builder.ensure(GccDev { target: run.target });
     }
 
     fn run(self, builder: &Builder<'_>) -> Self::Output {
-        let tarball = Tarball::new(builder, "gcc", &self.target.triple);
+        let tarball = Tarball::new(builder, "gcc-dev", &self.target.triple);
         let output = builder
             .ensure(super::gcc::Gcc { target_pair: GccTargetPair::for_native_build(self.target) });
         tarball.add_file(output.libgccjit(), "lib", FileType::NativeLibrary);
@@ -2896,6 +2989,6 @@ impl Step for Gcc {
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
-        Some(StepMetadata::dist("gcc", self.target))
+        Some(StepMetadata::dist("gcc-dev", self.target))
     }
 }
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index a3c13fc4b095..f3a1c6b0e3dd 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -14,7 +14,7 @@ use std::{env, fs, iter};
 
 use build_helper::exit;
 
-use crate::core::build_steps::compile::{Std, run_cargo};
+use crate::core::build_steps::compile::{ArtifactKeepMode, Std, run_cargo};
 use crate::core::build_steps::doc::{DocumentationFormat, prepare_doc_compiler};
 use crate::core::build_steps::gcc::{Gcc, GccTargetPair, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::llvm::get_llvm_version;
@@ -1582,10 +1582,10 @@ test!(UiFullDeps {
     IS_HOST: true,
 });
 
-test!(Rustdoc {
-    path: "tests/rustdoc",
-    mode: CompiletestMode::Rustdoc,
-    suite: "rustdoc",
+test!(RustdocHtml {
+    path: "tests/rustdoc-html",
+    mode: CompiletestMode::RustdocHtml,
+    suite: "rustdoc-html",
     default: true,
     IS_HOST: true,
 });
@@ -1969,7 +1969,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         if matches!(
             mode,
             CompiletestMode::RunMake
-                | CompiletestMode::Rustdoc
+                | CompiletestMode::RustdocHtml
                 | CompiletestMode::RustdocJs
                 | CompiletestMode::RustdocJson
         ) || matches!(suite, "rustdoc-ui" | "coverage-run-rustdoc")
@@ -2265,6 +2265,8 @@ Please disable assertions with `rust.debug-assertions = false`.
             cmd.arg("--with-std-remap-debuginfo");
         }
 
+        cmd.arg("--jobs").arg(builder.jobs().to_string());
+
         let mut llvm_components_passed = false;
         let mut copts_passed = false;
         if builder.config.llvm_enabled(test_compiler.host) {
@@ -2585,7 +2587,8 @@ impl BookTest {
                 let stamp = BuildStamp::new(&builder.cargo_out(test_compiler, mode, target))
                     .with_prefix(PathBuf::from(dep).file_name().and_then(|v| v.to_str()).unwrap());
 
-                let output_paths = run_cargo(builder, cargo, vec![], &stamp, vec![], false, false);
+                let output_paths =
+                    run_cargo(builder, cargo, vec![], &stamp, vec![], ArtifactKeepMode::OnlyRlib);
                 let directories = output_paths
                     .into_iter()
                     .filter_map(|p| p.parent().map(ToOwned::to_owned))
@@ -2758,7 +2761,7 @@ impl Step for ErrorIndex {
     fn make_run(run: RunConfig<'_>) {
         // error_index_generator depends on librustdoc. Use the compiler that
         // is normally used to build rustdoc for other tests (like compiletest
-        // tests in tests/rustdoc) so that it shares the same artifacts.
+        // tests in tests/rustdoc-html) so that it shares the same artifacts.
         let compilers = RustcPrivateCompilers::new(
             run.builder,
             run.builder.top_stage,
@@ -3159,7 +3162,7 @@ impl Step for CrateRustdoc {
             builder.compiler(builder.top_stage, target)
         } else {
             // Use the previous stage compiler to reuse the artifacts that are
-            // created when running compiletest for tests/rustdoc. If this used
+            // created when running compiletest for tests/rustdoc-html. If this used
             // `compiler`, then it would cause rustdoc to be built *again*, which
             // isn't really necessary.
             builder.compiler_for(builder.top_stage, target, target)
diff --git a/src/bootstrap/src/core/build_steps/test/compiletest.rs b/src/bootstrap/src/core/build_steps/test/compiletest.rs
index 359f6bb1a6ef..230ed75a0868 100644
--- a/src/bootstrap/src/core/build_steps/test/compiletest.rs
+++ b/src/bootstrap/src/core/build_steps/test/compiletest.rs
@@ -21,7 +21,7 @@ pub(crate) enum CompiletestMode {
     MirOpt,
     Pretty,
     RunMake,
-    Rustdoc,
+    RustdocHtml,
     RustdocJs,
     RustdocJson,
     Ui,
@@ -49,7 +49,7 @@ impl CompiletestMode {
             Self::MirOpt => "mir-opt",
             Self::Pretty => "pretty",
             Self::RunMake => "run-make",
-            Self::Rustdoc => "rustdoc",
+            Self::RustdocHtml => "rustdoc-html",
             Self::RustdocJs => "rustdoc-js",
             Self::RustdocJson => "rustdoc-json",
             Self::Ui => "ui",
diff --git a/src/bootstrap/src/core/builder/cli_paths.rs b/src/bootstrap/src/core/builder/cli_paths.rs
index 470e83d341c7..5ff2b380e4b9 100644
--- a/src/bootstrap/src/core/builder/cli_paths.rs
+++ b/src/bootstrap/src/core/builder/cli_paths.rs
@@ -31,8 +31,8 @@ pub(crate) const PATH_REMAP: &[(&str, &[&str])] = &[
             "tests/pretty",
             "tests/run-make",
             "tests/run-make-cargo",
-            "tests/rustdoc",
             "tests/rustdoc-gui",
+            "tests/rustdoc-html",
             "tests/rustdoc-js",
             "tests/rustdoc-js-std",
             "tests/rustdoc-json",
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
index fd18b59a9c6d..4ab84c3cabc1 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
@@ -1,6 +1,5 @@
 ---
 source: src/bootstrap/src/core/builder/cli_paths/tests.rs
-assertion_line: 68
 expression: test
 ---
 [Test] test::Tidy
@@ -38,9 +37,9 @@ expression: test
 [Test] test::UiFullDeps
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/ui-fulldeps)
-[Test] test::Rustdoc
+[Test] test::RustdocHtml
     targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
+    - Suite(test::tests/rustdoc-html)
 [Test] test::CoverageRunRustdoc
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/coverage-run-rustdoc)
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap
index 6522a7e8edaf..c8eee72aec42 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap
@@ -5,9 +5,6 @@ expression: test librustdoc rustdoc
 [Test] test::CrateRustdoc
     targets: [x86_64-unknown-linux-gnu]
     - Set({test::src/librustdoc, test::src/tools/rustdoc})
-[Test] test::Rustdoc
-    targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
 [Test] test::RustdocBook
     targets: [x86_64-unknown-linux-gnu]
     - Set({test::src/doc/rustdoc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc_html.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc_html.snap
new file mode 100644
index 000000000000..21acc1e46069
--- /dev/null
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc_html.snap
@@ -0,0 +1,10 @@
+---
+source: src/bootstrap/src/core/builder/cli_paths/tests.rs
+expression: test librustdoc rustdoc-html
+---
+[Test] test::CrateRustdoc
+    targets: [x86_64-unknown-linux-gnu]
+    - Set({test::src/librustdoc})
+[Test] test::RustdocHtml
+    targets: [x86_64-unknown-linux-gnu]
+    - Suite(test::tests/rustdoc-html)
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc.snap
index 337ad33fe35f..897372dcd1c7 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc.snap
@@ -2,9 +2,6 @@
 source: src/bootstrap/src/core/builder/cli_paths/tests.rs
 expression: test rustdoc
 ---
-[Test] test::Rustdoc
-    targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
 [Test] test::CrateRustdoc
     targets: [x86_64-unknown-linux-gnu]
     - Set({test::src/tools/rustdoc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc_html.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc_html.snap
new file mode 100644
index 000000000000..a6a2a27c075e
--- /dev/null
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_rustdoc_html.snap
@@ -0,0 +1,7 @@
+---
+source: src/bootstrap/src/core/builder/cli_paths/tests.rs
+expression: test rustdoc-html
+---
+[Test] test::RustdocHtml
+    targets: [x86_64-unknown-linux-gnu]
+    - Suite(test::tests/rustdoc-html)
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
index 171680515476..2a4805e4fd68 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
@@ -1,6 +1,5 @@
 ---
 source: src/bootstrap/src/core/builder/cli_paths/tests.rs
-assertion_line: 68
 expression: test --skip=coverage
 ---
 [Test] test::Tidy
@@ -37,9 +36,9 @@ expression: test --skip=coverage
 [Test] test::UiFullDeps
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/ui-fulldeps)
-[Test] test::Rustdoc
+[Test] test::RustdocHtml
     targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
+    - Suite(test::tests/rustdoc-html)
 [Test] test::CoverageRunRustdoc
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/coverage-run-rustdoc)
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests.snap
index b38af13d49c3..ad9660ef5c91 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests.snap
@@ -38,12 +38,12 @@ expression: test tests
 [Test] test::RunMakeCargo
     targets: [aarch64-unknown-linux-gnu]
     - Suite(test::tests/run-make-cargo)
-[Test] test::Rustdoc
-    targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
 [Test] test::RustdocGUI
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/rustdoc-gui)
+[Test] test::RustdocHtml
+    targets: [x86_64-unknown-linux-gnu]
+    - Suite(test::tests/rustdoc-html)
 [Test] test::RustdocJSNotStd
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/rustdoc-js)
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests_skip_coverage.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests_skip_coverage.snap
index 6a158ea62bb3..4572f089b0ae 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests_skip_coverage.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_tests_skip_coverage.snap
@@ -35,12 +35,12 @@ expression: test tests --skip=coverage
 [Test] test::RunMakeCargo
     targets: [aarch64-unknown-linux-gnu]
     - Suite(test::tests/run-make-cargo)
-[Test] test::Rustdoc
-    targets: [x86_64-unknown-linux-gnu]
-    - Suite(test::tests/rustdoc)
 [Test] test::RustdocGUI
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/rustdoc-gui)
+[Test] test::RustdocHtml
+    targets: [x86_64-unknown-linux-gnu]
+    - Suite(test::tests/rustdoc-html)
 [Test] test::RustdocJSNotStd
     targets: [x86_64-unknown-linux-gnu]
     - Suite(test::tests/rustdoc-js)
diff --git a/src/bootstrap/src/core/builder/cli_paths/tests.rs b/src/bootstrap/src/core/builder/cli_paths/tests.rs
index 49f75c8bea77..39293abd4fb9 100644
--- a/src/bootstrap/src/core/builder/cli_paths/tests.rs
+++ b/src/bootstrap/src/core/builder/cli_paths/tests.rs
@@ -169,7 +169,9 @@ declare_tests!(
     (x_test_library, "test library"),
     (x_test_librustdoc, "test librustdoc"),
     (x_test_librustdoc_rustdoc, "test librustdoc rustdoc"),
+    (x_test_librustdoc_rustdoc_html, "test librustdoc rustdoc-html"),
     (x_test_rustdoc, "test rustdoc"),
+    (x_test_rustdoc_html, "test rustdoc-html"),
     (x_test_skip_coverage, "test --skip=coverage"),
     // FIXME(Zalathar): This doesn't skip the coverage-map or coverage-run tests.
     (x_test_skip_tests, "test --skip=tests"),
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 7d2b1685bda9..4a04b97c549a 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -880,7 +880,7 @@ impl<'a> Builder<'a> {
                 test::Incremental,
                 test::Debuginfo,
                 test::UiFullDeps,
-                test::Rustdoc,
+                test::RustdocHtml,
                 test::CoverageRunRustdoc,
                 test::Pretty,
                 test::CodegenCranelift,
@@ -967,6 +967,7 @@ impl<'a> Builder<'a> {
                 dist::Mingw,
                 dist::Rustc,
                 dist::CraneliftCodegenBackend,
+                dist::GccCodegenBackend,
                 dist::Std,
                 dist::RustcDev,
                 dist::Analysis,
@@ -989,7 +990,7 @@ impl<'a> Builder<'a> {
                 dist::PlainSourceTarballGpl,
                 dist::BuildManifest,
                 dist::ReproducibleArtifacts,
-                dist::Gcc
+                dist::GccDev
             ),
             Kind::Install => describe!(
                 install::Docs,
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 9146c470e358..66614cc6cced 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2099,7 +2099,7 @@ mod snapshot {
         [test] compiletest-debuginfo 1 <host>
         [test] compiletest-ui-fulldeps 1 <host>
         [build] rustdoc 1 <host>
-        [test] compiletest-rustdoc 1 <host>
+        [test] compiletest-rustdoc-html 1 <host>
         [test] compiletest-coverage-run-rustdoc 1 <host>
         [test] compiletest-pretty 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
@@ -2169,7 +2169,7 @@ mod snapshot {
         let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("test")
-                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc", "rustdoc-gui", "incremental"])
+                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc-html", "rustdoc-gui", "incremental"])
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
@@ -2180,11 +2180,10 @@ mod snapshot {
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
         [build] rustdoc 1 <host>
         [test] compiletest-run-make 1 <host>
-        [test] compiletest-rustdoc 1 <host>
+        [test] compiletest-rustdoc-html 1 <host>
         [build] rustc 0 <host> -> RustdocGUITest 1 <host>
         [test] rustdoc-gui 1 <host>
         [test] compiletest-incremental 1 <host>
-        [build] rustc 1 <host> -> rustc 2 <host>
         ");
     }
 
@@ -2193,7 +2192,7 @@ mod snapshot {
         let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("test")
-                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc", "rustdoc-gui", "incremental"])
+                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc-html", "rustdoc-gui", "incremental"])
                 .stage(2)
                 .render_steps(), @r"
         [build] llvm <host>
@@ -2208,11 +2207,10 @@ mod snapshot {
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <host>
-        [test] compiletest-rustdoc 2 <host>
+        [test] compiletest-rustdoc-html 2 <host>
         [build] rustc 0 <host> -> RustdocGUITest 1 <host>
         [test] rustdoc-gui 2 <host>
         [test] compiletest-incremental 2 <host>
-        [build] rustdoc 1 <host>
         ");
     }
 
@@ -2241,12 +2239,11 @@ mod snapshot {
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <target1>
-        [test] compiletest-rustdoc 2 <target1>
+        [build] rustc 1 <host> -> rustc 2 <target1>
+        [build] rustdoc 1 <host>
         [build] rustc 0 <host> -> RustdocGUITest 1 <host>
         [test] rustdoc-gui 2 <target1>
         [test] compiletest-incremental 2 <target1>
-        [build] rustc 1 <host> -> rustc 2 <target1>
-        [build] rustdoc 1 <host>
         [build] rustc 2 <target1> -> std 2 <target1>
         [build] rustdoc 2 <target1>
         ");
@@ -2283,7 +2280,7 @@ mod snapshot {
         [build] rustc 2 <host> -> rustc 3 <host>
         [test] compiletest-ui-fulldeps 2 <host>
         [build] rustdoc 2 <host>
-        [test] compiletest-rustdoc 2 <host>
+        [test] compiletest-rustdoc-html 2 <host>
         [test] compiletest-coverage-run-rustdoc 2 <host>
         [test] compiletest-pretty 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index d950dc1a1c58..074404b4cdf3 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -381,7 +381,7 @@ impl Config {
         }
         let base = &self.stage0_metadata.config.artifacts_server;
         let version = self.artifact_version_part(gcc_sha);
-        let filename = format!("gcc-{version}-{}.tar.xz", self.host_target.triple);
+        let filename = format!("gcc-dev-{version}-{}.tar.xz", self.host_target.triple);
         let tarball = gcc_cache.join(&filename);
         if !tarball.exists() {
             let help_on_error = "ERROR: failed to download gcc from ci
@@ -396,7 +396,7 @@ impl Config {
     ";
             self.download_file(&format!("{base}/{gcc_sha}/{filename}"), &tarball, help_on_error);
         }
-        self.unpack(&tarball, root_dir, "gcc");
+        self.unpack(&tarball, root_dir, "gcc-dev");
     }
 }
 
diff --git a/src/bootstrap/src/utils/tarball.rs b/src/bootstrap/src/utils/tarball.rs
index 079afb7a0054..7db06dcc3e9a 100644
--- a/src/bootstrap/src/utils/tarball.rs
+++ b/src/bootstrap/src/utils/tarball.rs
@@ -25,6 +25,7 @@ pub(crate) enum OverlayKind {
     Rustfmt,
     RustAnalyzer,
     RustcCodegenCranelift,
+    RustcCodegenGcc,
     LlvmBitcodeLinker,
 }
 
@@ -66,6 +67,11 @@ impl OverlayKind {
                 "compiler/rustc_codegen_cranelift/LICENSE-APACHE",
                 "compiler/rustc_codegen_cranelift/LICENSE-MIT",
             ],
+            OverlayKind::RustcCodegenGcc => &[
+                "compiler/rustc_codegen_gcc/Readme.md",
+                "compiler/rustc_codegen_gcc/LICENSE-APACHE",
+                "compiler/rustc_codegen_gcc/LICENSE-MIT",
+            ],
             OverlayKind::LlvmBitcodeLinker => &[
                 "COPYRIGHT",
                 "LICENSE-APACHE",
@@ -93,6 +99,7 @@ impl OverlayKind {
                 .rust_analyzer_info
                 .version(builder, &builder.release_num("rust-analyzer/crates/rust-analyzer")),
             OverlayKind::RustcCodegenCranelift => builder.rust_version(),
+            OverlayKind::RustcCodegenGcc => builder.rust_version(),
             OverlayKind::LlvmBitcodeLinker => builder.rust_version(),
         }
     }
diff --git a/src/build_helper/src/git.rs b/src/build_helper/src/git.rs
index 42d9b00f004a..1fdc2ddb4cfc 100644
--- a/src/build_helper/src/git.rs
+++ b/src/build_helper/src/git.rs
@@ -152,6 +152,14 @@ pub fn has_changed_since(git_dir: &Path, base: &str, paths: &[&str]) -> bool {
     })
 }
 
+const LEGACY_BORS_EMAIL: &str = "bors@rust-lang.org";
+
+/// Escape characters from the git user e-mail, so that git commands do not interpret it as regex
+/// special characters.
+fn escape_email_git_regex(text: &str) -> String {
+    text.replace("[", "\\[").replace("]", "\\]").replace(".", "\\.")
+}
+
 /// Returns the latest upstream commit that modified `target_paths`, or `None` if no such commit
 /// was found.
 fn get_latest_upstream_commit_that_modified_files(
@@ -182,9 +190,15 @@ fn get_latest_upstream_commit_that_modified_files(
         "-n1",
         &upstream,
         "--author",
-        git_config.git_merge_commit_email,
+        &escape_email_git_regex(git_config.git_merge_commit_email),
     ]);
 
+    // Also search for legacy bors account, before we accrue enough commits to
+    // have changes to all relevant file paths done by new bors.
+    if git_config.git_merge_commit_email != LEGACY_BORS_EMAIL {
+        git.args(["--author", LEGACY_BORS_EMAIL]);
+    }
+
     if !target_paths.is_empty() {
         git.arg("--").args(target_paths);
     }
@@ -229,11 +243,17 @@ pub fn get_closest_upstream_commit(
     git.args([
         "rev-list",
         "--author-date-order",
-        &format!("--author={}", config.git_merge_commit_email),
+        &format!("--author={}", &escape_email_git_regex(config.git_merge_commit_email),),
         "-n1",
         base,
     ]);
 
+    // Also search for legacy bors account, before we accrue enough commits to
+    // have changes to all relevant file paths done by new bors.
+    if config.git_merge_commit_email != LEGACY_BORS_EMAIL {
+        git.args(["--author", LEGACY_BORS_EMAIL]);
+    }
+
     let output = output_result(&mut git)?.trim().to_owned();
     if output.is_empty() { Ok(None) } else { Ok(Some(output)) }
 }
diff --git a/src/ci/citool/tests/test-jobs.yml b/src/ci/citool/tests/test-jobs.yml
index 512c80628574..e26104905491 100644
--- a/src/ci/citool/tests/test-jobs.yml
+++ b/src/ci/citool/tests/test-jobs.yml
@@ -27,7 +27,7 @@ runners:
     <<: *base-job
 envs:
   env-x86_64-apple-tests: &env-x86_64-apple-tests
-    SCRIPT: ./x.py check compiletest && ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc -- --exact
+    SCRIPT: ./x.py check compiletest && ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc-html -- --exact
     RUST_CONFIGURE_ARGS: --build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc
     RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
     # Ensure that host tooling is tested on our minimum supported macOS version.
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh b/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
index 4c95d4a401e5..f77a0d562f03 100755
--- a/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
+++ b/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
@@ -7,10 +7,12 @@ python3 ../x.py build --set rust.debug=true opt-dist
 ./build/$HOSTS/stage1-tools-bin/opt-dist linux-ci -- python3 ../x.py dist \
     --host $HOSTS --target $HOSTS \
     --include-default-paths \
-    build-manifest bootstrap
+    build-manifest \
+    bootstrap \
+    rustc_codegen_gcc
 
-# Use GCC for building GCC, as it seems to behave badly when built with Clang
+# Use GCC for building GCC components, as it seems to behave badly when built with Clang
 # Only build GCC on full builds, not try builds
 if [ "${DIST_TRY_BUILD:-0}" == "0" ]; then
-    CC=/rustroot/bin/cc CXX=/rustroot/bin/c++ python3 ../x.py dist gcc
+    CC=/rustroot/bin/cc CXX=/rustroot/bin/c++ python3 ../x.py dist gcc-dev
 fi
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
index 0fd14ae232d7..f9c1ea531add 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
@@ -45,7 +45,7 @@ ENV SCRIPT python3 ../x.py \
   --test-codegen-backend gcc \
   --skip tests/coverage \
   --skip tests/coverage-run-rustdoc \
-  --skip tests/rustdoc \
+  --skip tests/rustdoc-html \
   --skip tests/rustdoc-gui \
   --skip tests/rustdoc-js \
   --skip tests/rustdoc-js-std \
diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index 044f5a8fff32..691b8b8deb81 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -312,16 +312,6 @@ else
   command=(/checkout/src/ci/run.sh)
 fi
 
-if isCI; then
-  # Get some needed information for $BASE_COMMIT
-  #
-  # This command gets the last merge commit which we'll use as base to list
-  # deleted files since then.
-  BASE_COMMIT="$(git log --author=bors@rust-lang.org -n 2 --pretty=format:%H | tail -n 1)"
-else
-  BASE_COMMIT=""
-fi
-
 SUMMARY_FILE=github-summary.md
 touch $objdir/${SUMMARY_FILE}
 
@@ -359,7 +349,6 @@ docker \
   --env RUST_CI_OVERRIDE_RELEASE_CHANNEL \
   --env CI_JOB_NAME="${CI_JOB_NAME-$image}" \
   --env CI_JOB_DOC_URL="${CI_JOB_DOC_URL}" \
-  --env BASE_COMMIT="$BASE_COMMIT" \
   --env DIST_TRY_BUILD \
   --env PR_CI_JOB \
   --env OBJDIR_ON_HOST="$objdir" \
diff --git a/src/ci/scripts/verify-channel.sh b/src/ci/scripts/verify-channel.sh
index 9a9e713243d7..cac8ba332ed1 100755
--- a/src/ci/scripts/verify-channel.sh
+++ b/src/ci/scripts/verify-channel.sh
@@ -8,7 +8,8 @@ IFS=$'\n\t'
 
 source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"
 
-if isCiBranch auto || isCiBranch try || isCiBranch try-perf || isCiBranch automation/bors/try; then
+if isCiBranch auto || isCiBranch try || isCiBranch try-perf || \
+   isCiBranch automation/bors/try || isCiBranch automation/bors/auto; then
     echo "channel verification is only executed on PR builds"
     exit
 fi
diff --git a/src/doc/rustc-dev-guide/src/SUMMARY.md b/src/doc/rustc-dev-guide/src/SUMMARY.md
index e80ee6a5137d..2dd07144a78c 100644
--- a/src/doc/rustc-dev-guide/src/SUMMARY.md
+++ b/src/doc/rustc-dev-guide/src/SUMMARY.md
@@ -100,7 +100,7 @@
 - [Parallel compilation](./parallel-rustc.md)
 - [Rustdoc internals](./rustdoc-internals.md)
     - [Search](./rustdoc-internals/search.md)
-	- [The `rustdoc` test suite](./rustdoc-internals/rustdoc-test-suite.md)
+	- [The `rustdoc-html` test suite](./rustdoc-internals/rustdoc-html-test-suite.md)
 	- [The `rustdoc-gui` test suite](./rustdoc-internals/rustdoc-gui-test-suite.md)
 	- [The `rustdoc-json` test suite](./rustdoc-internals/rustdoc-json-test-suite.md)
 - [GPU offload internals](./offload/internals.md)
diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index d2b4e791df0e..c43c1f680acf 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -22,6 +22,7 @@ The following external projects are managed using some form of a `subtree`:
 * [rustfmt](https://github.com/rust-lang/rustfmt)
 * [rust-analyzer](https://github.com/rust-lang/rust-analyzer)
 * [rustc_codegen_cranelift](https://github.com/rust-lang/rustc_codegen_cranelift)
+* [rustc_codegen_gcc](https://github.com/rust-lang/rustc_codegen_gcc)
 * [rustc-dev-guide](https://github.com/rust-lang/rustc-dev-guide)
 * [compiler-builtins](https://github.com/rust-lang/compiler-builtins)
 * [stdarch](https://github.com/rust-lang/stdarch)
@@ -40,6 +41,7 @@ implement a new tool feature or test, that should happen in one collective rustc
     * `portable-simd` ([sync script](https://github.com/rust-lang/portable-simd/blob/master/subtree-sync.sh))
     * `rustfmt`
     * `rustc_codegen_cranelift` ([sync script](https://github.com/rust-lang/rustc_codegen_cranelift/blob/113af154d459e41b3dc2c5d7d878e3d3a8f33c69/scripts/rustup.sh#L7))
+    * `rustc_codegen_gcc` ([sync guide](https://github.com/rust-lang/rustc_codegen_gcc/blob/master/doc/subtree.md))
 * Using the [josh](#synchronizing-a-josh-subtree) tool
     * `miri`
     * `rust-analyzer`
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-html-test-suite.md
similarity index 98%
rename from src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
rename to src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-html-test-suite.md
index 9516968df803..b74405d310eb 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-html-test-suite.md
@@ -1,6 +1,6 @@
-# The `rustdoc` test suite
+# The `rustdoc-html` test suite
 
-This page is about the test suite named `rustdoc` used to test the HTML output of `rustdoc`.
+This page is about the test suite named `rustdoc-html` used to test the HTML output of `rustdoc`.
 For other rustdoc-specific test suites, see [Rustdoc test suites].
 
 Each test file in this test suite is simply a Rust source file `file.rs` sprinkled with
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index 5781a12ca44c..7a846b711326 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -24,7 +24,7 @@ Also, talk about how it works
 ## jsondocck
 
 [jsondocck] processes directives given in comments, to assert that the values in the output are expected.
-It's a lot like [htmldocck](./rustdoc-test-suite.md) in that way.
+It's a lot like [htmldocck](./rustdoc-html-test-suite.md) in that way.
 
 It uses [JSONPath] as a query language, which takes a path, and returns a *list* of values that that path is said to match to.
 
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index e0924f8538ef..d69e0a5ce988 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -82,7 +82,7 @@ The following test suites are available, with links for more information:
 
 | Test suite                           | Purpose                                                                  |
 |--------------------------------------|--------------------------------------------------------------------------|
-| [`rustdoc`][rustdoc-html-tests]      | Check HTML output of `rustdoc`                                           |
+| [`rustdoc-html`][rustdoc-html-tests]      | Check HTML output of `rustdoc`                                           |
 | [`rustdoc-gui`][rustdoc-gui-tests]   | Check `rustdoc`'s GUI using a web browser                                |
 | [`rustdoc-js`][rustdoc-js-tests]     | Check `rustdoc`'s search engine and index                                |
 | [`rustdoc-js-std`][rustdoc-js-tests] | Check `rustdoc`'s search engine and index on the std library docs        |
@@ -94,7 +94,7 @@ These tests ensure that certain lints that are emitted as part of executing rust
 are also run when executing rustc.
 Run-make tests pertaining to rustdoc are typically named `run-make/rustdoc-*/`.
 
-[rustdoc-html-tests]: ../rustdoc-internals/rustdoc-test-suite.md
+[rustdoc-html-tests]: ../rustdoc-internals/rustdoc-html-test-suite.md
 [rustdoc-gui-tests]: ../rustdoc-internals/rustdoc-gui-test-suite.md
 [rustdoc-js-tests]: ../rustdoc-internals/search.md#testing-the-search-engine
 [rustdoc-json-tests]: ../rustdoc-internals/rustdoc-json-test-suite.md
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 4852c3623b05..52e1f09dca0f 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -308,12 +308,12 @@ Asked in
 
 #### Test-suite-specific directives
 
-The test suites [`rustdoc`][rustdoc-html-tests], [`rustdoc-js`/`rustdoc-js-std`][rustdoc-js-tests]
+The test suites [`rustdoc-html`][rustdoc-html-tests], [`rustdoc-js`/`rustdoc-js-std`][rustdoc-js-tests]
 and [`rustdoc-json`][rustdoc-json-tests] each feature an additional set of directives whose basic
 syntax resembles the one of compiletest directives but which are ultimately read and checked by
 separate tools. For more information, please read their respective chapters as linked above.
 
-[rustdoc-html-tests]: ../rustdoc-internals/rustdoc-test-suite.md
+[rustdoc-html-tests]: ../rustdoc-internals/rustdoc-html-test-suite.md
 [rustdoc-js-tests]: ../rustdoc-internals/search.html#testing-the-search-engine
 [rustdoc-json-tests]: ../rustdoc-internals/rustdoc-json-test-suite.md
 
diff --git a/src/doc/rustc/book.toml b/src/doc/rustc/book.toml
index 9a7c28525f0e..565f6247dcb2 100644
--- a/src/doc/rustc/book.toml
+++ b/src/doc/rustc/book.toml
@@ -3,7 +3,7 @@ title = "The rustc book"
 
 [output.html]
 git-repository-url = "https://github.com/rust-lang/rust/tree/HEAD/src/doc/rustc"
-edit-url-template = "https://github.com/rust-lang/rust/edit/HEAD/src/doc/rustc/{path}"
+edit-url-template = "https://github.com/rust-lang/rust/edit/main/src/doc/rustc/{path}"
 
 [output.html.search]
 use-boolean-and = true
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index 3d776677d23e..5d1201bbf426 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -29,14 +29,15 @@ You may prefer the `-softfloat` target when writing a kernel or interfacing with
 pre-compiled binaries that use the soft-float ABI.
 
 When using the hardfloat targets, the minimum floating-point features assumed
-are those of the `fp-armv8`, which excludes NEON SIMD support. If your
+are [`FEAT_AdvSIMD`][feat-advsimd], which means NEON SIMD support. If your
 processor supports a different set of floating-point features than the default
-expectations of `fp-armv8`, then these should also be enabled or disabled as
-needed with `-C target-feature=(+/-)`. It is also possible to tell Rust (or
+expectations of `FEAT_AdvSIMD`, then these should also be enabled or disabled
+as needed with `-C target-feature=(+/-)`. It is also possible to tell Rust (or
 LLVM) that you have a specific model of Arm processor, using the
 [`-Ctarget-cpu`][target-cpu] option. Doing so may change the default set of
 target-features enabled.
 
+[feat-advsimd]: https://developer.arm.com/documentation/109697/2025_12/Feature-descriptions/The-Armv8-0-architecture-extension?lang=en
 [target-cpu]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-cpu
 [target-feature]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-feature
 
diff --git a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
index 0eb7e1d84bd0..2d9fc85dad33 100644
--- a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
+++ b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
@@ -7,7 +7,6 @@ platform.
 
 ## Target maintainers
 
-[@RDambrosio016](https://github.com/RDambrosio016)
 [@kjetilkjeka](https://github.com/kjetilkjeka)
 
 ## Requirements
@@ -49,6 +48,39 @@ $ rustup component add llvm-tools --toolchain nightly
 $ rustup component add llvm-bitcode-linker --toolchain nightly
 ```
 
+## Target specific restrictions
+
+The PTX instruction set architecture has special requirements regarding what is
+and isn't allowed. In order to avoid producing invalid PTX or generating undefined
+behavior by LLVM, some Rust language features are disallowed when compiling for this target.
+
+### Static initializers must be acyclic
+
+A static's initializer must not form a cycle with itself or another static's
+initializer. Therefore, the compiler will reject not only the self-referencing static `A`,
+but all of the following statics.
+
+```Rust
+struct Foo(&'static Foo);
+
+static A: Foo = Foo(&A); //~ ERROR static initializer forms a cycle involving `A`
+
+static B0: Foo = Foo(&B1); //~ ERROR static initializer forms a cycle involving `B0`
+static B1: Foo = Foo(&B0);
+
+static C0: Foo = Foo(&C1); //~ ERROR static initializer forms a cycle involving `C0`
+static C1: Foo = Foo(&C2);
+static C2: Foo = Foo(&C0);
+```
+
+Initializers that are acyclic are allowed:
+
+```Rust
+struct Bar(&'static u32);
+
+static BAR: Bar = Bar(&INT); // is allowed
+static INT: u32 = 42u32; // also allowed
+```
 
 <!-- FIXME: fill this out
 
diff --git a/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
index b8bee11055fe..cb7d05515453 100644
--- a/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
@@ -7,6 +7,7 @@ IBM z/Architecture (s390x) targets (including IBM Z and LinuxONE) running Linux.
 ## Target maintainers
 
 [@uweigand](https://github.com/uweigand)
+[@Gelbpunkt](https://github.com/Gelbpunkt)
 
 ## Requirements
 
diff --git a/src/doc/rustc/src/remap-source-paths.md b/src/doc/rustc/src/remap-source-paths.md
index ebe92d71158a..dc00278fac67 100644
--- a/src/doc/rustc/src/remap-source-paths.md
+++ b/src/doc/rustc/src/remap-source-paths.md
@@ -3,7 +3,7 @@
 `rustc` supports remapping source paths prefixes **as a best effort** in all compiler generated
 output, including compiler diagnostics, debugging information, macro expansions, etc.
 
-This is useful for normalizing build products, for example by removing the current directory
+This is useful for normalizing build products, for example, by removing the current directory
 out of the paths emitted into object files.
 
 The remapping is done via the `--remap-path-prefix` option.
@@ -41,7 +41,7 @@ This example replaces all occurrences of `/home/user/project` in emitted paths w
 
 ## Caveats and Limitations
 
-### Linkers generated paths
+### Paths generated by linkers
 
 On some platforms like `x86_64-pc-windows-msvc`, the linker may embed absolute host paths and compiler
 arguments into debug info files (like `.pdb`) independently of `rustc`.
@@ -54,7 +54,7 @@ The `--remap-path-prefix` option does not affect these linker-generated paths.
 ### Textual replacement only
 
 The remapping is strictly textual and does not account for different path separator conventions across
-platforms. Care must be taken when specifying prefixes, especially on Windows where both `/` and `\` may
+platforms. Care must be taken when specifying prefixes, especially on Windows, where both `/` and `\` may
 appear in paths.
 
 ### External tools
diff --git a/src/doc/unstable-book/book.toml b/src/doc/unstable-book/book.toml
index c357949f6c2e..8a3d11499cdd 100644
--- a/src/doc/unstable-book/book.toml
+++ b/src/doc/unstable-book/book.toml
@@ -3,4 +3,4 @@ title = "The Rust Unstable Book"
 
 [output.html]
 git-repository-url = "https://github.com/rust-lang/rust/tree/HEAD/src/doc/unstable-book"
-edit-url-template = "https://github.com/rust-lang/rust/edit/HEAD/src/doc/unstable-book/{path}"
+edit-url-template = "https://github.com/rust-lang/rust/edit/main/src/doc/unstable-book/{path}"
diff --git a/src/doc/unstable-book/src/library-features/derive-eq.md b/src/doc/unstable-book/src/library-features/derive-clone-copy-internals.md
similarity index 77%
rename from src/doc/unstable-book/src/library-features/derive-eq.md
rename to src/doc/unstable-book/src/library-features/derive-clone-copy-internals.md
index 68a275f5419d..c53a55132de5 100644
--- a/src/doc/unstable-book/src/library-features/derive-eq.md
+++ b/src/doc/unstable-book/src/library-features/derive-clone-copy-internals.md
@@ -1,4 +1,4 @@
-# `derive_eq`
+# `derive_clone_copy_internals`
 
 This feature is internal to the Rust compiler and is not intended for general use.
 
diff --git a/src/doc/unstable-book/src/library-features/derive-clone-copy.md b/src/doc/unstable-book/src/library-features/derive-eq-internals.md
similarity index 82%
rename from src/doc/unstable-book/src/library-features/derive-clone-copy.md
rename to src/doc/unstable-book/src/library-features/derive-eq-internals.md
index cc603911cbd2..3f334b5ad3b6 100644
--- a/src/doc/unstable-book/src/library-features/derive-clone-copy.md
+++ b/src/doc/unstable-book/src/library-features/derive-eq-internals.md
@@ -1,4 +1,4 @@
-# `derive_clone_copy`
+# `derive_eq_internals`
 
 This feature is internal to the Rust compiler and is not intended for general use.
 
diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index 7ab2a72d75b5..485af5ab1d01 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -7,7 +7,6 @@ use std::sync::Arc;
 use std::{fmt, mem, ops};
 
 use itertools::Either;
-use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::thin_vec::{ThinVec, thin_vec};
 use rustc_hir as hir;
@@ -29,12 +28,6 @@ mod tests;
 #[cfg_attr(test, derive(PartialEq))]
 pub(crate) struct Cfg(CfgEntry);
 
-#[derive(PartialEq, Debug)]
-pub(crate) struct InvalidCfgError {
-    pub(crate) msg: &'static str,
-    pub(crate) span: Span,
-}
-
 /// Whether the configuration consists of just `Cfg` or `Not`.
 fn is_simple_cfg(cfg: &CfgEntry) -> bool {
     match cfg {
@@ -105,106 +98,6 @@ fn should_capitalize_first_letter(cfg: &CfgEntry) -> bool {
 }
 
 impl Cfg {
-    /// Parses a `MetaItemInner` into a `Cfg`.
-    fn parse_nested(
-        nested_cfg: &MetaItemInner,
-        exclude: &FxHashSet<NameValueCfg>,
-    ) -> Result<Option<Cfg>, InvalidCfgError> {
-        match nested_cfg {
-            MetaItemInner::MetaItem(cfg) => Cfg::parse_without(cfg, exclude),
-            MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => {
-                Ok(Some(Cfg(CfgEntry::Bool(*b, DUMMY_SP))))
-            }
-            MetaItemInner::Lit(lit) => {
-                Err(InvalidCfgError { msg: "unexpected literal", span: lit.span })
-            }
-        }
-    }
-
-    fn parse_without(
-        cfg: &MetaItem,
-        exclude: &FxHashSet<NameValueCfg>,
-    ) -> Result<Option<Cfg>, InvalidCfgError> {
-        let name = match cfg.ident() {
-            Some(ident) => ident.name,
-            None => {
-                return Err(InvalidCfgError {
-                    msg: "expected a single identifier",
-                    span: cfg.span,
-                });
-            }
-        };
-        match cfg.kind {
-            MetaItemKind::Word => {
-                if exclude.contains(&NameValueCfg::new(name)) {
-                    Ok(None)
-                } else {
-                    Ok(Some(Cfg(CfgEntry::NameValue { name, value: None, span: DUMMY_SP })))
-                }
-            }
-            MetaItemKind::NameValue(ref lit) => match lit.kind {
-                LitKind::Str(value, _) => {
-                    if exclude.contains(&NameValueCfg::new_value(name, value)) {
-                        Ok(None)
-                    } else {
-                        Ok(Some(Cfg(CfgEntry::NameValue {
-                            name,
-                            value: Some(value),
-                            span: DUMMY_SP,
-                        })))
-                    }
-                }
-                _ => Err(InvalidCfgError {
-                    // FIXME: if the main #[cfg] syntax decided to support non-string literals,
-                    // this should be changed as well.
-                    msg: "value of cfg option should be a string literal",
-                    span: lit.span,
-                }),
-            },
-            MetaItemKind::List(ref items) => {
-                let orig_len = items.len();
-                let mut sub_cfgs =
-                    items.iter().filter_map(|i| Cfg::parse_nested(i, exclude).transpose());
-                let ret = match name {
-                    sym::all => {
-                        sub_cfgs.try_fold(Cfg(CfgEntry::Bool(true, DUMMY_SP)), |x, y| Ok(x & y?))
-                    }
-                    sym::any => {
-                        sub_cfgs.try_fold(Cfg(CfgEntry::Bool(false, DUMMY_SP)), |x, y| Ok(x | y?))
-                    }
-                    sym::not => {
-                        if orig_len == 1 {
-                            let mut sub_cfgs = sub_cfgs.collect::<Vec<_>>();
-                            if sub_cfgs.len() == 1 {
-                                Ok(!sub_cfgs.pop().unwrap()?)
-                            } else {
-                                return Ok(None);
-                            }
-                        } else {
-                            Err(InvalidCfgError { msg: "expected 1 cfg-pattern", span: cfg.span })
-                        }
-                    }
-                    _ => Err(InvalidCfgError { msg: "invalid predicate", span: cfg.span }),
-                };
-                match ret {
-                    Ok(c) => Ok(Some(c)),
-                    Err(e) => Err(e),
-                }
-            }
-        }
-    }
-
-    /// Parses a `MetaItem` into a `Cfg`.
-    ///
-    /// The `MetaItem` should be the content of the `#[cfg(...)]`, e.g., `unix` or
-    /// `target_os = "redox"`.
-    ///
-    /// If the content is not properly formatted, it will return an error indicating what and where
-    /// the error is.
-    pub(crate) fn parse(cfg: &MetaItemInner) -> Result<Cfg, InvalidCfgError> {
-        Self::parse_nested(cfg, &FxHashSet::default()).map(|ret| ret.unwrap())
-    }
-
     /// Renders the configuration for human display, as a short HTML description.
     pub(crate) fn render_short_html(&self) -> String {
         let mut msg = Display(&self.0, Format::ShortHtml).to_string();
@@ -644,10 +537,6 @@ impl NameValueCfg {
     fn new(name: Symbol) -> Self {
         Self { name, value: None }
     }
-
-    fn new_value(name: Symbol, value: Symbol) -> Self {
-        Self { name, value: Some(value) }
-    }
 }
 
 impl<'a> From<&'a CfgEntry> for NameValueCfg {
@@ -751,15 +640,6 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
     tcx: TyCtxt<'_>,
     cfg_info: &mut CfgInfo,
 ) -> Option<Arc<Cfg>> {
-    fn single<T: IntoIterator>(it: T) -> Option<T::Item> {
-        let mut iter = it.into_iter();
-        let item = iter.next()?;
-        if iter.next().is_some() {
-            return None;
-        }
-        Some(item)
-    }
-
     fn check_changed_auto_active_status(
         changed_auto_active_status: &mut Option<rustc_span::Span>,
         attr_span: Span,
@@ -859,12 +739,11 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
             }
             continue;
         } else if !cfg_info.parent_is_doc_cfg
-            && let Some(ident) = attr.ident()
-            && matches!(ident.name, sym::cfg | sym::cfg_trace)
-            && let Some(attr) = single(attr.meta_item_list()?)
-            && let Ok(new_cfg) = Cfg::parse(&attr)
+            && let hir::Attribute::Parsed(AttributeKind::CfgTrace(cfgs)) = attr
         {
-            cfg_info.current_cfg &= new_cfg;
+            for (new_cfg, _) in cfgs {
+                cfg_info.current_cfg &= Cfg(new_cfg.clone());
+            }
         }
     }
 
diff --git a/src/librustdoc/clean/cfg/tests.rs b/src/librustdoc/clean/cfg/tests.rs
index 09316ead76ac..e0c21865d8df 100644
--- a/src/librustdoc/clean/cfg/tests.rs
+++ b/src/librustdoc/clean/cfg/tests.rs
@@ -1,8 +1,5 @@
-use rustc_ast::ast::LitIntType;
-use rustc_ast::{MetaItemInner, MetaItemLit, Path, Safety, StrStyle};
 use rustc_data_structures::thin_vec::thin_vec;
 use rustc_hir::attrs::CfgEntry;
-use rustc_span::symbol::{Ident, kw};
 use rustc_span::{DUMMY_SP, create_default_session_globals_then};
 
 use super::*;
@@ -28,10 +25,6 @@ fn name_value_cfg_e(name: &str, value: &str) -> CfgEntry {
     }
 }
 
-fn dummy_lit(symbol: Symbol, kind: LitKind) -> MetaItemInner {
-    MetaItemInner::Lit(MetaItemLit { symbol, suffix: None, kind, span: DUMMY_SP })
-}
-
 fn cfg_all(v: ThinVec<CfgEntry>) -> Cfg {
     Cfg(cfg_all_e(v))
 }
@@ -52,51 +45,6 @@ fn cfg_not(v: CfgEntry) -> Cfg {
     Cfg(CfgEntry::Not(Box::new(v), DUMMY_SP))
 }
 
-fn dummy_meta_item_word(name: &str) -> MetaItemInner {
-    MetaItemInner::MetaItem(MetaItem {
-        unsafety: Safety::Default,
-        path: Path::from_ident(Ident::from_str(name)),
-        kind: MetaItemKind::Word,
-        span: DUMMY_SP,
-    })
-}
-
-fn dummy_meta_item_name_value(name: &str, symbol: Symbol, kind: LitKind) -> MetaItemInner {
-    let lit = MetaItemLit { symbol, suffix: None, kind, span: DUMMY_SP };
-    MetaItemInner::MetaItem(MetaItem {
-        unsafety: Safety::Default,
-        path: Path::from_ident(Ident::from_str(name)),
-        kind: MetaItemKind::NameValue(lit),
-        span: DUMMY_SP,
-    })
-}
-
-macro_rules! dummy_meta_item_list {
-    ($name:ident, [$($list:ident),* $(,)?]) => {
-        MetaItemInner::MetaItem(MetaItem {
-            unsafety: Safety::Default,
-            path: Path::from_ident(Ident::from_str(stringify!($name))),
-            kind: MetaItemKind::List(thin_vec![
-                $(
-                    dummy_meta_item_word(stringify!($list)),
-                )*
-            ]),
-            span: DUMMY_SP,
-        })
-    };
-
-    ($name:ident, [$($list:expr),* $(,)?]) => {
-        MetaItemInner::MetaItem(MetaItem {
-            unsafety: Safety::Default,
-            path: Path::from_ident(Ident::from_str(stringify!($name))),
-            kind: MetaItemKind::List(thin_vec![
-                $($list,)*
-            ]),
-            span: DUMMY_SP,
-        })
-    };
-}
-
 fn cfg_true() -> Cfg {
     Cfg(CfgEntry::Bool(true, DUMMY_SP))
 }
@@ -303,87 +251,6 @@ fn test_cfg_or() {
     })
 }
 
-#[test]
-fn test_parse_ok() {
-    create_default_session_globals_then(|| {
-        let r#true = Symbol::intern("true");
-        let mi = dummy_lit(r#true, LitKind::Bool(true));
-        assert_eq!(Cfg::parse(&mi), Ok(cfg_true()));
-
-        let r#false = Symbol::intern("false");
-        let mi = dummy_lit(r#false, LitKind::Bool(false));
-        assert_eq!(Cfg::parse(&mi), Ok(cfg_false()));
-
-        let mi = dummy_meta_item_word("all");
-        assert_eq!(Cfg::parse(&mi), Ok(word_cfg("all")));
-
-        let done = Symbol::intern("done");
-        let mi = dummy_meta_item_name_value("all", done, LitKind::Str(done, StrStyle::Cooked));
-        assert_eq!(Cfg::parse(&mi), Ok(name_value_cfg("all", "done")));
-
-        let mi = dummy_meta_item_list!(all, [a, b]);
-        assert_eq!(Cfg::parse(&mi), Ok(word_cfg("a") & word_cfg("b")));
-
-        let mi = dummy_meta_item_list!(any, [a, b]);
-        assert_eq!(Cfg::parse(&mi), Ok(word_cfg("a") | word_cfg("b")));
-
-        let mi = dummy_meta_item_list!(not, [a]);
-        assert_eq!(Cfg::parse(&mi), Ok(!word_cfg("a")));
-
-        let mi = dummy_meta_item_list!(
-            not,
-            [dummy_meta_item_list!(
-                any,
-                [dummy_meta_item_word("a"), dummy_meta_item_list!(all, [b, c]),]
-            ),]
-        );
-        assert_eq!(Cfg::parse(&mi), Ok(!(word_cfg("a") | (word_cfg("b") & word_cfg("c")))));
-
-        let mi = dummy_meta_item_list!(all, [a, b, c]);
-        assert_eq!(Cfg::parse(&mi), Ok(word_cfg("a") & word_cfg("b") & word_cfg("c")));
-    })
-}
-
-#[test]
-fn test_parse_err() {
-    create_default_session_globals_then(|| {
-        let mi = dummy_meta_item_name_value("foo", kw::False, LitKind::Bool(false));
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(not, [a, b]);
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(not, []);
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(foo, []);
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(
-            all,
-            [dummy_meta_item_list!(foo, []), dummy_meta_item_word("b"),]
-        );
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(
-            any,
-            [dummy_meta_item_word("a"), dummy_meta_item_list!(foo, []),]
-        );
-        assert!(Cfg::parse(&mi).is_err());
-
-        let mi = dummy_meta_item_list!(not, [dummy_meta_item_list!(foo, []),]);
-        assert!(Cfg::parse(&mi).is_err());
-
-        let c = Symbol::intern("e");
-        let mi = dummy_lit(c, LitKind::Char('e'));
-        assert!(Cfg::parse(&mi).is_err());
-
-        let five = Symbol::intern("5");
-        let mi = dummy_lit(five, LitKind::Int(5.into(), LitIntType::Unsuffixed));
-        assert!(Cfg::parse(&mi).is_err());
-    })
-}
-
 #[test]
 fn test_render_short_html() {
     create_default_session_globals_then(|| {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 707b48b355ba..817eda4c52ec 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -51,7 +51,7 @@ use rustc_middle::ty::{self, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeVisitableE
 use rustc_middle::{bug, span_bug};
 use rustc_span::ExpnKind;
 use rustc_span::hygiene::{AstPass, MacroKind};
-use rustc_span::symbol::{Ident, Symbol, kw, sym};
+use rustc_span::symbol::{Ident, Symbol, kw};
 use rustc_trait_selection::traits::wf::object_region_bounds;
 use tracing::{debug, instrument};
 use utils::*;
@@ -323,8 +323,18 @@ pub(crate) fn clean_const<'tcx>(constant: &hir::ConstArg<'tcx>) -> ConstantKind
             // FIXME(mgca): proper printing :3
             ConstantKind::Path { path: "/* STRUCT EXPR */".to_string().into() }
         }
+        hir::ConstArgKind::TupleCall(..) => {
+            ConstantKind::Path { path: "/* TUPLE CALL */".to_string().into() }
+        }
+        hir::ConstArgKind::Tup(..) => {
+            // FIXME(mgca): proper printing :3
+            ConstantKind::Path { path: "/* TUPLE EXPR */".to_string().into() }
+        }
         hir::ConstArgKind::Anon(anon) => ConstantKind::Anonymous { body: anon.body },
         hir::ConstArgKind::Infer(..) | hir::ConstArgKind::Error(..) => ConstantKind::Infer,
+        hir::ConstArgKind::Literal(..) => {
+            ConstantKind::Path { path: "/* LITERAL */".to_string().into() }
+        }
     }
 }
 
@@ -1804,7 +1814,11 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
                     let ct = cx.tcx.normalize_erasing_regions(typing_env, ct);
                     print_const(cx, ct)
                 }
-                hir::ConstArgKind::Struct(..) | hir::ConstArgKind::Path(..) => {
+                hir::ConstArgKind::Struct(..)
+                | hir::ConstArgKind::Path(..)
+                | hir::ConstArgKind::TupleCall(..)
+                | hir::ConstArgKind::Tup(..)
+                | hir::ConstArgKind::Literal(..) => {
                     let ct = lower_const_arg_for_rustdoc(cx.tcx, const_arg, FeedConstTy::No);
                     print_const(cx, ct)
                 }
@@ -2677,17 +2691,13 @@ fn add_without_unwanted_attributes<'hir>(
                     import_parent,
                 ));
             }
-            hir::Attribute::Unparsed(normal) if let [ident] = &*normal.path.segments => {
-                if is_inline || ident.name != sym::cfg_trace {
-                    // If it's not a `cfg()` attribute, we keep it.
-                    attrs.push((Cow::Borrowed(attr), import_parent));
-                }
-            }
-            // FIXME: make sure to exclude `#[cfg_trace]` here when it is ported to the new parsers
-            hir::Attribute::Parsed(..) => {
+
+            // We discard `#[cfg(...)]` attributes unless we're inlining
+            hir::Attribute::Parsed(AttributeKind::CfgTrace(..)) if !is_inline => {}
+            // We keep all other attributes
+            _ => {
                 attrs.push((Cow::Borrowed(attr), import_parent));
             }
-            _ => {}
         }
     }
 }
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index a390a03ff114..c3bafd3db13a 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -7,6 +7,7 @@ use std::{fmt, iter};
 use arrayvec::ArrayVec;
 use itertools::Either;
 use rustc_abi::{ExternAbi, VariantIdx};
+use rustc_ast::attr::AttributeExt;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation, DocAttribute};
@@ -450,7 +451,16 @@ impl Item {
     }
 
     pub(crate) fn attr_span(&self, tcx: TyCtxt<'_>) -> rustc_span::Span {
+        let deprecation_notes = self
+            .attrs
+            .other_attrs
+            .iter()
+            .filter_map(|attr| attr.deprecation_note().map(|_| attr.span()));
+
         span_of_fragments(&self.attrs.doc_strings)
+            .into_iter()
+            .chain(deprecation_notes)
+            .reduce(|a, b| a.to(b))
             .unwrap_or_else(|| self.span(tcx).map_or(DUMMY_SP, |span| span.inner()))
     }
 
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index a4d377432c91..c472c20a7dc7 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -111,7 +111,11 @@ pub(crate) struct MarkdownWithToc<'a> {
 }
 /// A tuple struct like `Markdown` that renders the markdown escaping HTML tags
 /// and includes no paragraph tags.
-pub(crate) struct MarkdownItemInfo<'a>(pub(crate) &'a str, pub(crate) &'a mut IdMap);
+pub(crate) struct MarkdownItemInfo<'a> {
+    pub(crate) content: &'a str,
+    pub(crate) links: &'a [RenderedLink],
+    pub(crate) ids: &'a mut IdMap,
+}
 /// A tuple struct like `Markdown` that renders only the first paragraph.
 pub(crate) struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
 
@@ -1459,15 +1463,28 @@ impl MarkdownWithToc<'_> {
     }
 }
 
-impl MarkdownItemInfo<'_> {
+impl<'a> MarkdownItemInfo<'a> {
+    pub(crate) fn new(content: &'a str, links: &'a [RenderedLink], ids: &'a mut IdMap) -> Self {
+        Self { content, links, ids }
+    }
+
     pub(crate) fn write_into(self, mut f: impl fmt::Write) -> fmt::Result {
-        let MarkdownItemInfo(md, ids) = self;
+        let MarkdownItemInfo { content: md, links, ids } = self;
 
         // This is actually common enough to special-case
         if md.is_empty() {
             return Ok(());
         }
-        let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
+
+        let replacer = move |broken_link: BrokenLink<'_>| {
+            links
+                .iter()
+                .find(|link| *link.original_text == *broken_link.reference)
+                .map(|link| (link.href.as_str().into(), link.tooltip.as_str().into()))
+        };
+
+        let p = Parser::new_with_broken_link_callback(md, main_body_opts(), Some(replacer));
+        let p = p.into_offset_iter();
 
         // Treat inline HTML as plain text.
         let p = p.map(|event| match event.0 {
@@ -1477,6 +1494,7 @@ impl MarkdownItemInfo<'_> {
 
         ids.handle_footnotes(|ids, existing_footnotes| {
             let p = HeadingLinks::new(p, None, ids, HeadingOffset::H1);
+            let p = SpannedLinkReplacer::new(p, links);
             let p = footnotes::Footnotes::new(p, existing_footnotes);
             let p = TableWrapper::new(p.map(|(ev, _)| ev));
             let p = p.filter(|event| {
diff --git a/src/librustdoc/html/markdown/tests.rs b/src/librustdoc/html/markdown/tests.rs
index 61fd42874633..1c99ccc5228b 100644
--- a/src/librustdoc/html/markdown/tests.rs
+++ b/src/librustdoc/html/markdown/tests.rs
@@ -471,7 +471,7 @@ fn test_markdown_html_escape() {
     fn t(input: &str, expect: &str) {
         let mut idmap = IdMap::new();
         let mut output = String::new();
-        MarkdownItemInfo(input, &mut idmap).write_into(&mut output).unwrap();
+        MarkdownItemInfo::new(input, &[], &mut idmap).write_into(&mut output).unwrap();
         assert_eq!(output, expect, "original: {}", input);
     }
 
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 4529f5a8c016..63de870f07f4 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -877,7 +877,8 @@ fn short_item_info(
         if let Some(note) = note {
             let note = note.as_str();
             let mut id_map = cx.id_map.borrow_mut();
-            let html = MarkdownItemInfo(note, &mut id_map);
+            let links = item.links(cx);
+            let html = MarkdownItemInfo::new(note, &links, &mut id_map);
             message.push_str(": ");
             html.write_into(&mut message).unwrap();
         }
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index e0a37c95257c..af97ae93a2b9 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -882,7 +882,8 @@ impl<'item> DocVisitor<'item> for TypeImplCollector<'_, '_, 'item> {
             //
             // FIXME(lazy_type_alias): Once the feature is complete or stable, rewrite this
             // to use type unification.
-            // Be aware of `tests/rustdoc/type-alias/deeply-nested-112515.rs` which might regress.
+            // Be aware of `tests/rustdoc-html/type-alias/deeply-nested-112515.rs` which might
+            // regress.
             let Some(impl_did) = impl_item_id.as_def_id() else { continue };
             let for_ty = self.cx.tcx().type_of(impl_did).skip_binder();
             let reject_cx = DeepRejectCtxt::relate_infer_infer(self.cx.tcx());
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index b93e921dd5b7..b770a0e2a0e4 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1200,9 +1200,11 @@ nav.sub {
 	display: initial;
 }
 .anchor {
+	--anchor-link-shift: 0.5em;
 	display: none;
 	position: absolute;
-	left: -0.5em;
+	left: calc(var(--anchor-link-shift) * -1);
+	padding-right: var(--anchor-link-shift);
 	background: none !important;
 }
 .anchor.field {
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index 37d456ae796b..a201f661d9f7 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -104,22 +104,6 @@ impl<'tcx> JsonRenderer<'tcx> {
             })
             .unwrap_or_default()
     }
-
-    fn serialize_and_write<T: Write>(
-        &self,
-        output_crate: types::Crate,
-        mut writer: BufWriter<T>,
-        path: &str,
-    ) -> Result<(), Error> {
-        self.sess().time("rustdoc_json_serialize_and_write", || {
-            try_err!(
-                serde_json::ser::to_writer(&mut writer, &output_crate).map_err(|e| e.to_string()),
-                path
-            );
-            try_err!(writer.flush(), path);
-            Ok(())
-        })
-    }
 }
 
 impl<'tcx> JsonRenderer<'tcx> {
@@ -252,26 +236,23 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         unreachable!("RUN_ON_MODULE = false, should never call mod_item_in")
     }
 
-    fn after_krate(mut self) -> Result<(), Error> {
+    fn after_krate(self) -> Result<(), Error> {
         debug!("Done with crate");
 
         let e = ExternalCrate { crate_num: LOCAL_CRATE };
-
-        // We've finished using the index, and don't want to clone it, because it is big.
-        let index = std::mem::take(&mut self.index);
+        let sess = self.sess();
 
         // Note that tcx.rust_target_features is inappropriate here because rustdoc tries to run for
         // multiple targets: https://github.com/rust-lang/rust/pull/137632
         //
         // We want to describe a single target, so pass tcx.sess rather than tcx.
-        let target = conversions::target(self.tcx.sess);
+        let target = conversions::target(sess);
 
         debug!("Constructing Output");
         let output_crate = types::Crate {
             root: self.id_from_item_default(e.def_id().into()),
             crate_version: self.cache.crate_version.clone(),
             includes_private: self.cache.document_private,
-            index,
             paths: self
                 .cache
                 .paths
@@ -313,6 +294,8 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                     )
                 })
                 .collect(),
+            // Be careful to not clone the `index`, it is big.
+            index: self.index,
             target,
             format_version: types::FORMAT_VERSION,
         };
@@ -323,17 +306,34 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
             p.push(output_crate.index.get(&output_crate.root).unwrap().name.clone().unwrap());
             p.set_extension("json");
 
-            self.serialize_and_write(
+            serialize_and_write(
+                sess,
                 output_crate,
                 try_err!(File::create_buffered(&p), p),
                 &p.display().to_string(),
             )
         } else {
-            self.serialize_and_write(output_crate, BufWriter::new(stdout().lock()), "<stdout>")
+            serialize_and_write(sess, output_crate, BufWriter::new(stdout().lock()), "<stdout>")
         }
     }
 }
 
+fn serialize_and_write<T: Write>(
+    sess: &Session,
+    output_crate: types::Crate,
+    mut writer: BufWriter<T>,
+    path: &str,
+) -> Result<(), Error> {
+    sess.time("rustdoc_json_serialize_and_write", || {
+        try_err!(
+            serde_json::ser::to_writer(&mut writer, &output_crate).map_err(|e| e.to_string()),
+            path
+        );
+        try_err!(writer.flush(), path);
+        Ok(())
+    })
+}
+
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.
 //
 // These assertions are here, not in `src/rustdoc-json-types/lib.rs` where the types are defined,
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 3abf0fee3959..07d6efaa97e1 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -7,6 +7,7 @@ use std::fmt::Display;
 use std::mem;
 use std::ops::Range;
 
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::util::comments::may_have_doc_links;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
@@ -1047,18 +1048,7 @@ impl LinkCollector<'_, '_> {
             return;
         }
 
-        // We want to resolve in the lexical scope of the documentation.
-        // In the presence of re-exports, this is not the same as the module of the item.
-        // Rather than merging all documentation into one, resolve it one attribute at a time
-        // so we know which module it came from.
-        for (item_id, doc) in prepare_to_doc_link_resolution(&item.attrs.doc_strings) {
-            if !may_have_doc_links(&doc) {
-                continue;
-            }
-            debug!("combined_docs={doc}");
-            // NOTE: if there are links that start in one crate and end in another, this will not resolve them.
-            // This is a degenerate case and it's not supported by rustdoc.
-            let item_id = item_id.unwrap_or_else(|| item.item_id.expect_def_id());
+        let mut insert_links = |item_id, doc: &str| {
             let module_id = match self.cx.tcx.def_kind(item_id) {
                 DefKind::Mod if item.inner_docs(self.cx.tcx) => item_id,
                 _ => find_nearest_parent_module(self.cx.tcx, item_id).unwrap(),
@@ -1074,6 +1064,35 @@ impl LinkCollector<'_, '_> {
                         .insert(link);
                 }
             }
+        };
+
+        // We want to resolve in the lexical scope of the documentation.
+        // In the presence of re-exports, this is not the same as the module of the item.
+        // Rather than merging all documentation into one, resolve it one attribute at a time
+        // so we know which module it came from.
+        for (item_id, doc) in prepare_to_doc_link_resolution(&item.attrs.doc_strings) {
+            if !may_have_doc_links(&doc) {
+                continue;
+            }
+
+            debug!("combined_docs={doc}");
+            // NOTE: if there are links that start in one crate and end in another, this will not resolve them.
+            // This is a degenerate case and it's not supported by rustdoc.
+            let item_id = item_id.unwrap_or_else(|| item.item_id.expect_def_id());
+            insert_links(item_id, &doc)
+        }
+
+        // Also resolve links in the note text of `#[deprecated]`.
+        for attr in &item.attrs.other_attrs {
+            let Some(note_sym) = attr.deprecation_note() else { continue };
+            let note = note_sym.as_str();
+
+            if !may_have_doc_links(note) {
+                continue;
+            }
+
+            debug!("deprecated_note={note}");
+            insert_links(item.item_id.expect_def_id(), note)
         }
     }
 
@@ -1086,7 +1105,7 @@ impl LinkCollector<'_, '_> {
     /// FIXME(jynelson): this is way too many arguments
     fn resolve_link(
         &mut self,
-        dox: &String,
+        dox: &str,
         item: &Item,
         item_id: DefId,
         module_id: DefId,
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 95f5537f394c..54da158d4d39 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -2,7 +2,6 @@
 
 use rustc_hir::Attribute;
 use rustc_hir::attrs::{AttributeKind, DocAttribute};
-use rustc_span::symbol::sym;
 
 use crate::clean::inline::{load_attrs, merge_attrs};
 use crate::clean::{CfgInfo, Crate, Item, ItemKind};
@@ -39,10 +38,7 @@ fn add_only_cfg_attributes(attrs: &mut Vec<Attribute>, new_attrs: &[Attribute])
             let mut new_attr = DocAttribute::default();
             new_attr.cfg = d.cfg.clone();
             attrs.push(Attribute::Parsed(AttributeKind::Doc(Box::new(new_attr))));
-        } else if let Attribute::Unparsed(normal) = attr
-            && let [ident] = &*normal.path.segments
-            && ident.name == sym::cfg_trace
-        {
+        } else if let Attribute::Parsed(AttributeKind::CfgTrace(..)) = attr {
             // If it's a `cfg()` attribute, we keep it.
             attrs.push(attr.clone());
         }
diff --git a/src/stage0 b/src/stage0
index 66b652a844f3..226f1d6f645e 100644
--- a/src/stage0
+++ b/src/stage0
@@ -1,7 +1,7 @@
 dist_server=https://static.rust-lang.org
 artifacts_server=https://ci-artifacts.rust-lang.org/rustc-builds
 artifacts_with_llvm_assertions_server=https://ci-artifacts.rust-lang.org/rustc-builds-alt
-git_merge_commit_email=bors@rust-lang.org
+git_merge_commit_email=122020455+rust-bors[bot]@users.noreply.github.com
 nightly_branch=main
 
 # The configuration above this comment is editable, and can be changed
diff --git a/src/tools/cargo b/src/tools/cargo
index b54051b15052..6d1bd93c47f0 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit b54051b1505281ec7a45a250140a0ff25d33f319
+Subproject commit 6d1bd93c47f059ec1344cb31e68a2fb284cbc6b1
diff --git a/src/tools/cargotest/main.rs b/src/tools/cargotest/main.rs
index 4c57683806e6..5bbed35e2068 100644
--- a/src/tools/cargotest/main.rs
+++ b/src/tools/cargotest/main.rs
@@ -84,7 +84,7 @@ const TEST_REPOS: &[Test] = &[
     Test {
         name: "diesel",
         repo: "https://github.com/diesel-rs/diesel",
-        sha: "91493fe47175076f330ce5fc518f0196c0476f56",
+        sha: "3db7c17c5b069656ed22750e84d6498c8ab5b81d",
         lock: None,
         packages: &[],
         // Test the embedded sqlite variant of diesel
diff --git a/src/tools/clippy/COPYRIGHT b/src/tools/clippy/COPYRIGHT
index f402dcf465a3..d3b4c9e5fb2c 100644
--- a/src/tools/clippy/COPYRIGHT
+++ b/src/tools/clippy/COPYRIGHT
@@ -1,6 +1,6 @@
 // REUSE-IgnoreStart
 
-Copyright 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
diff --git a/src/tools/clippy/Cargo.toml b/src/tools/clippy/Cargo.toml
index 67078adea2b4..7379dcbb7b37 100644
--- a/src/tools/clippy/Cargo.toml
+++ b/src/tools/clippy/Cargo.toml
@@ -42,7 +42,7 @@ walkdir = "2.3"
 filetime = "0.2.9"
 itertools = "0.12"
 pulldown-cmark = { version = "0.11", default-features = false, features = ["html"] }
-askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
+askama = { version = "0.15", default-features = false, features = ["alloc", "config", "derive"] }
 
 [dev-dependencies.toml]
 version = "0.9.7"
diff --git a/src/tools/clippy/LICENSE-APACHE b/src/tools/clippy/LICENSE-APACHE
index 9990a0cec474..773ae298cc19 100644
--- a/src/tools/clippy/LICENSE-APACHE
+++ b/src/tools/clippy/LICENSE-APACHE
@@ -186,7 +186,7 @@ APPENDIX: How to apply the Apache License to your work.
    same "printed page" as the copyright notice for easier
    identification within third-party archives.
 
-Copyright 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
diff --git a/src/tools/clippy/LICENSE-MIT b/src/tools/clippy/LICENSE-MIT
index 5d6e36ef6bfc..9549420685cc 100644
--- a/src/tools/clippy/LICENSE-MIT
+++ b/src/tools/clippy/LICENSE-MIT
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
diff --git a/src/tools/clippy/README.md b/src/tools/clippy/README.md
index 78498c73ae78..8bccd040c1f9 100644
--- a/src/tools/clippy/README.md
+++ b/src/tools/clippy/README.md
@@ -277,7 +277,7 @@ If you want to contribute to Clippy, you can find more information in [CONTRIBUT
 
 <!-- REUSE-IgnoreStart -->
 
-Copyright 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)> or the MIT license
diff --git a/src/tools/clippy/clippy_dev/Cargo.toml b/src/tools/clippy/clippy_dev/Cargo.toml
index c2abbac37535..238465210ee2 100644
--- a/src/tools/clippy/clippy_dev/Cargo.toml
+++ b/src/tools/clippy/clippy_dev/Cargo.toml
@@ -10,7 +10,7 @@ clap = { version = "4.4", features = ["derive"] }
 indoc = "1.0"
 itertools = "0.12"
 opener = "0.7"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 walkdir = "2.3"
 
 [package.metadata.rust-analyzer]
diff --git a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
index 53d9725703c3..0235b130b6c0 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
@@ -1,6 +1,7 @@
 use super::ALLOW_ATTRIBUTES;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::{AttrStyle, Attribute};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, LintContext};
@@ -9,17 +10,12 @@ use rustc_lint::{EarlyContext, LintContext};
 pub fn check<'cx>(cx: &EarlyContext<'cx>, attr: &'cx Attribute) {
     if !attr.span.in_external_macro(cx.sess().source_map())
         && let AttrStyle::Outer = attr.style
-        && let Some(ident) = attr.ident()
+        && let Some(path_span) = attr.path_span()
         && !is_from_proc_macro(cx, attr)
     {
         #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
-        span_lint_and_then(cx, ALLOW_ATTRIBUTES, ident.span, "#[allow] attribute found", |diag| {
-            diag.span_suggestion(
-                ident.span,
-                "replace it with",
-                "expect",
-                Applicability::MachineApplicable,
-            );
+        span_lint_and_then(cx, ALLOW_ATTRIBUTES, path_span, "#[allow] attribute found", |diag| {
+            diag.span_suggestion(path_span, "replace it with", "expect", Applicability::MachineApplicable);
         });
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/attrs/mod.rs b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
index 91c2dc7f3dc6..42c321df61c1 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
@@ -16,7 +16,7 @@ mod utils;
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::msrvs::{self, Msrv, MsrvStack};
-use rustc_ast::{self as ast, AttrArgs, AttrKind, Attribute, MetaItemInner, MetaItemKind};
+use rustc_ast::{self as ast, AttrArgs, AttrItemKind, AttrKind, Attribute, MetaItemInner, MetaItemKind};
 use rustc_hir::{ImplItem, Item, ItemKind, TraitItem};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -574,16 +574,16 @@ impl EarlyLintPass for PostExpansionEarlyAttributes {
 
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         if let Some(items) = &attr.meta_item_list()
-            && let Some(ident) = attr.ident()
+            && let Some(name) = attr.name()
         {
-            if matches!(ident.name, sym::allow) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
+            if matches!(name, sym::allow) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
                 allow_attributes::check(cx, attr);
             }
-            if matches!(ident.name, sym::allow | sym::expect) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
-                allow_attributes_without_reason::check(cx, ident.name, items, attr);
+            if matches!(name, sym::allow | sym::expect) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
+                allow_attributes_without_reason::check(cx, name, items, attr);
             }
-            if is_lint_level(ident.name, attr.id) {
-                blanket_clippy_restriction_lints::check(cx, ident.name, items);
+            if is_lint_level(name, attr.id) {
+                blanket_clippy_restriction_lints::check(cx, name, items);
             }
             if items.is_empty() || !attr.has_name(sym::deprecated) {
                 return;
@@ -604,7 +604,9 @@ impl EarlyLintPass for PostExpansionEarlyAttributes {
 
         if attr.has_name(sym::ignore)
             && match &attr.kind {
-                AttrKind::Normal(normal_attr) => !matches!(normal_attr.item.args, AttrArgs::Eq { .. }),
+                AttrKind::Normal(normal_attr) => {
+                    !matches!(normal_attr.item.args, AttrItemKind::Unparsed(AttrArgs::Eq { .. }))
+                },
                 AttrKind::DocComment(..) => true,
             }
         {
diff --git a/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs b/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs
index fd27e30a67f3..1a9abd88a46a 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs
@@ -2,19 +2,19 @@ use super::{Attribute, SHOULD_PANIC_WITHOUT_EXPECT};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::TokenTree;
-use rustc_ast::{AttrArgs, AttrKind};
+use rustc_ast::{AttrArgs, AttrItemKind, AttrKind};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 use rustc_span::sym;
 
 pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute) {
     if let AttrKind::Normal(normal_attr) = &attr.kind {
-        if let AttrArgs::Eq { .. } = &normal_attr.item.args {
+        if let AttrItemKind::Unparsed(AttrArgs::Eq { .. }) = &normal_attr.item.args {
             // `#[should_panic = ".."]` found, good
             return;
         }
 
-        if let AttrArgs::Delimited(args) = &normal_attr.item.args
+        if let AttrItemKind::Unparsed(AttrArgs::Delimited(args)) = &normal_attr.item.args
             && let mut tt_iter = args.tokens.iter()
             && let Some(TokenTree::Token(
                 Token {
diff --git a/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs b/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
index 1cebc18edc90..aa9a6654bee3 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
@@ -15,7 +15,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, item: &Item, attrs: &[Attribute]) {
             return;
         }
         if let Some(lint_list) = &attr.meta_item_list()
-            && attr.ident().is_some_and(|ident| is_lint_level(ident.name, attr.id))
+            && attr.name().is_some_and(|name| is_lint_level(name, attr.id))
         {
             for lint in lint_list {
                 match item.kind {
diff --git a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs
index f31b67f470f9..165941a859f7 100644
--- a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs
+++ b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
+use clippy_utils::source::walk_span_to_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::sym;
 use clippy_utils::ty::{implements_trait, is_copy};
@@ -130,22 +131,24 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
 
                 let mut suggestions = vec![(name_span, non_eq_mac.to_string()), (lit_span, String::new())];
 
-                if let Some(sugg) = Sugg::hir_opt(cx, non_lit_expr) {
-                    let sugg = if bool_value ^ eq_macro {
-                        !sugg.maybe_paren()
-                    } else if ty::Bool == *non_lit_ty.kind() {
-                        sugg
-                    } else {
-                        !!sugg.maybe_paren()
-                    };
-                    suggestions.push((non_lit_expr.span, sugg.to_string()));
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = Sugg::hir_with_context(cx, non_lit_expr, macro_call.span.ctxt(), "..", &mut applicability);
+                let sugg = if bool_value ^ eq_macro {
+                    !sugg.maybe_paren()
+                } else if ty::Bool == *non_lit_ty.kind() {
+                    sugg
+                } else {
+                    !!sugg.maybe_paren()
+                };
+                let non_lit_expr_span =
+                    walk_span_to_context(non_lit_expr.span, macro_call.span.ctxt()).unwrap_or(non_lit_expr.span);
+                suggestions.push((non_lit_expr_span, sugg.to_string()));
 
-                    diag.multipart_suggestion(
-                        format!("replace it with `{non_eq_mac}!(..)`"),
-                        suggestions,
-                        Applicability::MachineApplicable,
-                    );
-                }
+                diag.multipart_suggestion(
+                    format!("replace it with `{non_eq_mac}!(..)`"),
+                    suggestions,
+                    applicability,
+                );
             },
         );
     }
diff --git a/src/tools/clippy/clippy_lints/src/booleans.rs b/src/tools/clippy/clippy_lints/src/booleans.rs
index a04a56d72bc0..0bd459d8b021 100644
--- a/src/tools/clippy/clippy_lints/src/booleans.rs
+++ b/src/tools/clippy/clippy_lints/src/booleans.rs
@@ -15,6 +15,7 @@ use rustc_lint::{LateContext, LateLintPass, Level};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, Symbol, SyntaxContext};
+use std::fmt::Write as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -356,7 +357,7 @@ impl SuggestContext<'_, '_, '_> {
                         if app != Applicability::MachineApplicable {
                             return None;
                         }
-                        self.output.push_str(&(!snip).to_string());
+                        let _cannot_fail = write!(&mut self.output, "{}", &(!snip));
                     }
                 },
                 True | False | Not(_) => {
diff --git a/src/tools/clippy/clippy_lints/src/cargo/mod.rs b/src/tools/clippy/clippy_lints/src/cargo/mod.rs
index 60371dcd7715..08d92adbacef 100644
--- a/src/tools/clippy/clippy_lints/src/cargo/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/cargo/mod.rs
@@ -132,7 +132,7 @@ declare_clippy_lint! {
     /// Because this can be caused purely by the dependencies
     /// themselves, it's not always possible to fix this issue.
     /// In those cases, you can allow that specific crate using
-    /// the `allowed_duplicate_crates` configuration option.
+    /// the `allowed-duplicate-crates` configuration option.
     ///
     /// ### Example
     /// ```toml
diff --git a/src/tools/clippy/clippy_lints/src/cfg_not_test.rs b/src/tools/clippy/clippy_lints/src/cfg_not_test.rs
index 7590fe96fd21..88d07be0d4d4 100644
--- a/src/tools/clippy/clippy_lints/src/cfg_not_test.rs
+++ b/src/tools/clippy/clippy_lints/src/cfg_not_test.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use rustc_ast::MetaItemInner;
+use rustc_ast::attr::data_structures::CfgEntry;
+use rustc_ast::{AttrItemKind, EarlyParsedAttribute};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -32,29 +34,32 @@ declare_lint_pass!(CfgNotTest => [CFG_NOT_TEST]);
 
 impl EarlyLintPass for CfgNotTest {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &rustc_ast::Attribute) {
-        if attr.has_name(rustc_span::sym::cfg_trace) && contains_not_test(attr.meta_item_list().as_deref(), false) {
-            span_lint_and_then(
-                cx,
-                CFG_NOT_TEST,
-                attr.span,
-                "code is excluded from test builds",
-                |diag| {
-                    diag.help("consider not excluding any code from test builds");
-                    diag.note_once("this could increase code coverage despite not actually being tested");
-                },
-            );
+        if attr.has_name(sym::cfg_trace) {
+            let AttrItemKind::Parsed(EarlyParsedAttribute::CfgTrace(cfg)) = &attr.get_normal_item().args else {
+                unreachable!()
+            };
+
+            if contains_not_test(cfg, false) {
+                span_lint_and_then(
+                    cx,
+                    CFG_NOT_TEST,
+                    attr.span,
+                    "code is excluded from test builds",
+                    |diag| {
+                        diag.help("consider not excluding any code from test builds");
+                        diag.note_once("this could increase code coverage despite not actually being tested");
+                    },
+                );
+            }
         }
     }
 }
 
-fn contains_not_test(list: Option<&[MetaItemInner]>, not: bool) -> bool {
-    list.is_some_and(|list| {
-        list.iter().any(|item| {
-            item.ident().is_some_and(|ident| match ident.name {
-                rustc_span::sym::not => contains_not_test(item.meta_item_list(), !not),
-                rustc_span::sym::test => not,
-                _ => contains_not_test(item.meta_item_list(), not),
-            })
-        })
-    })
+fn contains_not_test(cfg: &CfgEntry, not: bool) -> bool {
+    match cfg {
+        CfgEntry::All(subs, _) | CfgEntry::Any(subs, _) => subs.iter().any(|item| contains_not_test(item, not)),
+        CfgEntry::Not(sub, _) => contains_not_test(sub, !not),
+        CfgEntry::NameValue { name: sym::test, .. } => not,
+        _ => false,
+    }
 }
diff --git a/src/tools/clippy/clippy_lints/src/checked_conversions.rs b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
index 9b3822f9d8f0..8303897d1294 100644
--- a/src/tools/clippy/clippy_lints/src/checked_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{SpanlessEq, is_in_const_context, is_integer_literal, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, TyKind};
@@ -80,7 +80,8 @@ impl LateLintPass<'_> for CheckedConversions {
             && self.msrv.meets(cx, msrvs::TRY_FROM)
         {
             let mut applicability = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, cv.expr_to_cast.span, "_", &mut applicability);
+            let (snippet, _) =
+                snippet_with_context(cx, cv.expr_to_cast.span, item.span.ctxt(), "_", &mut applicability);
             span_lint_and_sugg(
                 cx,
                 CHECKED_CONVERSIONS,
diff --git a/src/tools/clippy/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs b/src/tools/clippy/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
index 2bd5e2cbfb1a..316d800a70c9 100644
--- a/src/tools/clippy/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
+++ b/src/tools/clippy/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
@@ -1,15 +1,16 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::fulfill_or_allowed;
 use rustc_hir::{self as hir, HirId};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
-use rustc_span::{Span, sym};
+use rustc_span::sym;
 
 use super::DERIVE_ORD_XOR_PARTIAL_ORD;
 
 /// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
-    span: Span,
+    item: &hir::Item<'_>,
     trait_ref: &hir::TraitRef<'_>,
     ty: Ty<'tcx>,
     adt_hir_id: HirId,
@@ -19,6 +20,8 @@ pub(super) fn check<'tcx>(
         && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
         && let Some(def_id) = &trait_ref.trait_def_id()
         && *def_id == ord_trait_def_id
+        && let item_hir_id = cx.tcx.local_def_id_to_hir_id(item.owner_id)
+        && !fulfill_or_allowed(cx, DERIVE_ORD_XOR_PARTIAL_ORD, [adt_hir_id])
     {
         // Look for the PartialOrd implementations for `ty`
         cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
@@ -39,7 +42,7 @@ pub(super) fn check<'tcx>(
                     "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
                 };
 
-                span_lint_hir_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, adt_hir_id, span, mess, |diag| {
+                span_lint_hir_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, item_hir_id, item.span, mess, |diag| {
                     if let Some(local_def_id) = impl_id.as_local() {
                         let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
                         diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
diff --git a/src/tools/clippy/clippy_lints/src/derive/mod.rs b/src/tools/clippy/clippy_lints/src/derive/mod.rs
index eafe7c4bb9f2..86614201c406 100644
--- a/src/tools/clippy/clippy_lints/src/derive/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/derive/mod.rs
@@ -208,7 +208,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
             let is_automatically_derived = cx.tcx.is_automatically_derived(item.owner_id.to_def_id());
 
             derived_hash_with_manual_eq::check(cx, item.span, trait_ref, ty, adt_hir_id, is_automatically_derived);
-            derive_ord_xor_partial_ord::check(cx, item.span, trait_ref, ty, adt_hir_id, is_automatically_derived);
+            derive_ord_xor_partial_ord::check(cx, item, trait_ref, ty, adt_hir_id, is_automatically_derived);
 
             if is_automatically_derived {
                 unsafe_derive_deserialize::check(cx, item, trait_ref, ty, adt_hir_id);
diff --git a/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs b/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
index bca1cd03bb7e..6c800f47b68a 100644
--- a/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::{AttrArgs, AttrKind, AttrStyle, Attribute};
+use rustc_ast::{AttrArgs, AttrItemKind, AttrKind, AttrStyle, Attribute};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 
@@ -11,7 +11,7 @@ pub fn check(cx: &EarlyContext<'_>, attrs: &[Attribute]) {
         if !attr.span.from_expansion()
             && let AttrKind::Normal(ref item) = attr.kind
             && attr.doc_str().is_some()
-            && let AttrArgs::Eq { expr: meta, .. } = &item.item.args
+            && let AttrItemKind::Unparsed(AttrArgs::Eq { expr: meta, .. }) = &item.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
diff --git a/src/tools/clippy/clippy_lints/src/doc/mod.rs b/src/tools/clippy/clippy_lints/src/doc/mod.rs
index b11b2f8392c1..2b41275ee3a4 100644
--- a/src/tools/clippy/clippy_lints/src/doc/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/mod.rs
@@ -869,10 +869,12 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         }),
         true,
     );
-    let mut doc = fragments.iter().fold(String::new(), |mut acc, fragment| {
-        add_doc_fragment(&mut acc, fragment);
-        acc
-    });
+
+    let mut doc = String::with_capacity(fragments.iter().map(|frag| frag.doc.as_str().len() + 1).sum());
+
+    for fragment in &fragments {
+        add_doc_fragment(&mut doc, fragment);
+    }
     doc.pop();
 
     if doc.trim().is_empty() {
diff --git a/src/tools/clippy/clippy_lints/src/double_parens.rs b/src/tools/clippy/clippy_lints/src/double_parens.rs
index 8defbeeaa5f2..351d29d87432 100644
--- a/src/tools/clippy/clippy_lints/src/double_parens.rs
+++ b/src/tools/clippy/clippy_lints/src/double_parens.rs
@@ -114,6 +114,8 @@ fn check_source(cx: &EarlyContext<'_>, inner: &Expr) -> bool {
         && inner.starts_with('(')
         && inner.ends_with(')')
         && outer_after_inner.trim_start().starts_with(')')
+        // Don't lint macro repetition patterns like `($($result),*)` where parens are necessary
+        && !inner.trim_start_matches('(').trim_start().starts_with("$(")
     {
         true
     } else {
diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
index 7b6f8729cb75..516f9e3aa60c 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,9 +1,13 @@
+use std::borrow::Cow;
+
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::{Sugg, make_binop};
 use clippy_utils::{
-    SpanlessEq, eq_expr_value, higher, is_in_const_context, is_integer_literal, peel_blocks, peel_blocks_with_stmt, sym,
+    SpanlessEq, eq_expr_value, higher, is_in_const_context, is_integer_literal, is_integer_literal_untyped,
+    peel_blocks, peel_blocks_with_stmt, sym,
 };
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::packed::Pu128;
@@ -238,10 +242,21 @@ fn check_subtraction(
         if eq_expr_value(cx, left, big_expr) && eq_expr_value(cx, right, little_expr) {
             // This part of the condition is voluntarily split from the one before to ensure that
             // if `snippet_opt` fails, it won't try the next conditions.
-            if (!is_in_const_context(cx) || msrv.meets(cx, msrvs::SATURATING_SUB_CONST))
-                && let Some(big_expr_sugg) = Sugg::hir_opt(cx, big_expr).map(Sugg::maybe_paren)
-                && let Some(little_expr_sugg) = Sugg::hir_opt(cx, little_expr)
-            {
+            if !is_in_const_context(cx) || msrv.meets(cx, msrvs::SATURATING_SUB_CONST) {
+                let mut applicability = Applicability::MachineApplicable;
+                let big_expr_sugg = (if is_integer_literal_untyped(big_expr) {
+                    let get_snippet = |span: Span| {
+                        let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+                        let big_expr_ty = cx.typeck_results().expr_ty(big_expr);
+                        Cow::Owned(format!("{snippet}_{big_expr_ty}"))
+                    };
+                    Sugg::hir_from_snippet(cx, big_expr, get_snippet)
+                } else {
+                    Sugg::hir_with_applicability(cx, big_expr, "..", &mut applicability)
+                })
+                .maybe_paren();
+                let little_expr_sugg = Sugg::hir_with_applicability(cx, little_expr, "..", &mut applicability);
+
                 let sugg = format!(
                     "{}{big_expr_sugg}.saturating_sub({little_expr_sugg}){}",
                     if is_composited { "{ " } else { "" },
@@ -254,7 +269,7 @@ fn check_subtraction(
                     "manual arithmetic check found",
                     "replace it with",
                     sugg,
-                    Applicability::MachineApplicable,
+                    applicability,
                 );
             }
         } else if eq_expr_value(cx, left, little_expr)
diff --git a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
index c3bc9048c23a..8d538ff1acba 100644
--- a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
+++ b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
@@ -3,7 +3,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::{is_in_const_context, is_in_test, sym};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, AmbigArg, Expr, ExprKind, HirId, RustcVersion, StabilityLevel, StableSince};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{self as hir, AmbigArg, Expr, ExprKind, HirId, RustcVersion, StabilityLevel, StableSince, find_attr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::impl_lint_pass;
@@ -268,11 +269,9 @@ impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv {
 /// attribute.
 fn is_under_cfg_attribute(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     cx.tcx.hir_parent_id_iter(hir_id).any(|id| {
-        cx.tcx.hir_attrs(id).iter().any(|attr| {
-            matches!(
-                attr.ident().map(|ident| ident.name),
-                Some(sym::cfg_trace | sym::cfg_attr_trace)
-            )
-        })
+        find_attr!(
+            cx.tcx.hir_attrs(id),
+            AttributeKind::CfgTrace(..) | AttributeKind::CfgAttrTrace
+        )
     })
 }
diff --git a/src/tools/clippy/clippy_lints/src/inherent_impl.rs b/src/tools/clippy/clippy_lints/src/inherent_impl.rs
index f59c7615d745..14928a1be13b 100644
--- a/src/tools/clippy/clippy_lints/src/inherent_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/inherent_impl.rs
@@ -101,7 +101,21 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
                     InherentImplLintScope::Crate => Criterion::Crate,
                 };
                 let is_test = is_cfg_test(cx.tcx, hir_id) || is_in_cfg_test(cx.tcx, hir_id);
-                match type_map.entry((impl_ty, criterion, is_test)) {
+                let predicates = {
+                    // Gets the predicates (bounds) for the given impl block,
+                    // sorted for consistent comparison to allow distinguishing between impl blocks
+                    // with different generic bounds.
+                    let mut predicates = cx
+                        .tcx
+                        .predicates_of(impl_id)
+                        .predicates
+                        .iter()
+                        .map(|(clause, _)| *clause)
+                        .collect::<Vec<_>>();
+                    predicates.sort_by_key(|c| format!("{c:?}"));
+                    predicates
+                };
+                match type_map.entry((impl_ty, predicates, criterion, is_test)) {
                     Entry::Vacant(e) => {
                         // Store the id for the first impl block of this type. The span is retrieved lazily.
                         e.insert(IdOrSpan::Id(impl_id));
@@ -152,15 +166,12 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
 fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
     let id = cx.tcx.local_def_id_to_hir_id(id);
     if let Node::Item(&Item {
-        kind: ItemKind::Impl(impl_item),
+        kind: ItemKind::Impl(_),
         span,
         ..
     }) = cx.tcx.hir_node(id)
     {
-        (!span.from_expansion()
-            && impl_item.generics.params.is_empty()
-            && !fulfill_or_allowed(cx, MULTIPLE_INHERENT_IMPL, [id]))
-        .then_some(span)
+        (!span.from_expansion() && !fulfill_or_allowed(cx, MULTIPLE_INHERENT_IMPL, [id])).then_some(span)
     } else {
         None
     }
diff --git a/src/tools/clippy/clippy_lints/src/large_include_file.rs b/src/tools/clippy/clippy_lints/src/large_include_file.rs
index 48ce1afc6e69..54599499515e 100644
--- a/src/tools/clippy/clippy_lints/src/large_include_file.rs
+++ b/src/tools/clippy/clippy_lints/src/large_include_file.rs
@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::{AttrArgs, AttrKind, Attribute, LitKind};
+use rustc_ast::{AttrArgs, AttrItemKind, AttrKind, Attribute, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -92,7 +92,7 @@ impl EarlyLintPass for LargeIncludeFile {
             && let AttrKind::Normal(ref item) = attr.kind
             && let Some(doc) = attr.doc_str()
             && doc.as_str().len() as u64 > self.max_file_size
-            && let AttrArgs::Eq { expr: meta, .. } = &item.item.args
+            && let AttrItemKind::Unparsed(AttrArgs::Eq { expr: meta, .. }) = &item.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
diff --git a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
index 620e27fa67c6..32c23a2d0362 100644
--- a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
+++ b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
@@ -94,6 +94,15 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
             })
             && u128::from(self.maximum_allowed_size) < u128::from(element_count) * u128::from(element_size)
         {
+            // libtest might generate a large array containing the test cases, and no span will be associated
+            // to it. In this case it is better not to complain.
+            //
+            // Note that this condition is not checked explicitly by a unit test. Do not remove it without
+            // ensuring that <https://github.com/rust-lang/rust-clippy/issues/13774> stays fixed.
+            if expr.span.is_dummy() {
+                return;
+            }
+
             span_lint_and_then(
                 cx,
                 LARGE_STACK_ARRAYS,
@@ -126,7 +135,7 @@ fn might_be_expanded<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> bool {
         let ExprKind::Repeat(_, len_ct) = expr.kind else {
             return false;
         };
-        !expr.span.contains(len_ct.span())
+        !expr.span.contains(len_ct.span)
     }
 
     expr.span.from_expansion() || is_from_proc_macro(cx, expr) || repeat_expr_might_be_expanded(expr)
diff --git a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
index 39b2391c98ec..7fb8e51377a2 100644
--- a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
@@ -1,16 +1,22 @@
 use super::FOR_KV_MAP;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet_with_applicability, walk_span_to_context};
 use clippy_utils::{pat_is_wild, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::sym;
+use rustc_span::{Span, sym};
 
 /// Checks for the `FOR_KV_MAP` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    span: Span,
+) {
     let pat_span = pat.span;
 
     if let PatKind::Tuple(pat, _) = pat.kind
@@ -34,21 +40,25 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
             _ => arg,
         };
 
-        if matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap)) {
+        if matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap))
+            && let Some(arg_span) = walk_span_to_context(arg_span, span.ctxt())
+        {
             span_lint_and_then(
                 cx,
                 FOR_KV_MAP,
                 arg_span,
                 format!("you seem to want to iterate on a map's {kind}s"),
                 |diag| {
-                    let map = sugg::Sugg::hir(cx, arg, "map");
+                    let mut applicability = Applicability::MachineApplicable;
+                    let map = sugg::Sugg::hir_with_context(cx, arg, span.ctxt(), "map", &mut applicability);
+                    let pat = snippet_with_applicability(cx, new_pat_span, kind, &mut applicability);
                     diag.multipart_suggestion(
                         "use the corresponding method",
                         vec![
-                            (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
+                            (pat_span, pat.to_string()),
                             (arg_span, format!("{}.{kind}s{mutbl}()", map.maybe_paren())),
                         ],
-                        Applicability::MachineApplicable,
+                        applicability,
                     );
                 },
             );
diff --git a/src/tools/clippy/clippy_lints/src/loops/mod.rs b/src/tools/clippy/clippy_lints/src/loops/mod.rs
index ddc783069385..83574cab6b67 100644
--- a/src/tools/clippy/clippy_lints/src/loops/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/mod.rs
@@ -943,7 +943,7 @@ impl Loops {
             explicit_counter_loop::check(cx, pat, arg, body, expr, label);
         }
         self.check_for_loop_arg(cx, pat, arg);
-        for_kv_map::check(cx, pat, arg, body);
+        for_kv_map::check(cx, pat, arg, body, span);
         mut_range_bound::check(cx, arg, body);
         single_element_loop::check(cx, pat, arg, body, expr);
         same_item_push::check(cx, pat, arg, body, expr, self.msrv);
diff --git a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
index a037af3433c3..e7b9b1cd3881 100644
--- a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
@@ -4,8 +4,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::{snippet, snippet_with_context};
-use clippy_utils::sym;
 use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
+use clippy_utils::{contains_return, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Closure, Destination, Expr, ExprKind, HirId, InlineAsm, InlineAsmOperand, Node, Pat, Stmt, StmtKind,
@@ -82,7 +82,7 @@ pub(super) fn check_iterator_reduction<'tcx>(
 ) {
     let closure_body = cx.tcx.hir_body(closure.body).value;
     let body_ty = cx.typeck_results().expr_ty(closure_body);
-    if body_ty.is_never() {
+    if body_ty.is_never() && !contains_return(closure_body) {
         span_lint_and_then(
             cx,
             NEVER_LOOP,
diff --git a/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs b/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs
index 25057b4aeaa2..1c20a8f81efb 100644
--- a/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs
@@ -1,7 +1,7 @@
 use crate::manual_ignore_case_cmp::MatchType::{Literal, ToAscii};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sym;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
@@ -111,14 +111,12 @@ impl LateLintPass<'_> for ManualIgnoreCaseCmp {
                 "manual case-insensitive ASCII comparison",
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
+                    let (left_snip, _) = snippet_with_context(cx, left_span, expr.span.ctxt(), "..", &mut app);
+                    let (right_snip, _) = snippet_with_context(cx, right_span, expr.span.ctxt(), "..", &mut app);
                     diag.span_suggestion_verbose(
                         expr.span,
                         "consider using `.eq_ignore_ascii_case()` instead",
-                        format!(
-                            "{neg}{}.eq_ignore_ascii_case({deref}{})",
-                            snippet_with_applicability(cx, left_span, "_", &mut app),
-                            snippet_with_applicability(cx, right_span, "_", &mut app)
-                        ),
+                        format!("{neg}{left_snip}.eq_ignore_ascii_case({deref}{right_snip})"),
                         app,
                     );
                 },
diff --git a/src/tools/clippy/clippy_lints/src/manual_ilog2.rs b/src/tools/clippy/clippy_lints/src/manual_ilog2.rs
index 1c61db530606..4b411a60f3bf 100644
--- a/src/tools/clippy/clippy_lints/src/manual_ilog2.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_ilog2.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{is_from_proc_macro, sym};
 use rustc_ast::LitKind;
 use rustc_data_structures::packed::Pu128;
@@ -102,7 +102,7 @@ impl LateLintPass<'_> for ManualIlog2 {
 
 fn emit(cx: &LateContext<'_>, recv: &Expr<'_>, full_expr: &Expr<'_>) {
     let mut app = Applicability::MachineApplicable;
-    let recv = snippet_with_applicability(cx, recv.span, "_", &mut app);
+    let (recv, _) = snippet_with_context(cx, recv.span, full_expr.span.ctxt(), "_", &mut app);
     span_lint_and_sugg(
         cx,
         MANUAL_ILOG2,
diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
index c35c3d1f62e6..1fc8bb9acce2 100644
--- a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
@@ -135,7 +135,7 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
     } else {
         Applicability::MachineApplicable
     };
-    let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_paren();
+    let scrut = Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_paren();
 
     let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee);
     let (_, _, mutability) = peel_and_count_ty_refs(scrutinee_ty);
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
index 795355f25f9e..12fe44ef2f13 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
@@ -46,6 +46,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
         let cast = if input_ty == output_ty { "" } else { ".map(|x| x as _)" };
 
         let mut applicability = Applicability::MachineApplicable;
+        let ctxt = expr.span.ctxt();
         span_lint_and_then(
             cx,
             MATCH_AS_REF,
@@ -59,7 +60,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                         "use `Option::as_ref()`",
                         format!(
                             "{}.as_ref(){cast}",
-                            Sugg::hir_with_applicability(cx, ex, "_", &mut applicability).maybe_paren(),
+                            Sugg::hir_with_context(cx, ex, ctxt, "_", &mut applicability).maybe_paren(),
                         ),
                         applicability,
                     );
@@ -69,7 +70,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                         format!("use `Option::{method}()` directly"),
                         format!(
                             "{}.{method}(){cast}",
-                            Sugg::hir_with_applicability(cx, ex, "_", &mut applicability).maybe_paren(),
+                            Sugg::hir_with_context(cx, ex, ctxt, "_", &mut applicability).maybe_paren(),
                         ),
                         applicability,
                     );
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_bool.rs b/src/tools/clippy/clippy_lints/src/matches/match_bool.rs
index a2c8741f4f74..3e76231b6ef1 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_bool.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_bool.rs
@@ -16,6 +16,7 @@ pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]
         && arms
             .iter()
             .all(|arm| arm.pat.walk_short(|p| !matches!(p.kind, PatKind::Binding(..))))
+        && arms.len() == 2
     {
         span_lint_and_then(
             cx,
@@ -23,59 +24,58 @@ pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]
             expr.span,
             "`match` on a boolean expression",
             move |diag| {
-                if arms.len() == 2 {
-                    let mut app = Applicability::MachineApplicable;
-                    let test_sugg = if let PatKind::Expr(arm_bool) = arms[0].pat.kind {
-                        let test = Sugg::hir_with_applicability(cx, scrutinee, "_", &mut app);
-                        if let PatExprKind::Lit { lit, .. } = arm_bool.kind {
-                            match &lit.node {
-                                LitKind::Bool(true) => Some(test),
-                                LitKind::Bool(false) => Some(!test),
-                                _ => None,
-                            }
-                            .map(|test| {
-                                if let Some(guard) = &arms[0]
-                                    .guard
-                                    .map(|g| Sugg::hir_with_applicability(cx, g, "_", &mut app))
-                                {
-                                    test.and(guard)
-                                } else {
-                                    test
-                                }
-                            })
-                        } else {
-                            None
+                let mut app = Applicability::MachineApplicable;
+                let ctxt = expr.span.ctxt();
+                let test_sugg = if let PatKind::Expr(arm_bool) = arms[0].pat.kind {
+                    let test = Sugg::hir_with_context(cx, scrutinee, ctxt, "_", &mut app);
+                    if let PatExprKind::Lit { lit, .. } = arm_bool.kind {
+                        match &lit.node {
+                            LitKind::Bool(true) => Some(test),
+                            LitKind::Bool(false) => Some(!test),
+                            _ => None,
                         }
+                        .map(|test| {
+                            if let Some(guard) = &arms[0]
+                                .guard
+                                .map(|g| Sugg::hir_with_context(cx, g, ctxt, "_", &mut app))
+                            {
+                                test.and(guard)
+                            } else {
+                                test
+                            }
+                        })
                     } else {
                         None
+                    }
+                } else {
+                    None
+                };
+
+                if let Some(test_sugg) = test_sugg {
+                    let ctxt = expr.span.ctxt();
+                    let (true_expr, false_expr) = (arms[0].body, arms[1].body);
+                    let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
+                        (false, false) => Some(format!(
+                            "if {} {} else {}",
+                            test_sugg,
+                            expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app),
+                            expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
+                        )),
+                        (false, true) => Some(format!(
+                            "if {} {}",
+                            test_sugg,
+                            expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app)
+                        )),
+                        (true, false) => Some(format!(
+                            "if {} {}",
+                            !test_sugg,
+                            expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
+                        )),
+                        (true, true) => None,
                     };
 
-                    if let Some(test_sugg) = test_sugg {
-                        let ctxt = expr.span.ctxt();
-                        let (true_expr, false_expr) = (arms[0].body, arms[1].body);
-                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
-                            (false, false) => Some(format!(
-                                "if {} {} else {}",
-                                test_sugg,
-                                expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app),
-                                expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
-                            )),
-                            (false, true) => Some(format!(
-                                "if {} {}",
-                                test_sugg,
-                                expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app)
-                            )),
-                            (true, false) => Some(format!(
-                                "if {} {}",
-                                !test_sugg,
-                                expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
-                            )),
-                            (true, true) => None,
-                        };
-
-                        if let Some(sugg) = sugg {
-                            diag.span_suggestion(expr.span, "consider using an `if`/`else` expression", sugg, app);
-                        }
+                    if let Some(sugg) = sugg {
+                        diag.span_suggestion(expr.span, "consider using an `if`/`else` expression", sugg, app);
                     }
                 }
             },
diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs
index bc3783750e5c..bf0c0c4aec3c 100644
--- a/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -1,7 +1,6 @@
 use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
-use clippy_utils::source::walk_span_to_context;
 use clippy_utils::sugg::{Sugg, make_unop};
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::{any_temporaries_need_ordered_drop, for_each_expr_without_closures};
@@ -25,7 +24,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         ..
     }) = higher::WhileLet::hir(expr)
     {
-        find_method_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
+        find_method_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false, let_span);
         find_if_let_true(cx, let_pat, let_expr, let_span);
     }
 }
@@ -39,7 +38,7 @@ pub(super) fn check_if_let<'tcx>(
     let_span: Span,
 ) {
     find_if_let_true(cx, pat, scrutinee, let_span);
-    find_method_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else);
+    find_method_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else, let_span);
 }
 
 /// Looks for:
@@ -182,6 +181,7 @@ fn find_method_sugg_for_if_let<'tcx>(
     let_expr: &'tcx Expr<'_>,
     keyword: &'static str,
     has_else: bool,
+    let_span: Span,
 ) {
     // also look inside refs
     // if we have &None for example, peel it so we can detect "if let None = x"
@@ -239,15 +239,9 @@ fn find_method_sugg_for_if_let<'tcx>(
             let expr_span = expr.span;
             let ctxt = expr.span.ctxt();
 
-            // if/while let ... = ... { ... }
-            //                    ^^^
-            let Some(res_span) = walk_span_to_context(result_expr.span.source_callsite(), ctxt) else {
-                return;
-            };
-
             // if/while let ... = ... { ... }
             // ^^^^^^^^^^^^^^^^^^^^^^
-            let span = expr_span.until(res_span.shrink_to_hi());
+            let span = expr_span.until(let_span.shrink_to_hi());
 
             let mut app = if needs_drop {
                 Applicability::MaybeIncorrect
@@ -273,13 +267,14 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
     if let Ok(arms) = arms.try_into() // TODO: use `slice::as_array` once stabilized
         && let Some((good_method, maybe_guard)) = found_good_method(cx, arms)
     {
-        let span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span.to(op.span));
+        let expr_span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span);
+
         let result_expr = match &op.kind {
             ExprKind::AddrOf(_, _, borrowed) => borrowed,
             _ => op,
         };
         let mut app = Applicability::MachineApplicable;
-        let receiver_sugg = Sugg::hir_with_applicability(cx, result_expr, "_", &mut app).maybe_paren();
+        let receiver_sugg = Sugg::hir_with_context(cx, result_expr, expr_span.ctxt(), "_", &mut app).maybe_paren();
         let mut sugg = format!("{receiver_sugg}.{good_method}");
 
         if let Some(guard) = maybe_guard {
@@ -302,14 +297,14 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                 return;
             }
 
-            let guard = Sugg::hir(cx, guard, "..");
+            let guard = Sugg::hir_with_context(cx, guard, expr_span.ctxt(), "..", &mut app);
             let _ = write!(sugg, " && {}", guard.maybe_paren());
         }
 
         span_lint_and_sugg(
             cx,
             REDUNDANT_PATTERN_MATCHING,
-            span,
+            expr_span,
             format!("redundant pattern matching, consider using `{good_method}`"),
             "try",
             sugg,
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
index add01b6a0837..8135c67d0d78 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
@@ -3,9 +3,9 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::{is_assert_macro, root_macro_call};
 use clippy_utils::res::MaybeResPath;
 use clippy_utils::{find_binding_init, get_parent_expr, is_inside_always_const_context};
-use rustc_hir::{Expr, HirId};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{Expr, HirId, find_attr};
 use rustc_lint::{LateContext, LintContext};
-use rustc_span::sym;
 
 use super::CONST_IS_EMPTY;
 
@@ -40,7 +40,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
 fn is_under_cfg(cx: &LateContext<'_>, id: HirId) -> bool {
     cx.tcx
         .hir_parent_id_iter(id)
-        .any(|id| cx.tcx.hir_attrs(id).iter().any(|attr| attr.has_name(sym::cfg_trace)))
+        .any(|id| find_attr!(cx.tcx.hir_attrs(id), AttributeKind::CfgTrace(..)))
 }
 
 /// Similar to [`clippy_utils::expr_or_init`], but does not go up the chain if the initialization
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
index 16db8663941e..366bfaed73d4 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
@@ -2,7 +2,7 @@ use super::ITER_KV_MAP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::{pat_is_wild, sym};
 use rustc_hir::{Body, Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
@@ -58,6 +58,8 @@ pub(super) fn check<'tcx>(
                 applicability,
             );
         } else {
+            let (body_snippet, _) =
+                snippet_with_context(cx, body_expr.span, expr.span.ctxt(), "..", &mut applicability);
             span_lint_and_sugg(
                 cx,
                 ITER_KV_MAP,
@@ -65,9 +67,8 @@ pub(super) fn check<'tcx>(
                 format!("iterating on a map's {replacement_kind}s"),
                 "try",
                 format!(
-                    "{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{}{bound_ident}| {})",
+                    "{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{}{bound_ident}| {body_snippet})",
                     annotation.prefix_str(),
-                    snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)
                 ),
                 applicability,
             );
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs
index 9dae6fbb48dd..c3f031edff2e 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,10 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::{MaybeDef, MaybeQPath, MaybeResPath, MaybeTypeckRes};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{DefinedTy, ExprUseNode, expr_use_ctxt, peel_blocks, strip_pat_refs};
 use rustc_ast::ast;
 use rustc_data_structures::packed::Pu128;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
 use rustc_hir::PatKind;
 use rustc_hir::def::{DefKind, Res};
@@ -59,6 +59,34 @@ struct Replacement {
     method_name: &'static str,
     has_args: bool,
     has_generic_return: bool,
+    is_short_circuiting: bool,
+}
+
+impl Replacement {
+    fn default_applicability(&self) -> Applicability {
+        if self.is_short_circuiting {
+            Applicability::MaybeIncorrect
+        } else {
+            Applicability::MachineApplicable
+        }
+    }
+
+    fn maybe_add_note(&self, diag: &mut Diag<'_, ()>) {
+        if self.is_short_circuiting {
+            diag.note(format!(
+                "the `{}` method is short circuiting and may change the program semantics if the iterator has side effects",
+                self.method_name
+            ));
+        }
+    }
+
+    fn maybe_turbofish(&self, ty: Ty<'_>) -> String {
+        if self.has_generic_return {
+            format!("::<{ty}>")
+        } else {
+            String::new()
+        }
+    }
 }
 
 fn check_fold_with_op(
@@ -86,32 +114,30 @@ fn check_fold_with_op(
         && left_expr.res_local_id() == Some(first_arg_id)
         && (replacement.has_args || right_expr.res_local_id() == Some(second_arg_id))
     {
-        let mut applicability = Applicability::MachineApplicable;
-
-        let turbofish = if replacement.has_generic_return {
-            format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
-        } else {
-            String::new()
-        };
-
-        let sugg = if replacement.has_args {
-            format!(
-                "{method}{turbofish}(|{second_arg_ident}| {r})",
-                method = replacement.method_name,
-                r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
-            )
-        } else {
-            format!("{method}{turbofish}()", method = replacement.method_name)
-        };
-
-        span_lint_and_sugg(
+        let span = fold_span.with_hi(expr.span.hi());
+        span_lint_and_then(
             cx,
             UNNECESSARY_FOLD,
-            fold_span.with_hi(expr.span.hi()),
+            span,
             "this `.fold` can be written more succinctly using another method",
-            "try",
-            sugg,
-            applicability,
+            |diag| {
+                let mut applicability = replacement.default_applicability();
+                let turbofish =
+                    replacement.maybe_turbofish(cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs());
+                let (r_snippet, _) =
+                    snippet_with_context(cx, right_expr.span, expr.span.ctxt(), "EXPR", &mut applicability);
+                let sugg = if replacement.has_args {
+                    format!(
+                        "{method}{turbofish}(|{second_arg_ident}| {r_snippet})",
+                        method = replacement.method_name,
+                    )
+                } else {
+                    format!("{method}{turbofish}()", method = replacement.method_name)
+                };
+
+                diag.span_suggestion(span, "try", sugg, applicability);
+                replacement.maybe_add_note(diag);
+            },
         );
         return true;
     }
@@ -131,22 +157,25 @@ fn check_fold_with_method(
         // Check if the function belongs to the operator
         && cx.tcx.is_diagnostic_item(method, fn_did)
     {
-        let applicability = Applicability::MachineApplicable;
-
-        let turbofish = if replacement.has_generic_return {
-            format!("::<{}>", cx.typeck_results().expr_ty(expr))
-        } else {
-            String::new()
-        };
-
-        span_lint_and_sugg(
+        let span = fold_span.with_hi(expr.span.hi());
+        span_lint_and_then(
             cx,
             UNNECESSARY_FOLD,
-            fold_span.with_hi(expr.span.hi()),
+            span,
             "this `.fold` can be written more succinctly using another method",
-            "try",
-            format!("{method}{turbofish}()", method = replacement.method_name),
-            applicability,
+            |diag| {
+                diag.span_suggestion(
+                    span,
+                    "try",
+                    format!(
+                        "{method}{turbofish}()",
+                        method = replacement.method_name,
+                        turbofish = replacement.maybe_turbofish(cx.typeck_results().expr_ty(expr))
+                    ),
+                    replacement.default_applicability(),
+                );
+                replacement.maybe_add_note(diag);
+            },
         );
     }
 }
@@ -171,6 +200,7 @@ pub(super) fn check<'tcx>(
                     method_name: "any",
                     has_args: true,
                     has_generic_return: false,
+                    is_short_circuiting: true,
                 };
                 check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Or, replacement);
             },
@@ -179,6 +209,7 @@ pub(super) fn check<'tcx>(
                     method_name: "all",
                     has_args: true,
                     has_generic_return: false,
+                    is_short_circuiting: true,
                 };
                 check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::And, replacement);
             },
@@ -187,6 +218,7 @@ pub(super) fn check<'tcx>(
                     method_name: "sum",
                     has_args: false,
                     has_generic_return: needs_turbofish(cx, expr),
+                    is_short_circuiting: false,
                 };
                 if !check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Add, replacement) {
                     check_fold_with_method(cx, expr, acc, fold_span, sym::add, replacement);
@@ -197,6 +229,7 @@ pub(super) fn check<'tcx>(
                     method_name: "product",
                     has_args: false,
                     has_generic_return: needs_turbofish(cx, expr),
+                    is_short_circuiting: false,
                 };
                 if !check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Mul, replacement) {
                     check_fold_with_method(cx, expr, acc, fold_span, sym::mul, replacement);
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
index a6a39cb6ab30..74e8dbc15a6c 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,7 +3,7 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::{SpanRangeExt, snippet};
+use clippy_utils::source::{SpanRangeExt, snippet, snippet_with_context};
 use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, peel_and_count_ty_refs};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_expr_temporary_value, return_ty, sym};
@@ -131,8 +131,10 @@ fn check_addr_of_expr(
         && (*referent_ty != receiver_ty
             || (matches!(referent_ty.kind(), ty::Array(..)) && is_copy(cx, *referent_ty))
             || is_cow_into_owned(cx, method_name, method_parent_id))
-        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
+        let mut applicability = Applicability::MachineApplicable;
+        let (receiver_snippet, _) = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut applicability);
+
         if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
             span_lint_and_sugg(
                 cx,
@@ -145,7 +147,7 @@ fn check_addr_of_expr(
                     "",
                     width = n_target_refs - n_receiver_refs
                 ),
-                Applicability::MachineApplicable,
+                applicability,
             );
             return true;
         }
@@ -165,8 +167,8 @@ fn check_addr_of_expr(
                     parent.span,
                     format!("unnecessary use of `{method_name}`"),
                     "use",
-                    receiver_snippet.to_owned(),
-                    Applicability::MachineApplicable,
+                    receiver_snippet.to_string(),
+                    applicability,
                 );
             } else {
                 span_lint_and_sugg(
@@ -176,7 +178,7 @@ fn check_addr_of_expr(
                     format!("unnecessary use of `{method_name}`"),
                     "remove this",
                     String::new(),
-                    Applicability::MachineApplicable,
+                    applicability,
                 );
             }
             return true;
@@ -191,7 +193,7 @@ fn check_addr_of_expr(
                 format!("unnecessary use of `{method_name}`"),
                 "use",
                 format!("{receiver_snippet}.as_ref()"),
-                Applicability::MachineApplicable,
+                applicability,
             );
             return true;
         }
@@ -409,8 +411,10 @@ fn check_other_call_arg<'tcx>(
             None
         }
         && can_change_type(cx, maybe_arg, receiver_ty)
-        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
+        let mut applicability = Applicability::MachineApplicable;
+        let (receiver_snippet, _) = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut applicability);
+
         span_lint_and_sugg(
             cx,
             UNNECESSARY_TO_OWNED,
@@ -418,7 +422,7 @@ fn check_other_call_arg<'tcx>(
             format!("unnecessary use of `{method_name}`"),
             "use",
             format!("{:&>n_refs$}{receiver_snippet}", ""),
-            Applicability::MachineApplicable,
+            applicability,
         );
         return true;
     }
diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs
index ac221743cfd6..375b275cd113 100644
--- a/src/tools/clippy/clippy_lints/src/missing_doc.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs
@@ -287,8 +287,8 @@ fn is_doc_attr(attr: &Attribute) -> bool {
     match attr {
         Attribute::Parsed(AttributeKind::DocComment { .. }) => true,
         Attribute::Unparsed(attr)
-            if let [ident] = &*attr.path.segments
-                && ident.name == sym::doc =>
+            if let [name] = &*attr.path.segments
+                && *name == sym::doc =>
         {
             matches!(attr.args, AttrArgs::Eq { .. })
         },
diff --git a/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs b/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs
index eeea6dfd5f4b..5dd38cf059c2 100644
--- a/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs
@@ -82,7 +82,8 @@ impl LateLintPass<'_> for ImportRename {
                     && let Some(import) = match snip.split_once(" as ") {
                         None => Some(snip.as_str()),
                         Some((import, rename)) => {
-                            if rename.trim() == name.as_str() {
+                            let trimmed_rename = rename.trim();
+                            if trimmed_rename == "_" || trimmed_rename == name.as_str() {
                                 None
                             } else {
                                 Some(import.trim())
diff --git a/src/tools/clippy/clippy_lints/src/multiple_bound_locations.rs b/src/tools/clippy/clippy_lints/src/multiple_bound_locations.rs
index 741f38f97560..5b6b4f112455 100644
--- a/src/tools/clippy/clippy_lints/src/multiple_bound_locations.rs
+++ b/src/tools/clippy/clippy_lints/src/multiple_bound_locations.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.78.0"]
     pub MULTIPLE_BOUND_LOCATIONS,
-    suspicious,
+    style,
     "defining generic bounds in multiple locations"
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/mutex_atomic.rs b/src/tools/clippy/clippy_lints/src/mutex_atomic.rs
index 2fef8404f824..ad44d65b4d66 100644
--- a/src/tools/clippy/clippy_lints/src/mutex_atomic.rs
+++ b/src/tools/clippy/clippy_lints/src/mutex_atomic.rs
@@ -143,7 +143,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, ty_ascription: &T
                 && new.ident.name == sym::new
             {
                 let mut applicability = Applicability::MaybeIncorrect;
-                let arg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability);
+                let arg = Sugg::hir_with_context(cx, arg, expr.span.ctxt(), "_", &mut applicability);
                 let mut suggs = vec![(expr.span, format!("std::sync::atomic::{atomic_name}::new({arg})"))];
                 match ty_ascription {
                     TypeAscriptionKind::Required(ty_ascription) => {
diff --git a/src/tools/clippy/clippy_lints/src/needless_bool.rs b/src/tools/clippy/clippy_lints/src/needless_bool.rs
index 854e927aa2f7..6b5db9dcf3e2 100644
--- a/src/tools/clippy/clippy_lints/src/needless_bool.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_bool.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
     SpanlessEq, get_parent_expr, higher, is_block_like, is_else_clause, is_parent_stmt, is_receiver_of_method_call,
@@ -171,8 +171,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                 && SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b)
             {
                 let mut applicability = Applicability::MachineApplicable;
-                let cond = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
-                let lhs = snippet_with_applicability(cx, lhs_a.span, "..", &mut applicability);
+                let cond = Sugg::hir_with_context(cx, cond, e.span.ctxt(), "..", &mut applicability);
+                let (lhs, _) = snippet_with_context(cx, lhs_a.span, e.span.ctxt(), "..", &mut applicability);
                 let mut sugg = if a == b {
                     format!("{cond}; {lhs} = {a:?};")
                 } else {
diff --git a/src/tools/clippy/clippy_lints/src/needless_for_each.rs b/src/tools/clippy/clippy_lints/src/needless_for_each.rs
index d03188f1d39b..55a5a16c0099 100644
--- a/src/tools/clippy/clippy_lints/src/needless_for_each.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_for_each.rs
@@ -56,8 +56,20 @@ declare_lint_pass!(NeedlessForEach => [NEEDLESS_FOR_EACH]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
-            && let ExprKind::MethodCall(method_name, for_each_recv, [for_each_arg], _) = expr.kind
+        if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind {
+            check_expr(cx, expr, stmt.span);
+        }
+    }
+
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+        if let Some(expr) = block.expr {
+            check_expr(cx, expr, expr.span);
+        }
+    }
+}
+
+fn check_expr(cx: &LateContext<'_>, expr: &Expr<'_>, outer_span: Span) {
+    if let ExprKind::MethodCall(method_name, for_each_recv, [for_each_arg], _) = expr.kind
             && let ExprKind::MethodCall(_, iter_recv, [], _) = for_each_recv.kind
             // Skip the lint if the call chain is too long. e.g. `v.field.iter().for_each()` or
             // `v.foo().iter().for_each()` must be skipped.
@@ -76,69 +88,74 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
             // Skip the lint if the body is not safe, so as not to suggest `for … in … unsafe {}`
             // and suggesting `for … in … { unsafe { } }` is a little ugly.
             && !matches!(body.value.kind, ExprKind::Block(Block { rules: BlockCheckMode::UnsafeBlock(_), .. }, ..))
+    {
+        let mut applicability = Applicability::MachineApplicable;
+
+        // If any closure parameter has an explicit type specified, applying the lint would necessarily
+        // remove that specification, possibly breaking type inference
+        if fn_decl
+            .inputs
+            .iter()
+            .any(|input| matches!(input.kind, TyKind::Infer(..)))
         {
-            let mut applicability = Applicability::MachineApplicable;
+            applicability = Applicability::MaybeIncorrect;
+        }
 
-            // If any closure parameter has an explicit type specified, applying the lint would necessarily
-            // remove that specification, possibly breaking type inference
-            if fn_decl
-                .inputs
-                .iter()
-                .any(|input| matches!(input.kind, TyKind::Infer(..)))
-            {
-                applicability = Applicability::MaybeIncorrect;
-            }
+        let mut ret_collector = RetCollector::default();
+        ret_collector.visit_expr(body.value);
 
-            let mut ret_collector = RetCollector::default();
-            ret_collector.visit_expr(body.value);
+        // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
+        if ret_collector.ret_in_loop {
+            return;
+        }
 
-            // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
-            if ret_collector.ret_in_loop {
-                return;
-            }
+        let ret_suggs = if ret_collector.spans.is_empty() {
+            None
+        } else {
+            applicability = Applicability::MaybeIncorrect;
+            Some(
+                ret_collector
+                    .spans
+                    .into_iter()
+                    .map(|span| (span, "continue".to_string()))
+                    .collect(),
+            )
+        };
 
-            let ret_suggs = if ret_collector.spans.is_empty() {
-                None
+        let body_param_sugg = snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability);
+        let for_each_rev_sugg = snippet_with_applicability(cx, for_each_recv.span, "..", &mut applicability);
+        let (body_value_sugg, is_macro_call) =
+            snippet_with_context(cx, body.value.span, for_each_recv.span.ctxt(), "..", &mut applicability);
+
+        let sugg = format!(
+            "for {} in {} {}",
+            body_param_sugg,
+            for_each_rev_sugg,
+            if is_macro_call {
+                format!("{{ {body_value_sugg}; }}")
             } else {
-                applicability = Applicability::MaybeIncorrect;
-                Some(
-                    ret_collector
-                        .spans
-                        .into_iter()
-                        .map(|span| (span, "continue".to_string()))
-                        .collect(),
-                )
-            };
-
-            let body_param_sugg = snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability);
-            let for_each_rev_sugg = snippet_with_applicability(cx, for_each_recv.span, "..", &mut applicability);
-            let (body_value_sugg, is_macro_call) =
-                snippet_with_context(cx, body.value.span, for_each_recv.span.ctxt(), "..", &mut applicability);
-
-            let sugg = format!(
-                "for {} in {} {}",
-                body_param_sugg,
-                for_each_rev_sugg,
-                if is_macro_call {
-                    format!("{{ {body_value_sugg}; }}")
-                } else {
-                    match body.value.kind {
-                        ExprKind::Block(block, _) if is_let_desugar(block) => {
-                            format!("{{ {body_value_sugg} }}")
-                        },
-                        ExprKind::Block(_, _) => body_value_sugg.to_string(),
-                        _ => format!("{{ {body_value_sugg}; }}"),
-                    }
+                match body.value.kind {
+                    ExprKind::Block(block, _) if is_let_desugar(block) => {
+                        format!("{{ {body_value_sugg} }}")
+                    },
+                    ExprKind::Block(_, _) => body_value_sugg.to_string(),
+                    _ => format!("{{ {body_value_sugg}; }}"),
                 }
-            );
+            }
+        );
 
-            span_lint_and_then(cx, NEEDLESS_FOR_EACH, stmt.span, "needless use of `for_each`", |diag| {
-                diag.span_suggestion(stmt.span, "try", sugg, applicability);
+        span_lint_and_then(
+            cx,
+            NEEDLESS_FOR_EACH,
+            outer_span,
+            "needless use of `for_each`",
+            |diag| {
+                diag.span_suggestion(outer_span, "try", sugg, applicability);
                 if let Some(ret_suggs) = ret_suggs {
                     diag.multipart_suggestion("...and replace `return` with `continue`", ret_suggs, applicability);
                 }
-            });
-        }
+            },
+        );
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/new_without_default.rs b/src/tools/clippy/clippy_lints/src/new_without_default.rs
index 6fc034b6fc5d..e151c06c6c20 100644
--- a/src/tools/clippy/clippy_lints/src/new_without_default.rs
+++ b/src/tools/clippy/clippy_lints/src/new_without_default.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::return_ty;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_with_applicability};
 use clippy_utils::sugg::DiagExt;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::HirIdSet;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{Attribute, HirIdSet};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::AssocKind;
 use rustc_session::impl_lint_pass;
@@ -57,6 +58,7 @@ pub struct NewWithoutDefault {
 impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
 
 impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
+    #[expect(clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let hir::ItemKind::Impl(hir::Impl {
             of_trait: None,
@@ -121,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                 let attrs_sugg = {
                     let mut sugg = String::new();
                     for attr in cx.tcx.hir_attrs(assoc_item_hir_id) {
-                        if !attr.has_name(sym::cfg_trace) {
+                        let Attribute::Parsed(AttributeKind::CfgTrace(attrs)) = attr else {
                             // This might be some other attribute that the `impl Default` ought to inherit.
                             // But it could also be one of the many attributes that:
                             // - can't be put on an impl block -- like `#[inline]`
@@ -131,19 +133,40 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // reduce the applicability
                             app = Applicability::MaybeIncorrect;
                             continue;
-                        }
+                        };
 
-                        sugg.push_str(&snippet_with_applicability(cx.sess(), attr.span(), "_", &mut app));
-                        sugg.push('\n');
+                        for (_, attr_span) in attrs {
+                            sugg.push_str(&snippet_with_applicability(cx.sess(), *attr_span, "_", &mut app));
+                            sugg.push('\n');
+                        }
                     }
                     sugg
                 };
                 let generics_sugg = snippet_with_applicability(cx, generics.span, "", &mut app);
                 let where_clause_sugg = if generics.has_where_clause_predicates {
-                    format!(
-                        "\n{}\n",
-                        snippet_with_applicability(cx, generics.where_clause_span, "", &mut app)
-                    )
+                    let where_clause_sugg =
+                        snippet_with_applicability(cx, generics.where_clause_span, "", &mut app).to_string();
+                    let mut where_clause_sugg = reindent_multiline(&where_clause_sugg, true, Some(4));
+                    if impl_item.generics.has_where_clause_predicates {
+                        if !where_clause_sugg.ends_with(',') {
+                            where_clause_sugg.push(',');
+                        }
+
+                        let additional_where_preds =
+                            snippet_with_applicability(cx, impl_item.generics.where_clause_span, "", &mut app);
+                        let ident = indent_of(cx, generics.where_clause_span).unwrap_or(0);
+                        // Remove the leading `where ` keyword
+                        let additional_where_preds = additional_where_preds.trim_start_matches("where").trim_start();
+                        where_clause_sugg.push('\n');
+                        where_clause_sugg.extend(std::iter::repeat_n(' ', ident));
+                        where_clause_sugg.push_str(additional_where_preds);
+                    }
+                    format!("\n{where_clause_sugg}\n")
+                } else if impl_item.generics.has_where_clause_predicates {
+                    let where_clause_sugg =
+                        snippet_with_applicability(cx, impl_item.generics.where_clause_span, "", &mut app);
+                    let where_clause_sugg = reindent_multiline(&where_clause_sugg, true, Some(4));
+                    format!("\n{}\n", where_clause_sugg.trim_start())
                 } else {
                     String::new()
                 };
diff --git a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
index 05358de5b348..39097833a6c5 100644
--- a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeQPath;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -94,51 +94,37 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
                 return;
             }
 
-            let arg_snip = snippet(cx, arg_span, "..");
-            let expr_snip;
-            let eq_impl;
-            if with_deref.is_implemented() && !arg_ty.peel_refs().is_str() {
-                expr_snip = format!("*{arg_snip}");
-                eq_impl = with_deref;
+            let mut applicability = Applicability::MachineApplicable;
+            let (arg_snip, _) = snippet_with_context(cx, arg_span, expr.span.ctxt(), "..", &mut applicability);
+            let (expr_snip, eq_impl) = if with_deref.is_implemented() && !arg_ty.peel_refs().is_str() {
+                (format!("*{arg_snip}"), with_deref)
             } else {
-                expr_snip = arg_snip.to_string();
-                eq_impl = without_deref;
-            }
+                (arg_snip.to_string(), without_deref)
+            };
 
-            let span;
-            let hint;
-            if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
-                span = expr.span;
-                hint = expr_snip;
+            let (span, hint) = if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
+                (expr.span, expr_snip)
             } else {
-                span = expr.span.to(other.span);
+                let span = expr.span.to(other.span);
 
                 let cmp_span = if other.span < expr.span {
                     other.span.between(expr.span)
                 } else {
                     expr.span.between(other.span)
                 };
-                if eq_impl.ty_eq_other {
-                    hint = format!(
-                        "{expr_snip}{}{}",
-                        snippet(cx, cmp_span, ".."),
-                        snippet(cx, other.span, "..")
-                    );
-                } else {
-                    hint = format!(
-                        "{}{}{expr_snip}",
-                        snippet(cx, other.span, ".."),
-                        snippet(cx, cmp_span, "..")
-                    );
-                }
-            }
 
-            diag.span_suggestion(
-                span,
-                "try",
-                hint,
-                Applicability::MachineApplicable, // snippet
-            );
+                let (cmp_snippet, _) = snippet_with_context(cx, cmp_span, expr.span.ctxt(), "..", &mut applicability);
+                let (other_snippet, _) =
+                    snippet_with_context(cx, other.span, expr.span.ctxt(), "..", &mut applicability);
+
+                if eq_impl.ty_eq_other {
+                    (span, format!("{expr_snip}{cmp_snippet}{other_snippet}"))
+                } else {
+                    (span, format!("{other_snippet}{cmp_snippet}{expr_snip}"))
+                }
+            };
+
+            diag.span_suggestion(span, "try", hint, applicability);
         },
     );
 }
diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
index 98aa47421537..5ed923d719bc 100644
--- a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::sugg::{Sugg, has_enclosing_paren};
 use clippy_utils::{SpanlessEq, sym};
 use rustc_ast::{BinOpKind, LitIntType, LitKind, UnOp};
@@ -7,7 +8,7 @@ use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self};
+use rustc_middle::ty::{self, Ty};
 use rustc_span::source_map::Spanned;
 
 use super::MANUAL_DIV_CEIL;
@@ -16,59 +17,84 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, op: BinOpKind, lhs: &
     let mut applicability = Applicability::MachineApplicable;
 
     if op == BinOpKind::Div
-        && check_int_ty_and_feature(cx, lhs)
-        && check_int_ty_and_feature(cx, rhs)
-        && let ExprKind::Binary(inner_op, inner_lhs, inner_rhs) = lhs.kind
+        && check_int_ty_and_feature(cx, cx.typeck_results().expr_ty(lhs))
+        && check_int_ty_and_feature(cx, cx.typeck_results().expr_ty(rhs))
         && msrv.meets(cx, msrvs::DIV_CEIL)
     {
-        // (x + (y - 1)) / y
-        if let ExprKind::Binary(sub_op, sub_lhs, sub_rhs) = inner_rhs.kind
-            && inner_op.node == BinOpKind::Add
-            && sub_op.node == BinOpKind::Sub
-            && check_literal(sub_rhs)
-            && check_eq_expr(cx, sub_lhs, rhs)
-        {
-            build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
-            return;
-        }
+        match lhs.kind {
+            ExprKind::Binary(inner_op, inner_lhs, inner_rhs) => {
+                // (x + (y - 1)) / y
+                if let ExprKind::Binary(sub_op, sub_lhs, sub_rhs) = inner_rhs.kind
+                    && inner_op.node == BinOpKind::Add
+                    && sub_op.node == BinOpKind::Sub
+                    && check_literal(sub_rhs)
+                    && check_eq_expr(cx, sub_lhs, rhs)
+                {
+                    build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
+                    return;
+                }
 
-        // ((y - 1) + x) / y
-        if let ExprKind::Binary(sub_op, sub_lhs, sub_rhs) = inner_lhs.kind
-            && inner_op.node == BinOpKind::Add
-            && sub_op.node == BinOpKind::Sub
-            && check_literal(sub_rhs)
-            && check_eq_expr(cx, sub_lhs, rhs)
-        {
-            build_suggestion(cx, expr, inner_rhs, rhs, &mut applicability);
-            return;
-        }
+                // ((y - 1) + x) / y
+                if let ExprKind::Binary(sub_op, sub_lhs, sub_rhs) = inner_lhs.kind
+                    && inner_op.node == BinOpKind::Add
+                    && sub_op.node == BinOpKind::Sub
+                    && check_literal(sub_rhs)
+                    && check_eq_expr(cx, sub_lhs, rhs)
+                {
+                    build_suggestion(cx, expr, inner_rhs, rhs, &mut applicability);
+                    return;
+                }
 
-        // (x + y - 1) / y
-        if let ExprKind::Binary(add_op, add_lhs, add_rhs) = inner_lhs.kind
-            && inner_op.node == BinOpKind::Sub
-            && add_op.node == BinOpKind::Add
-            && check_literal(inner_rhs)
-            && check_eq_expr(cx, add_rhs, rhs)
-        {
-            build_suggestion(cx, expr, add_lhs, rhs, &mut applicability);
-        }
+                // (x + y - 1) / y
+                if let ExprKind::Binary(add_op, add_lhs, add_rhs) = inner_lhs.kind
+                    && inner_op.node == BinOpKind::Sub
+                    && add_op.node == BinOpKind::Add
+                    && check_literal(inner_rhs)
+                    && check_eq_expr(cx, add_rhs, rhs)
+                {
+                    build_suggestion(cx, expr, add_lhs, rhs, &mut applicability);
+                }
 
-        // (x + (Y - 1)) / Y
-        if inner_op.node == BinOpKind::Add && differ_by_one(inner_rhs, rhs) {
-            build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
-        }
+                // (x + (Y - 1)) / Y
+                if inner_op.node == BinOpKind::Add && differ_by_one(inner_rhs, rhs) {
+                    build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
+                }
 
-        // ((Y - 1) + x) / Y
-        if inner_op.node == BinOpKind::Add && differ_by_one(inner_lhs, rhs) {
-            build_suggestion(cx, expr, inner_rhs, rhs, &mut applicability);
-        }
+                // ((Y - 1) + x) / Y
+                if inner_op.node == BinOpKind::Add && differ_by_one(inner_lhs, rhs) {
+                    build_suggestion(cx, expr, inner_rhs, rhs, &mut applicability);
+                }
 
-        // (x - (-Y - 1)) / Y
-        if inner_op.node == BinOpKind::Sub
-            && let ExprKind::Unary(UnOp::Neg, abs_div_rhs) = rhs.kind
-            && differ_by_one(abs_div_rhs, inner_rhs)
-        {
-            build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
+                // (x - (-Y - 1)) / Y
+                if inner_op.node == BinOpKind::Sub
+                    && let ExprKind::Unary(UnOp::Neg, abs_div_rhs) = rhs.kind
+                    && differ_by_one(abs_div_rhs, inner_rhs)
+                {
+                    build_suggestion(cx, expr, inner_lhs, rhs, &mut applicability);
+                }
+            },
+            ExprKind::MethodCall(method, receiver, [next_multiple_of_arg], _) => {
+                // x.next_multiple_of(Y) / Y
+                if method.ident.name == sym::next_multiple_of
+                    && check_int_ty(cx.typeck_results().expr_ty(receiver))
+                    && check_eq_expr(cx, next_multiple_of_arg, rhs)
+                {
+                    build_suggestion(cx, expr, receiver, rhs, &mut applicability);
+                }
+            },
+            ExprKind::Call(callee, [receiver, next_multiple_of_arg]) => {
+                // int_type::next_multiple_of(x, Y) / Y
+                if let Some(impl_ty_binder) = callee
+                    .ty_rel_def_if_named(cx, sym::next_multiple_of)
+                    .assoc_fn_parent(cx)
+                    .opt_impl_ty(cx)
+                    && check_int_ty(impl_ty_binder.skip_binder())
+                    && check_eq_expr(cx, next_multiple_of_arg, rhs)
+                {
+                    build_suggestion(cx, expr, receiver, rhs, &mut applicability);
+                }
+            },
+            _ => (),
         }
     }
 }
@@ -91,8 +117,11 @@ fn differ_by_one(small_expr: &Expr<'_>, large_expr: &Expr<'_>) -> bool {
     }
 }
 
-fn check_int_ty_and_feature(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr);
+fn check_int_ty(expr_ty: Ty<'_>) -> bool {
+    matches!(expr_ty.peel_refs().kind(), ty::Int(_) | ty::Uint(_))
+}
+
+fn check_int_ty_and_feature(cx: &LateContext<'_>, expr_ty: Ty<'_>) -> bool {
     match expr_ty.peel_refs().kind() {
         ty::Uint(_) => true,
         ty::Int(_) => cx.tcx.features().enabled(sym::int_roundings),
diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs b/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs
index 0b9bd4fb6d32..291d81097b51 100644
--- a/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs
@@ -35,7 +35,7 @@ pub(super) fn check<'tcx>(
     {
         let mut app = Applicability::MachineApplicable;
         let divisor = deref_sugg(
-            Sugg::hir_with_applicability(cx, operand_right, "_", &mut app),
+            Sugg::hir_with_context(cx, operand_right, expr.span.ctxt(), "_", &mut app),
             cx.typeck_results().expr_ty_adjusted(operand_right),
         );
         span_lint_and_sugg(
@@ -47,7 +47,7 @@ pub(super) fn check<'tcx>(
             format!(
                 "{}{}.is_multiple_of({divisor})",
                 if op == BinOpKind::Eq { "" } else { "!" },
-                Sugg::hir_with_applicability(cx, operand_left, "_", &mut app).maybe_paren()
+                Sugg::hir_with_context(cx, operand_left, expr.span.ctxt(), "_", &mut app).maybe_paren()
             ),
             app,
         );
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
index 59d31f782bc3..e5fb3c0fa431 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -5,7 +5,7 @@ use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::{MaybeDef, MaybeQPath, MaybeResPath};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::usage::local_used_after_expr;
@@ -147,7 +147,8 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && !span_contains_cfg(cx, els.span)
     {
         let mut applicability = Applicability::MaybeIncorrect;
-        let init_expr_str = Sugg::hir_with_applicability(cx, init_expr, "..", &mut applicability).maybe_paren();
+        let init_expr_str =
+            Sugg::hir_with_context(cx, init_expr, stmt.span.ctxt(), "..", &mut applicability).maybe_paren();
         // Take care when binding is `ref`
         let sugg = if let PatKind::Binding(
             BindingMode(ByRef::Yes(_, ref_mutability), binding_mutability),
@@ -295,7 +296,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex
         && (is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block))
     {
         let mut applicability = Applicability::MachineApplicable;
-        let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+        let receiver_str = snippet_with_context(cx, caller.span, expr.span.ctxt(), "..", &mut applicability).0;
         let by_ref = !cx.type_is_copy_modulo_regions(caller_ty)
             && !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
         let sugg = if let Some(else_inner) = r#else {
diff --git a/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs b/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs
index 92d1b112198f..e4906eb0c777 100644
--- a/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs
+++ b/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs
@@ -98,7 +98,7 @@ impl LateLintPass<'_> for SingleRangeInVecInit {
             && snippet.starts_with(suggested_type.starts_with())
             && snippet.ends_with(suggested_type.ends_with())
         {
-            let mut applicability = Applicability::MachineApplicable;
+            let mut applicability = Applicability::MaybeIncorrect;
             let (start_snippet, _) = snippet_with_context(cx, start.expr.span, span.ctxt(), "..", &mut applicability);
             let (end_snippet, _) = snippet_with_context(cx, end.expr.span, span.ctxt(), "..", &mut applicability);
 
diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs
index 1d0efa46a14c..c0be724bcdee 100644
--- a/src/tools/clippy/clippy_lints/src/strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strings.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::res::{MaybeDef, MaybeQPath};
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::{
     SpanlessEq, get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, method_calls, peel_blocks, sym,
 };
@@ -273,6 +273,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
             let string_expression = &expressions[0].0;
 
             let snippet_app = snippet_with_applicability(cx, string_expression.span, "..", &mut applicability);
+            let (right_snip, _) = snippet_with_context(cx, right.span, e.span.ctxt(), "..", &mut applicability);
 
             span_lint_and_sugg(
                 cx,
@@ -280,7 +281,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                 e.span,
                 "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
                 "try",
-                format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
+                format!("Some(&{snippet_app}[{right_snip}])"),
                 applicability,
             );
         }
@@ -404,7 +405,8 @@ impl<'tcx> LateLintPass<'tcx> for StrToString {
                 "`to_string()` called on a `&str`",
                 |diag| {
                     let mut applicability = Applicability::MachineApplicable;
-                    let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
+                    let (snippet, _) =
+                        snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut applicability);
                     diag.span_suggestion(expr.span, "try", format!("{snippet}.to_owned()"), applicability);
                 },
             );
diff --git a/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs b/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs
index 58d692db5029..0d50bd547652 100644
--- a/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs
@@ -14,8 +14,8 @@ declare_clippy_lint! {
     /// and suggest calling `as_bytes().len()` or `to_bytes().len()` respectively instead.
     ///
     /// ### Why is this bad?
-    /// This avoids calling an unsafe `libc` function.
-    /// Currently, it also avoids calculating the length.
+    /// libc::strlen is an unsafe function, which we don't need to call
+    /// if all we want to know is the length of the c-string.
     ///
     /// ### Example
     /// ```rust, ignore
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs b/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
index 31e770f421e1..3f435f255d91 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
@@ -2,7 +2,7 @@ use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_integer_const;
 use clippy_utils::res::{MaybeDef, MaybeResPath};
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{ConstBlock, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::symbol::sym;
@@ -42,5 +42,23 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         return true;
     }
 
+    // Catching:
+    // `std::mem::transmute({ 0 as *const u64 })` and similar const blocks
+    if let ExprKind::Block(block, _) = arg.kind
+        && block.stmts.is_empty()
+        && let Some(inner) = block.expr
+    {
+        // Run again with the inner expression
+        return check(cx, expr, inner, to_ty);
+    }
+
+    // Catching:
+    // `std::mem::transmute(const { u64::MIN as *const u64 });`
+    if let ExprKind::ConstBlock(ConstBlock { body, .. }) = arg.kind {
+        // Strip out the const and run again
+        let block = cx.tcx.hir_body(body).value;
+        return check(cx, expr, block, to_ty);
+    }
+
     false
 }
diff --git a/src/tools/clippy/clippy_lints/src/useless_conversion.rs b/src/tools/clippy/clippy_lints/src/useless_conversion.rs
index c06313d1a4c4..423301edfe83 100644
--- a/src/tools/clippy/clippy_lints/src/useless_conversion.rs
+++ b/src/tools/clippy/clippy_lints/src/useless_conversion.rs
@@ -456,13 +456,25 @@ fn has_eligible_receiver(cx: &LateContext<'_>, recv: &Expr<'_>, expr: &Expr<'_>)
 
 fn adjustments(cx: &LateContext<'_>, expr: &Expr<'_>) -> String {
     let mut prefix = String::new();
-    for adj in cx.typeck_results().expr_adjustments(expr) {
+
+    let adjustments = cx.typeck_results().expr_adjustments(expr);
+
+    let [.., last] = adjustments else { return prefix };
+    let target = last.target;
+
+    for adj in adjustments {
         match adj.kind {
             Adjust::Deref(_) => prefix = format!("*{prefix}"),
             Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::Mut { .. })) => prefix = format!("&mut {prefix}"),
             Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::Not)) => prefix = format!("&{prefix}"),
             _ => {},
         }
+
+        // Stop once we reach the final target type.
+        // This prevents over-adjusting (e.g. suggesting &**y instead of *y).
+        if adj.target == target {
+            break;
+        }
     }
     prefix
 }
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index 90fa976fda38..acea701b2e83 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -320,8 +320,11 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 self.body(field!(anon_const.body));
             },
             ConstArgKind::Struct(..) => chain!(self, "let ConstArgKind::Struct(..) = {const_arg}.kind"),
+            ConstArgKind::TupleCall(..) => chain!(self, "let ConstArgKind::TupleCall(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
+            ConstArgKind::Tup(..) => chain!(self, "let ConstArgKind::Tup(..) = {const_arg}.kind"),
+            ConstArgKind::Literal(..) => chain!(self, "let ConstArgKind::Literal(..) = {const_arg}.kind")
         }
     }
 
diff --git a/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs b/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
index fda65bc84eda..f56b6f31550b 100644
--- a/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
+++ b/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
@@ -250,8 +250,8 @@ pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<
         if let hir::Attribute::Unparsed(attr_kind) = &attr
             // Identify attribute
             && let [tool_name, attr_name] = &attr_kind.path.segments[..]
-            && tool_name.name == sym::clippy
-            && attr_name.name == sym::version
+            && tool_name == &sym::clippy
+            && attr_name == &sym::version
             && let Some(version) = attr.value_str()
         {
             Some(version)
diff --git a/src/tools/clippy/clippy_utils/README.md b/src/tools/clippy/clippy_utils/README.md
index 01257c1a3059..ecd36b157571 100644
--- a/src/tools/clippy/clippy_utils/README.md
+++ b/src/tools/clippy/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-12-25
+nightly-2026-01-08
 ```
 <!-- end autogenerated nightly -->
 
@@ -30,7 +30,7 @@ Function signatures can change or be removed without replacement without any pri
 
 <!-- REUSE-IgnoreStart -->
 
-Copyright 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Licensed under the Apache License, Version 2.0
 <[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)> or the MIT license
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
index 432d7a251a21..cf8716398efb 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -976,11 +976,21 @@ pub fn eq_attr(l: &Attribute, r: &Attribute) -> bool {
     l.style == r.style
         && match (&l.kind, &r.kind) {
             (DocComment(l1, l2), DocComment(r1, r2)) => l1 == r1 && l2 == r2,
-            (Normal(l), Normal(r)) => eq_path(&l.item.path, &r.item.path) && eq_attr_args(&l.item.args, &r.item.args),
+            (Normal(l), Normal(r)) => {
+                eq_path(&l.item.path, &r.item.path) && eq_attr_item_kind(&l.item.args, &r.item.args)
+            },
             _ => false,
         }
 }
 
+pub fn eq_attr_item_kind(l: &AttrItemKind, r: &AttrItemKind) -> bool {
+    match (l, r) {
+        (AttrItemKind::Unparsed(l), AttrItemKind::Unparsed(r)) => eq_attr_args(l, r),
+        (AttrItemKind::Parsed(_l), AttrItemKind::Parsed(_r)) => todo!(),
+        _ => false,
+    }
+}
+
 pub fn eq_attr_args(l: &AttrArgs, r: &AttrArgs) -> bool {
     use AttrArgs::*;
     match (l, r) {
diff --git a/src/tools/clippy/clippy_utils/src/attrs.rs b/src/tools/clippy/clippy_utils/src/attrs.rs
index 8820801853e0..32f6cb4fd5e9 100644
--- a/src/tools/clippy/clippy_utils/src/attrs.rs
+++ b/src/tools/clippy/clippy_utils/src/attrs.rs
@@ -20,10 +20,13 @@ pub fn get_builtin_attr<'a, A: AttributeExt + 'a>(
     name: Symbol,
 ) -> impl Iterator<Item = &'a A> {
     attrs.iter().filter(move |attr| {
-        if let Some([clippy, segment2]) = attr.ident_path().as_deref()
-            && clippy.name == sym::clippy
+        if let [clippy, segment2] = &*attr.path()
+            && *clippy == sym::clippy
         {
-            let new_name = match segment2.name {
+            let path_span = attr
+                .path_span()
+                .expect("Clippy attributes are unparsed and have a span");
+            let new_name = match *segment2 {
                 sym::cyclomatic_complexity => Some("cognitive_complexity"),
                 sym::author
                 | sym::version
@@ -35,7 +38,7 @@ pub fn get_builtin_attr<'a, A: AttributeExt + 'a>(
                 | sym::has_significant_drop
                 | sym::format_args => None,
                 _ => {
-                    sess.dcx().span_err(segment2.span, "usage of unknown attribute");
+                    sess.dcx().span_err(path_span, "usage of unknown attribute");
                     return false;
                 },
             };
@@ -43,17 +46,17 @@ pub fn get_builtin_attr<'a, A: AttributeExt + 'a>(
             match new_name {
                 Some(new_name) => {
                     sess.dcx()
-                        .struct_span_err(segment2.span, "usage of deprecated attribute")
+                        .struct_span_err(path_span, "usage of deprecated attribute")
                         .with_span_suggestion(
-                            segment2.span,
+                            path_span,
                             "consider using",
-                            new_name,
+                            format!("clippy::{new_name}"),
                             Applicability::MachineApplicable,
                         )
                         .emit();
                     false
                 },
-                None => segment2.name == name,
+                None => *segment2 == name,
             }
         } else {
             false
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
index d9254fca9453..7fb8616072a5 100644
--- a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
+++ b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
@@ -348,9 +348,9 @@ fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirI
 fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
     match attr.kind {
         AttrKind::Normal(..) => {
-            if let Some(ident) = attr.ident() {
+            if let Some(name) = attr.name() {
                 // NOTE: This will likely have false positives, like `allow = 1`
-                let ident_string = ident.to_string();
+                let ident_string = name.to_string();
                 if attr.style == AttrStyle::Outer {
                     (
                         Pat::OwnedMultiStr(vec!["#[".to_owned() + &ident_string, ident_string]),
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
index 78e3d6d192a0..538f1fd2628c 100644
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -1140,9 +1140,13 @@ pub fn const_item_rhs_to_expr<'tcx>(tcx: TyCtxt<'tcx>, ct_rhs: ConstItemRhs<'tcx
         ConstItemRhs::Body(body_id) => Some(tcx.hir_body(body_id).value),
         ConstItemRhs::TypeConst(const_arg) => match const_arg.kind {
             ConstArgKind::Anon(anon) => Some(tcx.hir_body(anon.body).value),
-            ConstArgKind::Struct(..) | ConstArgKind::Path(_) | ConstArgKind::Error(..) | ConstArgKind::Infer(..) => {
-                None
-            },
+            ConstArgKind::Struct(..)
+            | ConstArgKind::Tup(..)
+            | ConstArgKind::Literal(..)
+            | ConstArgKind::TupleCall(..)
+            | ConstArgKind::Path(_)
+            | ConstArgKind::Error(..)
+            | ConstArgKind::Infer(..) => None,
         },
     }
 }
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 03853b5b4af5..0bb641568879 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -661,7 +661,14 @@ impl HirEqInterExpr<'_, '_, '_> {
     }
 
     fn eq_const_arg(&mut self, left: &ConstArg<'_>, right: &ConstArg<'_>) -> bool {
+        if !self.check_ctxt(left.span.ctxt(), right.span.ctxt()) {
+            return false;
+        }
+
         match (&left.kind, &right.kind) {
+            (ConstArgKind::Tup(l_t), ConstArgKind::Tup(r_t)) => {
+                l_t.len() == r_t.len() && l_t.iter().zip(*r_t).all(|(l_c, r_c)| self.eq_const_arg(*l_c, *r_c))
+            },
             (ConstArgKind::Path(l_p), ConstArgKind::Path(r_p)) => self.eq_qpath(l_p, r_p),
             (ConstArgKind::Anon(l_an), ConstArgKind::Anon(r_an)) => self.eq_body(l_an.body, r_an.body),
             (ConstArgKind::Infer(..), ConstArgKind::Infer(..)) => true,
@@ -672,12 +679,23 @@ impl HirEqInterExpr<'_, '_, '_> {
                         .zip(*inits_b)
                         .all(|(init_a, init_b)| self.eq_const_arg(init_a.expr, init_b.expr))
             },
+            (ConstArgKind::TupleCall(path_a, args_a), ConstArgKind::TupleCall(path_b, args_b)) => {
+                self.eq_qpath(path_a, path_b)
+                    && args_a
+                        .iter()
+                        .zip(*args_b)
+                        .all(|(arg_a, arg_b)| self.eq_const_arg(arg_a, arg_b))
+            },
+            (ConstArgKind::Literal(kind_l), ConstArgKind::Literal(kind_r)) => kind_l == kind_r,
             // Use explicit match for now since ConstArg is undergoing flux.
             (
                 ConstArgKind::Path(..)
+                | ConstArgKind::Tup(..)
                 | ConstArgKind::Anon(..)
+                | ConstArgKind::TupleCall(..)
                 | ConstArgKind::Infer(..)
                 | ConstArgKind::Struct(..)
+                | ConstArgKind::Literal(..)
                 | ConstArgKind::Error(..),
                 _,
             ) => false,
@@ -1538,6 +1556,11 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
 
     fn hash_const_arg(&mut self, const_arg: &ConstArg<'_>) {
         match &const_arg.kind {
+            ConstArgKind::Tup(tup) => {
+                for arg in *tup {
+                    self.hash_const_arg(*arg);
+                }
+            },
             ConstArgKind::Path(path) => self.hash_qpath(path),
             ConstArgKind::Anon(anon) => self.hash_body(anon.body),
             ConstArgKind::Struct(path, inits) => {
@@ -1546,7 +1569,14 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_const_arg(init.expr);
                 }
             },
+            ConstArgKind::TupleCall(path, args) => {
+                self.hash_qpath(path);
+                for arg in *args {
+                    self.hash_const_arg(arg);
+                }
+            },
             ConstArgKind::Infer(..) | ConstArgKind::Error(..) => {},
+            ConstArgKind::Literal(lit) => lit.hash(&mut self.s),
         }
     }
 
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 954c32687af6..2a620e917228 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -90,13 +90,13 @@ use std::sync::{Mutex, MutexGuard, OnceLock};
 use itertools::Itertools;
 use rustc_abi::Integer;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
-use rustc_ast::join_path_syms;
+use rustc_ast::{LitIntType, join_path_syms};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexmap;
 use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnindexMap;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
-use rustc_hir::attrs::AttributeKind;
+use rustc_hir::attrs::{AttributeKind, CfgEntry};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::definitions::{DefPath, DefPathData};
@@ -1385,6 +1385,17 @@ pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
     false
 }
 
+/// Checks whether the given expression is an untyped integer literal.
+pub fn is_integer_literal_untyped(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Lit(spanned) = expr.kind
+        && let LitKind::Int(_, suffix) = spanned.node
+    {
+        return suffix == LitIntType::Unsuffixed;
+    }
+
+    false
+}
+
 /// Checks whether the given expression is a constant literal of the given value.
 pub fn is_float_literal(expr: &Expr<'_>, value: f64) -> bool {
     if let ExprKind::Lit(spanned) = expr.kind
@@ -2401,17 +2412,15 @@ pub fn is_test_function(tcx: TyCtxt<'_>, fn_def_id: LocalDefId) -> bool {
 /// This only checks directly applied attributes, to see if a node is inside a `#[cfg(test)]` parent
 /// use [`is_in_cfg_test`]
 pub fn is_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
-    tcx.hir_attrs(id).iter().any(|attr| {
-        if attr.has_name(sym::cfg_trace)
-            && let Some(items) = attr.meta_item_list()
-            && let [item] = &*items
-            && item.has_name(sym::test)
-        {
-            true
-        } else {
-            false
-        }
-    })
+    if let Some(cfgs) = find_attr!(tcx.hir_attrs(id), AttributeKind::CfgTrace(cfgs) => cfgs)
+        && cfgs
+            .iter()
+            .any(|(cfg, _)| matches!(cfg, CfgEntry::NameValue { name: sym::test, .. }))
+    {
+        true
+    } else {
+        false
+    }
 }
 
 /// Checks if any parent node of `HirId` has `#[cfg(test)]` attribute applied
@@ -2426,11 +2435,12 @@ pub fn is_in_test(tcx: TyCtxt<'_>, hir_id: HirId) -> bool {
 
 /// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
 pub fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    tcx.has_attr(def_id, sym::cfg_trace)
-        || tcx
-            .hir_parent_iter(tcx.local_def_id_to_hir_id(def_id))
-            .flat_map(|(parent_id, _)| tcx.hir_attrs(parent_id))
-            .any(|attr| attr.has_name(sym::cfg_trace))
+    find_attr!(tcx.get_all_attrs(def_id), AttributeKind::CfgTrace(..))
+        || find_attr!(
+            tcx.hir_parent_iter(tcx.local_def_id_to_hir_id(def_id))
+                .flat_map(|(parent_id, _)| tcx.hir_attrs(parent_id)),
+            AttributeKind::CfgTrace(..)
+        )
 }
 
 /// Walks up the HIR tree from the given expression in an attempt to find where the value is
diff --git a/src/tools/clippy/clippy_utils/src/res.rs b/src/tools/clippy/clippy_utils/src/res.rs
index a3efece7d224..e890a73620a5 100644
--- a/src/tools/clippy/clippy_utils/src/res.rs
+++ b/src/tools/clippy/clippy_utils/src/res.rs
@@ -301,7 +301,7 @@ impl<'tcx> MaybeQPath<'tcx> for &'tcx PatExpr<'_> {
     fn opt_qpath(self) -> Option<QPathId<'tcx>> {
         match &self.kind {
             PatExprKind::Path(qpath) => Some((qpath, self.hir_id)),
-            _ => None,
+            PatExprKind::Lit { .. } => None,
         }
     }
 }
@@ -419,7 +419,7 @@ impl<'a> MaybeResPath<'a> for &PatExpr<'a> {
     fn opt_res_path(self) -> OptResPath<'a> {
         match &self.kind {
             PatExprKind::Path(qpath) => qpath.opt_res_path(),
-            _ => (None, None),
+            PatExprKind::Lit { .. } => (None, None),
         }
     }
 }
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index 2ef2afb45071..3ade38bea8ed 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -127,7 +127,7 @@ impl<'a> Sugg<'a> {
 
     /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
     /// function variants of `Sugg`, since these use different snippet functions.
-    fn hir_from_snippet(
+    pub fn hir_from_snippet(
         cx: &LateContext<'_>,
         expr: &hir::Expr<'_>,
         mut get_snippet: impl FnMut(Span) -> Cow<'a, str>,
diff --git a/src/tools/clippy/clippy_utils/src/sym.rs b/src/tools/clippy/clippy_utils/src/sym.rs
index a0d2e8673fe6..94591a7ee30a 100644
--- a/src/tools/clippy/clippy_utils/src/sym.rs
+++ b/src/tools/clippy/clippy_utils/src/sym.rs
@@ -62,7 +62,6 @@ generate! {
     MsrvStack,
     Octal,
     OpenOptions,
-    Other,
     PathLookup,
     Regex,
     RegexBuilder,
@@ -248,6 +247,7 @@ generate! {
     next_back,
     next_if,
     next_if_eq,
+    next_multiple_of,
     next_tuple,
     nth,
     ok,
diff --git a/src/tools/clippy/rust-toolchain.toml b/src/tools/clippy/rust-toolchain.toml
index dbec79e111fb..0755e1d29c69 100644
--- a/src/tools/clippy/rust-toolchain.toml
+++ b/src/tools/clippy/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-12-25"
+channel = "nightly-2026-01-08"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/src/tools/clippy/rustc_tools_util/README.md b/src/tools/clippy/rustc_tools_util/README.md
index f47a4c69c2c3..45d2844ad00b 100644
--- a/src/tools/clippy/rustc_tools_util/README.md
+++ b/src/tools/clippy/rustc_tools_util/README.md
@@ -51,7 +51,7 @@ The changelog for `rustc_tools_util` is available under:
 
 <!-- REUSE-IgnoreStart -->
 
-Copyright 2014-2025 The Rust Project Developers
+Copyright (c) The Rust Project Contributors
 
 Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/clippy.toml b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/clippy.toml
index 05ba822874d5..11af5b0a3306 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/clippy.toml
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/clippy.toml
@@ -6,5 +6,6 @@ enforced-import-renames = [
     { path = "std::clone", rename = "foo" },
     { path = "std::thread::sleep", rename = "thread_sleep" },
     { path = "std::any::type_name", rename = "ident" },
-    { path = "std::sync::Mutex", rename = "StdMutie" }
+    { path = "std::sync::Mutex", rename = "StdMutie" },
+    { path = "std::io::Write", rename = "to_test_rename_as_underscore" }
 ]
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
index 3e882f496985..c96df2884b8d 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
@@ -15,6 +15,7 @@ use std::{
     sync :: Mutex as StdMutie,
     //~^ missing_enforced_import_renames
 };
+use std::io::Write as _;
 
 fn main() {
     use std::collections::BTreeMap as Map;
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
index 32255af5117f..662e89157675 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
@@ -15,6 +15,7 @@ use std::{
     sync :: Mutex,
     //~^ missing_enforced_import_renames
 };
+use std::io::Write as _;
 
 fn main() {
     use std::collections::BTreeMap as OopsWrongRename;
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
index 982b144eb872..139331d17619 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
@@ -32,7 +32,7 @@ LL |     sync :: Mutex,
    |     ^^^^^^^^^^^^^ help: try: `sync :: Mutex as StdMutie`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:20:5
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:21:5
    |
 LL |     use std::collections::BTreeMap as OopsWrongRename;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `use std::collections::BTreeMap as Map`
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.fixed b/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
index ec76abbef05a..cd390ce0db9d 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
@@ -216,3 +216,16 @@ fn main() {
     assert!(!(b + b));
     //~^ bool_assert_comparison
 }
+
+fn issue16279() {
+    macro_rules! is_empty {
+        ($x:expr) => {
+            $x.is_empty()
+        };
+    }
+
+    assert!(!is_empty!("a"));
+    //~^ bool_assert_comparison
+    assert!(is_empty!(""));
+    //~^ bool_assert_comparison
+}
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.rs b/src/tools/clippy/tests/ui/bool_assert_comparison.rs
index 40824a23c82e..b2ea5b6ea540 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.rs
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.rs
@@ -216,3 +216,16 @@ fn main() {
     assert_eq!(b + b, false);
     //~^ bool_assert_comparison
 }
+
+fn issue16279() {
+    macro_rules! is_empty {
+        ($x:expr) => {
+            $x.is_empty()
+        };
+    }
+
+    assert_eq!(is_empty!("a"), false);
+    //~^ bool_assert_comparison
+    assert_eq!(is_empty!(""), true);
+    //~^ bool_assert_comparison
+}
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
index 72aa6303a202..b4e8fcf09bb6 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
@@ -444,5 +444,29 @@ LL -     assert_eq!(b + b, false);
 LL +     assert!(!(b + b));
    |
 
-error: aborting due to 37 previous errors
+error: used `assert_eq!` with a literal bool
+  --> tests/ui/bool_assert_comparison.rs:227:5
+   |
+LL |     assert_eq!(is_empty!("a"), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(is_empty!("a"), false);
+LL +     assert!(!is_empty!("a"));
+   |
+
+error: used `assert_eq!` with a literal bool
+  --> tests/ui/bool_assert_comparison.rs:229:5
+   |
+LL |     assert_eq!(is_empty!(""), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(is_empty!(""), true);
+LL +     assert!(is_empty!(""));
+   |
+
+error: aborting due to 39 previous errors
 
diff --git a/src/tools/clippy/tests/ui/checked_conversions.fixed b/src/tools/clippy/tests/ui/checked_conversions.fixed
index 6175275ef047..2309a053146f 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.fixed
+++ b/src/tools/clippy/tests/ui/checked_conversions.fixed
@@ -1,6 +1,7 @@
 #![allow(
     clippy::cast_lossless,
     clippy::legacy_numeric_constants,
+    clippy::no_effect,
     unused,
     // Int::max_value will be deprecated in the future
     deprecated,
@@ -105,4 +106,19 @@ fn msrv_1_34() {
     //~^ checked_conversions
 }
 
+fn issue16293() {
+    struct Outer {
+        inner: u32,
+    }
+    let outer = Outer { inner: 42 };
+    macro_rules! dot_inner {
+        ($obj:expr) => {
+            $obj.inner
+        };
+    }
+
+    i32::try_from(dot_inner!(outer)).is_ok();
+    //~^ checked_conversions
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/checked_conversions.rs b/src/tools/clippy/tests/ui/checked_conversions.rs
index 9ed0e8f660d0..dabb552eba27 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.rs
+++ b/src/tools/clippy/tests/ui/checked_conversions.rs
@@ -1,6 +1,7 @@
 #![allow(
     clippy::cast_lossless,
     clippy::legacy_numeric_constants,
+    clippy::no_effect,
     unused,
     // Int::max_value will be deprecated in the future
     deprecated,
@@ -105,4 +106,19 @@ fn msrv_1_34() {
     //~^ checked_conversions
 }
 
+fn issue16293() {
+    struct Outer {
+        inner: u32,
+    }
+    let outer = Outer { inner: 42 };
+    macro_rules! dot_inner {
+        ($obj:expr) => {
+            $obj.inner
+        };
+    }
+
+    dot_inner!(outer) <= i32::MAX as u32;
+    //~^ checked_conversions
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/checked_conversions.stderr b/src/tools/clippy/tests/ui/checked_conversions.stderr
index 624876dacb26..6018dacace39 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.stderr
+++ b/src/tools/clippy/tests/ui/checked_conversions.stderr
@@ -1,5 +1,5 @@
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:15:13
+  --> tests/ui/checked_conversions.rs:16:13
    |
 LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
@@ -8,100 +8,106 @@ LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    = help: to override `-D warnings` add `#[allow(clippy::checked_conversions)]`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:17:13
+  --> tests/ui/checked_conversions.rs:18:13
    |
 LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:22:13
+  --> tests/ui/checked_conversions.rs:23:13
    |
 LL |     let _ = value <= i64::from(u16::max_value()) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:24:13
+  --> tests/ui/checked_conversions.rs:25:13
    |
 LL |     let _ = value <= i64::from(u16::MAX) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:29:13
+  --> tests/ui/checked_conversions.rs:30:13
    |
 LL |     let _ = value <= (u8::max_value() as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:31:13
+  --> tests/ui/checked_conversions.rs:32:13
    |
 LL |     let _ = value <= (u8::MAX as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:38:13
+  --> tests/ui/checked_conversions.rs:39:13
    |
 LL |     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:40:13
+  --> tests/ui/checked_conversions.rs:41:13
    |
 LL |     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:45:13
+  --> tests/ui/checked_conversions.rs:46:13
    |
 LL |     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:47:13
+  --> tests/ui/checked_conversions.rs:48:13
    |
 LL |     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:54:13
+  --> tests/ui/checked_conversions.rs:55:13
    |
 LL |     let _ = value <= i32::max_value() as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:56:13
+  --> tests/ui/checked_conversions.rs:57:13
    |
 LL |     let _ = value <= i32::MAX as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:61:13
+  --> tests/ui/checked_conversions.rs:62:13
    |
 LL |     let _ = value <= isize::max_value() as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:63:13
+  --> tests/ui/checked_conversions.rs:64:13
    |
 LL |     let _ = value <= isize::MAX as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:68:13
+  --> tests/ui/checked_conversions.rs:69:13
    |
 LL |     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:70:13
+  --> tests/ui/checked_conversions.rs:71:13
    |
 LL |     let _ = value <= u16::MAX as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:104:13
+  --> tests/ui/checked_conversions.rs:105:13
    |
 LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
-error: aborting due to 17 previous errors
+error: checked cast can be simplified
+  --> tests/ui/checked_conversions.rs:120:5
+   |
+LL |     dot_inner!(outer) <= i32::MAX as u32;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(dot_inner!(outer)).is_ok()`
+
+error: aborting due to 18 previous errors
 
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
index 85d0991bef05..4c3b13b30043 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
@@ -83,3 +83,32 @@ fn issue_8103() {
     let _ = foo1 == foo2;
     //~^ cmp_owned
 }
+
+macro_rules! issue16322_macro_generator {
+    ($locale:ident) => {
+        mod $locale {
+            macro_rules! _make {
+                ($token:tt) => {
+                    stringify!($token)
+                };
+            }
+
+            pub(crate) use _make;
+        }
+
+        macro_rules! t {
+            ($token:tt) => {
+                crate::$locale::_make!($token)
+            };
+        }
+    };
+}
+
+issue16322_macro_generator!(de);
+
+fn issue16322(item: String) {
+    if item == t!(frohes_neu_Jahr) {
+        //~^ cmp_owned
+        println!("Ja!");
+    }
+}
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
index 2393757d76f2..a9d7509feaaf 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
@@ -83,3 +83,32 @@ fn issue_8103() {
     let _ = foo1 == foo2.to_owned();
     //~^ cmp_owned
 }
+
+macro_rules! issue16322_macro_generator {
+    ($locale:ident) => {
+        mod $locale {
+            macro_rules! _make {
+                ($token:tt) => {
+                    stringify!($token)
+                };
+            }
+
+            pub(crate) use _make;
+        }
+
+        macro_rules! t {
+            ($token:tt) => {
+                crate::$locale::_make!($token)
+            };
+        }
+    };
+}
+
+issue16322_macro_generator!(de);
+
+fn issue16322(item: String) {
+    if item == t!(frohes_neu_Jahr).to_string() {
+        //~^ cmp_owned
+        println!("Ja!");
+    }
+}
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
index dd9ffa70897a..66544ce0c217 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
@@ -49,5 +49,11 @@ error: this creates an owned instance just for comparison
 LL |     let _ = foo1 == foo2.to_owned();
    |                     ^^^^^^^^^^^^^^^ help: try: `foo2`
 
-error: aborting due to 8 previous errors
+error: this creates an owned instance just for comparison
+  --> tests/ui/cmp_owned/with_suggestion.rs:110:16
+   |
+LL |     if item == t!(frohes_neu_Jahr).to_string() {
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t!(frohes_neu_Jahr)`
+
+error: aborting due to 9 previous errors
 
diff --git a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
index b4bb24b0d2fe..386ab39401c5 100644
--- a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
@@ -91,3 +91,17 @@ mod issue15708 {
         }
     }
 }
+
+mod issue16298 {
+    #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+    struct Normalized<S>(S);
+
+    impl<S: Eq> Eq for Normalized<S> {}
+
+    #[expect(clippy::derive_ord_xor_partial_ord)]
+    impl<S: Eq + PartialOrd> Ord for Normalized<S> {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            self.partial_cmp(other).unwrap()
+        }
+    }
+}
diff --git a/src/tools/clippy/tests/ui/double_parens.fixed b/src/tools/clippy/tests/ui/double_parens.fixed
index 024af6840132..ef7838491f8f 100644
--- a/src/tools/clippy/tests/ui/double_parens.fixed
+++ b/src/tools/clippy/tests/ui/double_parens.fixed
@@ -161,4 +161,20 @@ fn issue15940() {
     pub struct Person;
 }
 
+fn issue16224() {
+    fn test() -> i32 { 42 }
+
+    macro_rules! call {
+        ($matcher:pat $(=> $result:expr)?) => {
+            match test() {
+                $matcher => Result::Ok(($($result),*)),
+                _ => Result::Err("No match".to_string()),
+            }
+        };
+    }
+
+    let _: Result<(), String> = call!(_);
+    let _: Result<i32, String> = call!(_ => 42);
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/double_parens.rs b/src/tools/clippy/tests/ui/double_parens.rs
index 8a76f2837f35..07eafdf69575 100644
--- a/src/tools/clippy/tests/ui/double_parens.rs
+++ b/src/tools/clippy/tests/ui/double_parens.rs
@@ -161,4 +161,20 @@ fn issue15940() {
     pub struct Person;
 }
 
+fn issue16224() {
+    fn test() -> i32 { 42 }
+
+    macro_rules! call {
+        ($matcher:pat $(=> $result:expr)?) => {
+            match test() {
+                $matcher => Result::Ok(($($result),*)),
+                _ => Result::Err("No match".to_string()),
+            }
+        };
+    }
+
+    let _: Result<(), String> = call!(_);
+    let _: Result<i32, String> = call!(_ => 42);
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/for_kv_map.fixed b/src/tools/clippy/tests/ui/for_kv_map.fixed
index 2a68b7443fbf..6ec4cb01ffd1 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.fixed
+++ b/src/tools/clippy/tests/ui/for_kv_map.fixed
@@ -69,3 +69,20 @@ fn main() {
         let _v = v;
     }
 }
+
+fn wrongly_unmangled_macros() {
+    use std::collections::HashMap;
+
+    macro_rules! test_map {
+        ($val:expr) => {
+            &*$val
+        };
+    }
+
+    let m: HashMap<u64, u64> = HashMap::new();
+    let wrapped = Rc::new(m);
+    for v in test_map!(wrapped).values() {
+        //~^ for_kv_map
+        let _v = v;
+    }
+}
diff --git a/src/tools/clippy/tests/ui/for_kv_map.rs b/src/tools/clippy/tests/ui/for_kv_map.rs
index 485a97815e3c..19e907ff10a6 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.rs
+++ b/src/tools/clippy/tests/ui/for_kv_map.rs
@@ -69,3 +69,20 @@ fn main() {
         let _v = v;
     }
 }
+
+fn wrongly_unmangled_macros() {
+    use std::collections::HashMap;
+
+    macro_rules! test_map {
+        ($val:expr) => {
+            &*$val
+        };
+    }
+
+    let m: HashMap<u64, u64> = HashMap::new();
+    let wrapped = Rc::new(m);
+    for (_, v) in test_map!(wrapped) {
+        //~^ for_kv_map
+        let _v = v;
+    }
+}
diff --git a/src/tools/clippy/tests/ui/for_kv_map.stderr b/src/tools/clippy/tests/ui/for_kv_map.stderr
index 0bd474a10682..5436592f2ab6 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.stderr
+++ b/src/tools/clippy/tests/ui/for_kv_map.stderr
@@ -72,5 +72,17 @@ LL -     'label: for (k, _value) in rm {
 LL +     'label: for k in rm.keys() {
    |
 
-error: aborting due to 6 previous errors
+error: you seem to want to iterate on a map's values
+  --> tests/ui/for_kv_map.rs:84:19
+   |
+LL |     for (_, v) in test_map!(wrapped) {
+   |                   ^^^^^^^^^^^^^^^^^^
+   |
+help: use the corresponding method
+   |
+LL -     for (_, v) in test_map!(wrapped) {
+LL +     for v in test_map!(wrapped).values() {
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/src/tools/clippy/tests/ui/impl.rs b/src/tools/clippy/tests/ui/impl.rs
index e6044cc50781..75761a34c86e 100644
--- a/src/tools/clippy/tests/ui/impl.rs
+++ b/src/tools/clippy/tests/ui/impl.rs
@@ -14,6 +14,7 @@ impl MyStruct {
 }
 
 impl<'a> MyStruct {
+    //~^ multiple_inherent_impl
     fn lifetimed() {}
 }
 
@@ -90,10 +91,12 @@ struct Lifetime<'s> {
 }
 
 impl Lifetime<'_> {}
-impl Lifetime<'_> {} // false negative
+impl Lifetime<'_> {}
+//~^ multiple_inherent_impl
 
 impl<'a> Lifetime<'a> {}
-impl<'a> Lifetime<'a> {} // false negative
+impl<'a> Lifetime<'a> {}
+//~^ multiple_inherent_impl
 
 impl<'b> Lifetime<'b> {} // false negative?
 
@@ -104,6 +107,39 @@ struct Generic<G> {
 }
 
 impl<G> Generic<G> {}
-impl<G> Generic<G> {} // false negative
+impl<G> Generic<G> {}
+//~^ multiple_inherent_impl
+
+use std::fmt::Debug;
+
+#[derive(Debug)]
+struct GenericWithBounds<T: Debug>(T);
+
+impl<T: Debug> GenericWithBounds<T> {
+    fn make_one(_one: T) -> Self {
+        todo!()
+    }
+}
+
+impl<T: Debug> GenericWithBounds<T> {
+    //~^ multiple_inherent_impl
+    fn make_two(_two: T) -> Self {
+        todo!()
+    }
+}
+
+struct MultipleTraitBounds<T>(T);
+
+impl<T: Debug> MultipleTraitBounds<T> {
+    fn debug_fn() {}
+}
+
+impl<T: Clone> MultipleTraitBounds<T> {
+    fn clone_fn() {}
+}
+
+impl<T: Debug + Clone> MultipleTraitBounds<T> {
+    fn debug_clone_fn() {}
+}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/impl.stderr b/src/tools/clippy/tests/ui/impl.stderr
index 93d4b3998f90..9c4aaf183d70 100644
--- a/src/tools/clippy/tests/ui/impl.stderr
+++ b/src/tools/clippy/tests/ui/impl.stderr
@@ -19,7 +19,24 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::multiple_inherent_impl)]`
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:26:5
+  --> tests/ui/impl.rs:16:1
+   |
+LL | / impl<'a> MyStruct {
+LL | |
+LL | |     fn lifetimed() {}
+LL | | }
+   | |_^
+   |
+note: first implementation here
+  --> tests/ui/impl.rs:6:1
+   |
+LL | / impl MyStruct {
+LL | |     fn first() {}
+LL | | }
+   | |_^
+
+error: multiple implementations of this structure
+  --> tests/ui/impl.rs:27:5
    |
 LL | /     impl super::MyStruct {
 LL | |
@@ -37,7 +54,7 @@ LL | | }
    | |_^
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:48:1
+  --> tests/ui/impl.rs:49:1
    |
 LL | / impl WithArgs<u64> {
 LL | |
@@ -47,7 +64,7 @@ LL | | }
    | |_^
    |
 note: first implementation here
-  --> tests/ui/impl.rs:45:1
+  --> tests/ui/impl.rs:46:1
    |
 LL | / impl WithArgs<u64> {
 LL | |     fn f2() {}
@@ -55,28 +72,85 @@ LL | | }
    | |_^
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:71:1
+  --> tests/ui/impl.rs:72:1
    |
 LL | impl OneAllowedImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first implementation here
-  --> tests/ui/impl.rs:68:1
+  --> tests/ui/impl.rs:69:1
    |
 LL | impl OneAllowedImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:84:1
+  --> tests/ui/impl.rs:85:1
    |
 LL | impl OneExpected {}
    | ^^^^^^^^^^^^^^^^^^^
    |
 note: first implementation here
-  --> tests/ui/impl.rs:81:1
+  --> tests/ui/impl.rs:82:1
    |
 LL | impl OneExpected {}
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: multiple implementations of this structure
+  --> tests/ui/impl.rs:94:1
+   |
+LL | impl Lifetime<'_> {}
+   | ^^^^^^^^^^^^^^^^^^^^
+   |
+note: first implementation here
+  --> tests/ui/impl.rs:93:1
+   |
+LL | impl Lifetime<'_> {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: multiple implementations of this structure
+  --> tests/ui/impl.rs:98:1
+   |
+LL | impl<'a> Lifetime<'a> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first implementation here
+  --> tests/ui/impl.rs:97:1
+   |
+LL | impl<'a> Lifetime<'a> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: multiple implementations of this structure
+  --> tests/ui/impl.rs:110:1
+   |
+LL | impl<G> Generic<G> {}
+   | ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first implementation here
+  --> tests/ui/impl.rs:109:1
+   |
+LL | impl<G> Generic<G> {}
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error: multiple implementations of this structure
+  --> tests/ui/impl.rs:124:1
+   |
+LL | / impl<T: Debug> GenericWithBounds<T> {
+LL | |
+LL | |     fn make_two(_two: T) -> Self {
+LL | |         todo!()
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: first implementation here
+  --> tests/ui/impl.rs:118:1
+   |
+LL | / impl<T: Debug> GenericWithBounds<T> {
+LL | |     fn make_one(_one: T) -> Self {
+LL | |         todo!()
+LL | |     }
+LL | | }
+   | |_^
+
+error: aborting due to 10 previous errors
 
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_sub.fixed b/src/tools/clippy/tests/ui/implicit_saturating_sub.fixed
index 1aab6c54407e..22e59bbd2705 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_sub.fixed
+++ b/src/tools/clippy/tests/ui/implicit_saturating_sub.fixed
@@ -252,3 +252,11 @@ fn arbitrary_expression() {
         0
     };
 }
+
+fn issue16307() {
+    let x: u8 = 100;
+    let y = 100_u8.saturating_sub(x);
+    //~^ implicit_saturating_sub
+
+    println!("{y}");
+}
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_sub.rs b/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
index 7ca57a2902db..7fa19f0c8ad2 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
+++ b/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
@@ -326,3 +326,11 @@ fn arbitrary_expression() {
         0
     };
 }
+
+fn issue16307() {
+    let x: u8 = 100;
+    let y = if x >= 100 { 0 } else { 100 - x };
+    //~^ implicit_saturating_sub
+
+    println!("{y}");
+}
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr b/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
index 0c225856fd07..2f3d2ba787e8 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
+++ b/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
@@ -238,5 +238,11 @@ error: manual arithmetic check found
 LL |     let _ = if a < b * 2 { 0 } else { a - b * 2 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a.saturating_sub(b * 2)`
 
-error: aborting due to 27 previous errors
+error: manual arithmetic check found
+  --> tests/ui/implicit_saturating_sub.rs:332:13
+   |
+LL |     let y = if x >= 100 { 0 } else { 100 - x };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `100_u8.saturating_sub(x)`
+
+error: aborting due to 28 previous errors
 
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.fixed b/src/tools/clippy/tests/ui/iter_kv_map.fixed
index b18dda358877..189d76bc9431 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.fixed
+++ b/src/tools/clippy/tests/ui/iter_kv_map.fixed
@@ -189,3 +189,9 @@ fn issue14595() {
     let _ = map.as_ref().values().copied().collect::<Vec<_>>();
     //~^ iter_kv_map
 }
+
+fn issue16340() {
+    let hm: HashMap<&str, &str> = HashMap::new();
+    let _ = hm.keys().map(|key| vec![key]);
+    //~^ iter_kv_map
+}
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.rs b/src/tools/clippy/tests/ui/iter_kv_map.rs
index 729e4e8a266c..cfc303447004 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.rs
+++ b/src/tools/clippy/tests/ui/iter_kv_map.rs
@@ -193,3 +193,9 @@ fn issue14595() {
     let _ = map.as_ref().iter().map(|(_, v)| v).copied().collect::<Vec<_>>();
     //~^ iter_kv_map
 }
+
+fn issue16340() {
+    let hm: HashMap<&str, &str> = HashMap::new();
+    let _ = hm.iter().map(|(key, _)| vec![key]);
+    //~^ iter_kv_map
+}
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.stderr b/src/tools/clippy/tests/ui/iter_kv_map.stderr
index 8f73541f5033..866e69ea1922 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.stderr
+++ b/src/tools/clippy/tests/ui/iter_kv_map.stderr
@@ -269,5 +269,11 @@ error: iterating on a map's values
 LL |     let _ = map.as_ref().iter().map(|(_, v)| v).copied().collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.as_ref().values()`
 
-error: aborting due to 39 previous errors
+error: iterating on a map's keys
+  --> tests/ui/iter_kv_map.rs:199:13
+   |
+LL |     let _ = hm.iter().map(|(key, _)| vec![key]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hm.keys().map(|key| vec![key])`
+
+error: aborting due to 40 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_clamp.fixed b/src/tools/clippy/tests/ui/manual_clamp.fixed
index 2450a4f4c611..b279a413bc17 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.fixed
+++ b/src/tools/clippy/tests/ui/manual_clamp.fixed
@@ -4,7 +4,8 @@
     dead_code,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::if_same_then_else
+    clippy::if_same_then_else,
+    clippy::needless_match
 )]
 
 use std::cmp::{max as cmp_max, min as cmp_min};
diff --git a/src/tools/clippy/tests/ui/manual_clamp.rs b/src/tools/clippy/tests/ui/manual_clamp.rs
index ee341d50768f..7fda41cd4c35 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.rs
+++ b/src/tools/clippy/tests/ui/manual_clamp.rs
@@ -4,7 +4,8 @@
     dead_code,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::if_same_then_else
+    clippy::if_same_then_else,
+    clippy::needless_match
 )]
 
 use std::cmp::{max as cmp_max, min as cmp_min};
diff --git a/src/tools/clippy/tests/ui/manual_clamp.stderr b/src/tools/clippy/tests/ui/manual_clamp.stderr
index 4a0e4fa51646..775a16418eba 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.stderr
+++ b/src/tools/clippy/tests/ui/manual_clamp.stderr
@@ -1,5 +1,5 @@
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:212:5
+  --> tests/ui/manual_clamp.rs:213:5
    |
 LL | /     if x9 < CONST_MIN {
 LL | |
@@ -15,7 +15,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::manual_clamp)]`
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:230:5
+  --> tests/ui/manual_clamp.rs:231:5
    |
 LL | /     if x11 > CONST_MAX {
 LL | |
@@ -29,7 +29,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:240:5
+  --> tests/ui/manual_clamp.rs:241:5
    |
 LL | /     if CONST_MIN > x12 {
 LL | |
@@ -43,7 +43,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:250:5
+  --> tests/ui/manual_clamp.rs:251:5
    |
 LL | /     if CONST_MAX < x13 {
 LL | |
@@ -57,7 +57,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:363:5
+  --> tests/ui/manual_clamp.rs:364:5
    |
 LL | /     if CONST_MAX < x35 {
 LL | |
@@ -71,7 +71,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:144:14
+  --> tests/ui/manual_clamp.rs:145:14
    |
 LL |       let x0 = if CONST_MAX < input {
    |  ______________^
@@ -86,7 +86,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:154:14
+  --> tests/ui/manual_clamp.rs:155:14
    |
 LL |       let x1 = if input > CONST_MAX {
    |  ______________^
@@ -101,7 +101,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:164:14
+  --> tests/ui/manual_clamp.rs:165:14
    |
 LL |       let x2 = if input < CONST_MIN {
    |  ______________^
@@ -116,7 +116,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:174:14
+  --> tests/ui/manual_clamp.rs:175:14
    |
 LL |       let x3 = if CONST_MIN > input {
    |  ______________^
@@ -131,7 +131,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:184:14
+  --> tests/ui/manual_clamp.rs:185:14
    |
 LL |     let x4 = input.max(CONST_MIN).min(CONST_MAX);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -139,7 +139,7 @@ LL |     let x4 = input.max(CONST_MIN).min(CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:187:14
+  --> tests/ui/manual_clamp.rs:188:14
    |
 LL |     let x5 = input.min(CONST_MAX).max(CONST_MIN);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -147,7 +147,7 @@ LL |     let x5 = input.min(CONST_MAX).max(CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:190:14
+  --> tests/ui/manual_clamp.rs:191:14
    |
 LL |       let x6 = match input {
    |  ______________^
@@ -161,7 +161,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:197:14
+  --> tests/ui/manual_clamp.rs:198:14
    |
 LL |       let x7 = match input {
    |  ______________^
@@ -175,7 +175,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:204:14
+  --> tests/ui/manual_clamp.rs:205:14
    |
 LL |       let x8 = match input {
    |  ______________^
@@ -189,7 +189,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:221:15
+  --> tests/ui/manual_clamp.rs:222:15
    |
 LL |       let x10 = match input {
    |  _______________^
@@ -203,7 +203,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:259:15
+  --> tests/ui/manual_clamp.rs:260:15
    |
 LL |       let x14 = if input > CONST_MAX {
    |  _______________^
@@ -218,7 +218,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:270:19
+  --> tests/ui/manual_clamp.rs:271:19
    |
 LL |           let x15 = if input > CONST_F64_MAX {
    |  ___________________^
@@ -234,7 +234,7 @@ LL | |         };
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:283:19
+  --> tests/ui/manual_clamp.rs:284:19
    |
 LL |         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -242,7 +242,7 @@ LL |         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:286:19
+  --> tests/ui/manual_clamp.rs:287:19
    |
 LL |         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -250,7 +250,7 @@ LL |         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:289:19
+  --> tests/ui/manual_clamp.rs:290:19
    |
 LL |         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -258,7 +258,7 @@ LL |         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:292:19
+  --> tests/ui/manual_clamp.rs:293:19
    |
 LL |         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -266,7 +266,7 @@ LL |         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:295:19
+  --> tests/ui/manual_clamp.rs:296:19
    |
 LL |         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -274,7 +274,7 @@ LL |         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:298:19
+  --> tests/ui/manual_clamp.rs:299:19
    |
 LL |         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -282,7 +282,7 @@ LL |         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:301:19
+  --> tests/ui/manual_clamp.rs:302:19
    |
 LL |         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -290,7 +290,7 @@ LL |         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:304:19
+  --> tests/ui/manual_clamp.rs:305:19
    |
 LL |         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -298,7 +298,7 @@ LL |         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:308:19
+  --> tests/ui/manual_clamp.rs:309:19
    |
 LL |         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -307,7 +307,7 @@ LL |         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:311:19
+  --> tests/ui/manual_clamp.rs:312:19
    |
 LL |         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -316,7 +316,7 @@ LL |         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:314:19
+  --> tests/ui/manual_clamp.rs:315:19
    |
 LL |         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -325,7 +325,7 @@ LL |         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:317:19
+  --> tests/ui/manual_clamp.rs:318:19
    |
 LL |         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -334,7 +334,7 @@ LL |         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:320:19
+  --> tests/ui/manual_clamp.rs:321:19
    |
 LL |         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -343,7 +343,7 @@ LL |         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:323:19
+  --> tests/ui/manual_clamp.rs:324:19
    |
 LL |         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -352,7 +352,7 @@ LL |         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:326:19
+  --> tests/ui/manual_clamp.rs:327:19
    |
 LL |         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -361,7 +361,7 @@ LL |         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:329:19
+  --> tests/ui/manual_clamp.rs:330:19
    |
 LL |         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -370,7 +370,7 @@ LL |         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:333:5
+  --> tests/ui/manual_clamp.rs:334:5
    |
 LL | /     if x32 < CONST_MIN {
 LL | |
@@ -384,7 +384,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:525:13
+  --> tests/ui/manual_clamp.rs:526:13
    |
 LL |       let _ = if input > CONST_MAX {
    |  _____________^
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.fixed b/src/tools/clippy/tests/ui/manual_div_ceil.fixed
index cd91be87ec17..8ffd107dd42e 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.fixed
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.fixed
@@ -105,3 +105,32 @@ fn issue_15705(size: u64, c: &u64) {
     let _ = size.div_ceil(*c);
     //~^ manual_div_ceil
 }
+
+struct MyStruct(u32);
+impl MyStruct {
+    // Method matching name on different type should not trigger lint
+    fn next_multiple_of(self, y: u32) -> u32 {
+        self.0.next_multiple_of(y)
+    }
+}
+
+fn issue_16219() {
+    let x = 33u32;
+
+    // Lint.
+    let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
+    let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
+
+    let y = &x;
+    let _ = y.div_ceil(8);
+    //~^ manual_div_ceil
+
+    // No lint.
+    let _ = x.next_multiple_of(8) / 7;
+    let _ = x.next_multiple_of(7) / 8;
+
+    let z = MyStruct(x);
+    let _ = z.next_multiple_of(8) / 8;
+}
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.rs b/src/tools/clippy/tests/ui/manual_div_ceil.rs
index 9899c7d775c2..859fb5a13c44 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.rs
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.rs
@@ -105,3 +105,32 @@ fn issue_15705(size: u64, c: &u64) {
     let _ = (size + c - 1) / c;
     //~^ manual_div_ceil
 }
+
+struct MyStruct(u32);
+impl MyStruct {
+    // Method matching name on different type should not trigger lint
+    fn next_multiple_of(self, y: u32) -> u32 {
+        self.0.next_multiple_of(y)
+    }
+}
+
+fn issue_16219() {
+    let x = 33u32;
+
+    // Lint.
+    let _ = x.next_multiple_of(8) / 8;
+    //~^ manual_div_ceil
+    let _ = u32::next_multiple_of(x, 8) / 8;
+    //~^ manual_div_ceil
+
+    let y = &x;
+    let _ = y.next_multiple_of(8) / 8;
+    //~^ manual_div_ceil
+
+    // No lint.
+    let _ = x.next_multiple_of(8) / 7;
+    let _ = x.next_multiple_of(7) / 8;
+
+    let z = MyStruct(x);
+    let _ = z.next_multiple_of(8) / 8;
+}
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.stderr b/src/tools/clippy/tests/ui/manual_div_ceil.stderr
index 44de3ba99be7..0efc114c7078 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.stderr
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.stderr
@@ -131,5 +131,23 @@ error: manually reimplementing `div_ceil`
 LL |     let _ = (size + c - 1) / c;
    |             ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `size.div_ceil(*c)`
 
-error: aborting due to 20 previous errors
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil.rs:121:13
+   |
+LL |     let _ = x.next_multiple_of(8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
+
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil.rs:123:13
+   |
+LL |     let _ = u32::next_multiple_of(x, 8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
+
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil.rs:127:13
+   |
+LL |     let _ = y.next_multiple_of(8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(8)`
+
+error: aborting due to 23 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
index f55999c5ad08..d77b8bc28986 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
@@ -84,3 +84,32 @@ fn issue_13950() {
     let _ = y.div_ceil(-7);
     //~^ manual_div_ceil
 }
+
+struct MyStruct(i32);
+impl MyStruct {
+    // Method matching name on different type should not trigger lint
+    fn next_multiple_of(self, y: i32) -> i32 {
+        self.0.next_multiple_of(y)
+    }
+}
+
+fn issue_16219() {
+    let x = 33i32;
+
+    // Lint.
+    let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
+    let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
+
+    let y = &x;
+    let _ = y.div_ceil(8);
+    //~^ manual_div_ceil
+
+    // No lint.
+    let _ = x.next_multiple_of(8) / 7;
+    let _ = x.next_multiple_of(7) / 8;
+
+    let z = MyStruct(x);
+    let _ = z.next_multiple_of(8) / 8;
+}
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
index 8a895f634cb4..5b9a4d9156a7 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
@@ -84,3 +84,32 @@ fn issue_13950() {
     let _ = (y - 8) / -7;
     //~^ manual_div_ceil
 }
+
+struct MyStruct(i32);
+impl MyStruct {
+    // Method matching name on different type should not trigger lint
+    fn next_multiple_of(self, y: i32) -> i32 {
+        self.0.next_multiple_of(y)
+    }
+}
+
+fn issue_16219() {
+    let x = 33i32;
+
+    // Lint.
+    let _ = x.next_multiple_of(8) / 8;
+    //~^ manual_div_ceil
+    let _ = i32::next_multiple_of(x, 8) / 8;
+    //~^ manual_div_ceil
+
+    let y = &x;
+    let _ = y.next_multiple_of(8) / 8;
+    //~^ manual_div_ceil
+
+    // No lint.
+    let _ = x.next_multiple_of(8) / 7;
+    let _ = x.next_multiple_of(7) / 8;
+
+    let z = MyStruct(x);
+    let _ = z.next_multiple_of(8) / 8;
+}
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
index e1160d962996..c5fa15112a87 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
@@ -139,5 +139,23 @@ error: manually reimplementing `div_ceil`
 LL |     let _ = (y - 8) / -7;
    |             ^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(-7)`
 
-error: aborting due to 23 previous errors
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil_with_feature.rs:100:13
+   |
+LL |     let _ = x.next_multiple_of(8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
+
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil_with_feature.rs:102:13
+   |
+LL |     let _ = i32::next_multiple_of(x, 8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
+
+error: manually reimplementing `div_ceil`
+  --> tests/ui/manual_div_ceil_with_feature.rs:106:13
+   |
+LL |     let _ = y.next_multiple_of(8) / 8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(8)`
+
+error: aborting due to 26 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
index cd7adc20b127..f0e413aaec0d 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
@@ -160,3 +160,23 @@ fn ref_osstring(a: OsString, b: &OsString) {
     b.eq_ignore_ascii_case(a);
     //~^ manual_ignore_case_cmp
 }
+
+fn wrongly_unmangled_macros(a: &str, b: &str) -> bool {
+    struct S<'a> {
+        inner: &'a str,
+    }
+
+    let a = S { inner: a };
+    let b = S { inner: b };
+
+    macro_rules! dot_inner {
+        ($s:expr) => {
+            $s.inner
+        };
+    }
+
+    dot_inner!(a).eq_ignore_ascii_case(dot_inner!(b))
+    //~^ manual_ignore_case_cmp
+        || dot_inner!(a).eq_ignore_ascii_case("abc")
+    //~^ manual_ignore_case_cmp
+}
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
index 85f6719827c9..9802e87cd233 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
@@ -160,3 +160,23 @@ fn ref_osstring(a: OsString, b: &OsString) {
     b.to_ascii_lowercase() == a.to_ascii_lowercase();
     //~^ manual_ignore_case_cmp
 }
+
+fn wrongly_unmangled_macros(a: &str, b: &str) -> bool {
+    struct S<'a> {
+        inner: &'a str,
+    }
+
+    let a = S { inner: a };
+    let b = S { inner: b };
+
+    macro_rules! dot_inner {
+        ($s:expr) => {
+            $s.inner
+        };
+    }
+
+    dot_inner!(a).to_ascii_lowercase() == dot_inner!(b).to_ascii_lowercase()
+    //~^ manual_ignore_case_cmp
+        || dot_inner!(a).to_ascii_lowercase() == "abc"
+    //~^ manual_ignore_case_cmp
+}
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
index fa7fadd91076..2f698e076ed3 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
@@ -588,5 +588,29 @@ LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
 LL +     b.eq_ignore_ascii_case(a);
    |
 
-error: aborting due to 49 previous errors
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:178:5
+   |
+LL |     dot_inner!(a).to_ascii_lowercase() == dot_inner!(b).to_ascii_lowercase()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     dot_inner!(a).to_ascii_lowercase() == dot_inner!(b).to_ascii_lowercase()
+LL +     dot_inner!(a).eq_ignore_ascii_case(dot_inner!(b))
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:180:12
+   |
+LL |         || dot_inner!(a).to_ascii_lowercase() == "abc"
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -         || dot_inner!(a).to_ascii_lowercase() == "abc"
+LL +         || dot_inner!(a).eq_ignore_ascii_case("abc")
+   |
+
+error: aborting due to 51 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_ilog2.fixed b/src/tools/clippy/tests/ui/manual_ilog2.fixed
index a0f6d9392c30..ea86fc927c7c 100644
--- a/src/tools/clippy/tests/ui/manual_ilog2.fixed
+++ b/src/tools/clippy/tests/ui/manual_ilog2.fixed
@@ -30,3 +30,20 @@ fn foo(a: u32, b: u64) {
     external!($a.ilog(2));
     with_span!(span; a.ilog(2));
 }
+
+fn wrongly_unmangled_macros() {
+    struct S {
+        inner: u32,
+    }
+
+    let x = S { inner: 42 };
+    macro_rules! access {
+        ($s:expr) => {
+            $s.inner
+        };
+    }
+    let log = access!(x).ilog2();
+    //~^ manual_ilog2
+    let log = access!(x).ilog2();
+    //~^ manual_ilog2
+}
diff --git a/src/tools/clippy/tests/ui/manual_ilog2.rs b/src/tools/clippy/tests/ui/manual_ilog2.rs
index bd4b5d9d3c0d..8cb0e12d7361 100644
--- a/src/tools/clippy/tests/ui/manual_ilog2.rs
+++ b/src/tools/clippy/tests/ui/manual_ilog2.rs
@@ -30,3 +30,20 @@ fn foo(a: u32, b: u64) {
     external!($a.ilog(2));
     with_span!(span; a.ilog(2));
 }
+
+fn wrongly_unmangled_macros() {
+    struct S {
+        inner: u32,
+    }
+
+    let x = S { inner: 42 };
+    macro_rules! access {
+        ($s:expr) => {
+            $s.inner
+        };
+    }
+    let log = 31 - access!(x).leading_zeros();
+    //~^ manual_ilog2
+    let log = access!(x).ilog(2);
+    //~^ manual_ilog2
+}
diff --git a/src/tools/clippy/tests/ui/manual_ilog2.stderr b/src/tools/clippy/tests/ui/manual_ilog2.stderr
index 7c9694f35330..d0ef8378081a 100644
--- a/src/tools/clippy/tests/ui/manual_ilog2.stderr
+++ b/src/tools/clippy/tests/ui/manual_ilog2.stderr
@@ -19,5 +19,17 @@ error: manually reimplementing `ilog2`
 LL |     63 - b.leading_zeros();
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `b.ilog2()`
 
-error: aborting due to 3 previous errors
+error: manually reimplementing `ilog2`
+  --> tests/ui/manual_ilog2.rs:45:15
+   |
+LL |     let log = 31 - access!(x).leading_zeros();
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `access!(x).ilog2()`
+
+error: manually reimplementing `ilog2`
+  --> tests/ui/manual_ilog2.rs:47:15
+   |
+LL |     let log = access!(x).ilog(2);
+   |               ^^^^^^^^^^^^^^^^^^ help: try: `access!(x).ilog2()`
+
+error: aborting due to 5 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_is_multiple_of.fixed b/src/tools/clippy/tests/ui/manual_is_multiple_of.fixed
index 03f75e725ed5..82e0684e5e57 100644
--- a/src/tools/clippy/tests/ui/manual_is_multiple_of.fixed
+++ b/src/tools/clippy/tests/ui/manual_is_multiple_of.fixed
@@ -101,3 +101,19 @@ mod issue15103 {
         (1..1_000).filter(|&i| i == d(d(i)) && i != d(i)).sum()
     }
 }
+
+fn wrongly_unmangled_macros(a: u32, b: u32) {
+    struct Wrapper(u32);
+    let a = Wrapper(a);
+    let b = Wrapper(b);
+    macro_rules! dot_0 {
+        ($x:expr) => {
+            $x.0
+        };
+    }
+
+    if dot_0!(a).is_multiple_of(dot_0!(b)) {
+        //~^ manual_is_multiple_of
+        todo!()
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_is_multiple_of.rs b/src/tools/clippy/tests/ui/manual_is_multiple_of.rs
index 7b6fa64c843d..82a492e24092 100644
--- a/src/tools/clippy/tests/ui/manual_is_multiple_of.rs
+++ b/src/tools/clippy/tests/ui/manual_is_multiple_of.rs
@@ -101,3 +101,19 @@ mod issue15103 {
         (1..1_000).filter(|&i| i == d(d(i)) && i != d(i)).sum()
     }
 }
+
+fn wrongly_unmangled_macros(a: u32, b: u32) {
+    struct Wrapper(u32);
+    let a = Wrapper(a);
+    let b = Wrapper(b);
+    macro_rules! dot_0 {
+        ($x:expr) => {
+            $x.0
+        };
+    }
+
+    if dot_0!(a) % dot_0!(b) == 0 {
+        //~^ manual_is_multiple_of
+        todo!()
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_is_multiple_of.stderr b/src/tools/clippy/tests/ui/manual_is_multiple_of.stderr
index 8523599ec402..3aba869c9111 100644
--- a/src/tools/clippy/tests/ui/manual_is_multiple_of.stderr
+++ b/src/tools/clippy/tests/ui/manual_is_multiple_of.stderr
@@ -67,5 +67,11 @@ error: manual implementation of `.is_multiple_of()`
 LL |         let d = |n: u32| -> u32 { (1..=n / 2).filter(|i| n % i == 0).sum() };
    |                                                          ^^^^^^^^^^ help: replace with: `n.is_multiple_of(*i)`
 
-error: aborting due to 11 previous errors
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:115:8
+   |
+LL |     if dot_0!(a) % dot_0!(b) == 0 {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `dot_0!(a).is_multiple_of(dot_0!(b))`
+
+error: aborting due to 12 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.fixed b/src/tools/clippy/tests/ui/manual_ok_err.fixed
index 9b70ce0df43a..e22f91a0155f 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.fixed
+++ b/src/tools/clippy/tests/ui/manual_ok_err.fixed
@@ -127,3 +127,13 @@ mod issue15051 {
         result_with_ref_mut(x).as_mut().ok()
     }
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, ()>($val)
+        };
+    }
+
+    let _ = test_expr!(42).ok();
+}
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.rs b/src/tools/clippy/tests/ui/manual_ok_err.rs
index dee904638245..c1355f0d4096 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.rs
+++ b/src/tools/clippy/tests/ui/manual_ok_err.rs
@@ -177,3 +177,17 @@ mod issue15051 {
         }
     }
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, ()>($val)
+        };
+    }
+
+    let _ = match test_expr!(42) {
+        //~^ manual_ok_err
+        Ok(v) => Some(v),
+        Err(_) => None,
+    };
+}
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.stderr b/src/tools/clippy/tests/ui/manual_ok_err.stderr
index 448fbffc0509..0c2ed368eb97 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.stderr
+++ b/src/tools/clippy/tests/ui/manual_ok_err.stderr
@@ -141,5 +141,16 @@ LL | |             Err(_) => None,
 LL | |         }
    | |_________^ help: replace with: `result_with_ref_mut(x).as_mut().ok()`
 
-error: aborting due to 12 previous errors
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:188:13
+   |
+LL |       let _ = match test_expr!(42) {
+   |  _____________^
+LL | |
+LL | |         Ok(v) => Some(v),
+LL | |         Err(_) => None,
+LL | |     };
+   | |_____^ help: replace with: `test_expr!(42).ok()`
+
+error: aborting due to 13 previous errors
 
diff --git a/src/tools/clippy/tests/ui/match_as_ref.fixed b/src/tools/clippy/tests/ui/match_as_ref.fixed
index 09a6ed169390..b1b8ffb885f5 100644
--- a/src/tools/clippy/tests/ui/match_as_ref.fixed
+++ b/src/tools/clippy/tests/ui/match_as_ref.fixed
@@ -90,3 +90,13 @@ fn issue15932() {
 
     let _: Option<&dyn std::fmt::Debug> = Some(0).as_ref().map(|x| x as _);
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let _: Option<&u32> = test_expr!(42).as_ref();
+}
diff --git a/src/tools/clippy/tests/ui/match_as_ref.rs b/src/tools/clippy/tests/ui/match_as_ref.rs
index 347b6d186887..3113167957d4 100644
--- a/src/tools/clippy/tests/ui/match_as_ref.rs
+++ b/src/tools/clippy/tests/ui/match_as_ref.rs
@@ -114,3 +114,17 @@ fn issue15932() {
         Some(ref mut v) => Some(v),
     };
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let _: Option<&u32> = match test_expr!(42) {
+        //~^ match_as_ref
+        None => None,
+        Some(ref v) => Some(v),
+    };
+}
diff --git a/src/tools/clippy/tests/ui/match_as_ref.stderr b/src/tools/clippy/tests/ui/match_as_ref.stderr
index df06e358f296..3eab499fe409 100644
--- a/src/tools/clippy/tests/ui/match_as_ref.stderr
+++ b/src/tools/clippy/tests/ui/match_as_ref.stderr
@@ -127,5 +127,26 @@ LL -     };
 LL +     let _: Option<&dyn std::fmt::Debug> = Some(0).as_ref().map(|x| x as _);
    |
 
-error: aborting due to 6 previous errors
+error: manual implementation of `Option::as_ref`
+  --> tests/ui/match_as_ref.rs:125:27
+   |
+LL |       let _: Option<&u32> = match test_expr!(42) {
+   |  ___________________________^
+LL | |
+LL | |         None => None,
+LL | |         Some(ref v) => Some(v),
+LL | |     };
+   | |_____^
+   |
+help: use `Option::as_ref()` directly
+   |
+LL -     let _: Option<&u32> = match test_expr!(42) {
+LL -
+LL -         None => None,
+LL -         Some(ref v) => Some(v),
+LL -     };
+LL +     let _: Option<&u32> = test_expr!(42).as_ref();
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/src/tools/clippy/tests/ui/match_bool.fixed b/src/tools/clippy/tests/ui/match_bool.fixed
index 876ae935afde..3d5d0a0d532c 100644
--- a/src/tools/clippy/tests/ui/match_bool.fixed
+++ b/src/tools/clippy/tests/ui/match_bool.fixed
@@ -74,4 +74,15 @@ fn issue15351() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x = 5;
+    if test_expr!(x) { 1 } else { 0 };
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/match_bool.rs b/src/tools/clippy/tests/ui/match_bool.rs
index a134ad8346e2..4db0aedf3260 100644
--- a/src/tools/clippy/tests/ui/match_bool.rs
+++ b/src/tools/clippy/tests/ui/match_bool.rs
@@ -126,4 +126,19 @@ fn issue15351() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x = 5;
+    match test_expr!(x) {
+        //~^ match_bool
+        true => 1,
+        false => 0,
+    };
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/match_bool.stderr b/src/tools/clippy/tests/ui/match_bool.stderr
index c05742e56339..223acd17aead 100644
--- a/src/tools/clippy/tests/ui/match_bool.stderr
+++ b/src/tools/clippy/tests/ui/match_bool.stderr
@@ -183,5 +183,15 @@ LL +         break 'a;
 LL +     } }
    |
 
-error: aborting due to 13 previous errors
+error: `match` on a boolean expression
+  --> tests/ui/match_bool.rs:137:5
+   |
+LL | /     match test_expr!(x) {
+LL | |
+LL | |         true => 1,
+LL | |         false => 0,
+LL | |     };
+   | |_____^ help: consider using an `if`/`else` expression: `if test_expr!(x) { 1 } else { 0 }`
+
+error: aborting due to 14 previous errors
 
diff --git a/src/tools/clippy/tests/ui/mutex_atomic.fixed b/src/tools/clippy/tests/ui/mutex_atomic.fixed
index e4218726019f..dc05d8a2c61f 100644
--- a/src/tools/clippy/tests/ui/mutex_atomic.fixed
+++ b/src/tools/clippy/tests/ui/mutex_atomic.fixed
@@ -65,3 +65,15 @@ fn issue13378() {
     let (funky_mtx) = std::sync::atomic::AtomicU64::new(0);
     //~^ mutex_integer
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val > 0 && true)
+        };
+    }
+
+    let _ = std::sync::atomic::AtomicBool::new(test_expr!(1));
+    //~^ mutex_atomic
+    // The suggestion should preserve the macro call: `AtomicBool::new(test_expr!(true))`
+}
diff --git a/src/tools/clippy/tests/ui/mutex_atomic.rs b/src/tools/clippy/tests/ui/mutex_atomic.rs
index 95f2b135903f..33745f8fc5e1 100644
--- a/src/tools/clippy/tests/ui/mutex_atomic.rs
+++ b/src/tools/clippy/tests/ui/mutex_atomic.rs
@@ -65,3 +65,15 @@ fn issue13378() {
     let (funky_mtx): Mutex<u64> = Mutex::new(0);
     //~^ mutex_integer
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val > 0 && true)
+        };
+    }
+
+    let _ = Mutex::new(test_expr!(1));
+    //~^ mutex_atomic
+    // The suggestion should preserve the macro call: `AtomicBool::new(test_expr!(true))`
+}
diff --git a/src/tools/clippy/tests/ui/mutex_atomic.stderr b/src/tools/clippy/tests/ui/mutex_atomic.stderr
index 0afc6d541dea..56d94035583c 100644
--- a/src/tools/clippy/tests/ui/mutex_atomic.stderr
+++ b/src/tools/clippy/tests/ui/mutex_atomic.stderr
@@ -130,5 +130,13 @@ LL -     let (funky_mtx): Mutex<u64> = Mutex::new(0);
 LL +     let (funky_mtx) = std::sync::atomic::AtomicU64::new(0);
    |
 
-error: aborting due to 14 previous errors
+error: using a `Mutex` where an atomic would do
+  --> tests/ui/mutex_atomic.rs:76:13
+   |
+LL |     let _ = Mutex::new(test_expr!(1));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicBool::new(test_expr!(1))`
+   |
+   = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+
+error: aborting due to 15 previous errors
 
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed b/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
index 89a3c1474f25..751d3d257000 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
@@ -34,7 +34,9 @@ fn main() {
         println!("true") // This is a const method call
     }
 
-    if y & (0 < 1) {
+    // Resolved
+    if y && (0 < 1) {
+        //~^ needless_bitwise_bool
         println!("true") // This is a BinOp with no side effects
     }
 }
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.rs b/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
index f5aa7a9f3d9e..5d3ff3b2079c 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
@@ -34,7 +34,9 @@ fn main() {
         println!("true") // This is a const method call
     }
 
+    // Resolved
     if y & (0 < 1) {
+        //~^ needless_bitwise_bool
         println!("true") // This is a BinOp with no side effects
     }
 }
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr b/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
index 9f14646c3e5a..4f64c7136916 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
@@ -7,5 +7,11 @@ LL |     if y & !x {
    = note: `-D clippy::needless-bitwise-bool` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_bitwise_bool)]`
 
-error: aborting due to 1 previous error
+error: use of bitwise operator instead of lazy operator between booleans
+  --> tests/ui/needless_bitwise_bool.rs:38:8
+   |
+LL |     if y & (0 < 1) {
+   |        ^^^^^^^^^^^ help: try: `y && (0 < 1)`
+
+error: aborting due to 2 previous errors
 
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.fixed b/src/tools/clippy/tests/ui/needless_bool_assign.fixed
index d6fab4c51b53..8fd572038140 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.fixed
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.fixed
@@ -42,3 +42,22 @@ fn issue15063(x: bool, y: bool) {
     } else { z = x || y; }
     //~^^^^^ needless_bool_assign
 }
+
+fn wrongly_unmangled_macros(must_keep: fn(usize, usize) -> bool, x: usize, y: usize) {
+    struct Wrapper<T>(T);
+    let mut skip = Wrapper(false);
+
+    macro_rules! invoke {
+        ($func:expr, $a:expr, $b:expr) => {
+            $func($a, $b)
+        };
+    }
+    macro_rules! dot_0 {
+        ($w:expr) => {
+            $w.0
+        };
+    }
+
+    dot_0!(skip) = !invoke!(must_keep, x, y);
+    //~^^^^^ needless_bool_assign
+}
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.rs b/src/tools/clippy/tests/ui/needless_bool_assign.rs
index c504f61f4dd1..4721ab433b32 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.rs
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.rs
@@ -58,3 +58,26 @@ fn issue15063(x: bool, y: bool) {
     }
     //~^^^^^ needless_bool_assign
 }
+
+fn wrongly_unmangled_macros(must_keep: fn(usize, usize) -> bool, x: usize, y: usize) {
+    struct Wrapper<T>(T);
+    let mut skip = Wrapper(false);
+
+    macro_rules! invoke {
+        ($func:expr, $a:expr, $b:expr) => {
+            $func($a, $b)
+        };
+    }
+    macro_rules! dot_0 {
+        ($w:expr) => {
+            $w.0
+        };
+    }
+
+    if invoke!(must_keep, x, y) {
+        dot_0!(skip) = false;
+    } else {
+        dot_0!(skip) = true;
+    }
+    //~^^^^^ needless_bool_assign
+}
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.stderr b/src/tools/clippy/tests/ui/needless_bool_assign.stderr
index 1d09b8b25a09..34ff782f34a3 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.stderr
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.stderr
@@ -62,5 +62,15 @@ LL | |         z = false;
 LL | |     }
    | |_____^ help: you can reduce it to: `{ z = x || y; }`
 
-error: aborting due to 5 previous errors
+error: this if-then-else expression assigns a bool literal
+  --> tests/ui/needless_bool_assign.rs:77:5
+   |
+LL | /     if invoke!(must_keep, x, y) {
+LL | |         dot_0!(skip) = false;
+LL | |     } else {
+LL | |         dot_0!(skip) = true;
+LL | |     }
+   | |_____^ help: you can reduce it to: `dot_0!(skip) = !invoke!(must_keep, x, y);`
+
+error: aborting due to 6 previous errors
 
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed b/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
index a6d64d9afc1a..19b34f42af24 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
@@ -149,3 +149,11 @@ fn issue15256() {
     for v in vec.iter() { println!("{v}"); }
     //~^ needless_for_each
 }
+
+fn issue16294() {
+    let vec: Vec<i32> = Vec::new();
+    for elem in vec.iter() {
+        //~^ needless_for_each
+        println!("{elem}");
+    }
+}
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.rs b/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
index 7e74d2b428fd..f04e2555a370 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
@@ -149,3 +149,11 @@ fn issue15256() {
     vec.iter().for_each(|v| println!("{v}"));
     //~^ needless_for_each
 }
+
+fn issue16294() {
+    let vec: Vec<i32> = Vec::new();
+    vec.iter().for_each(|elem| {
+        //~^ needless_for_each
+        println!("{elem}");
+    })
+}
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr b/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
index 204cfa36b022..121669d15072 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
@@ -154,5 +154,22 @@ error: needless use of `for_each`
 LL |     vec.iter().for_each(|v| println!("{v}"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec.iter() { println!("{v}"); }`
 
-error: aborting due to 11 previous errors
+error: needless use of `for_each`
+  --> tests/ui/needless_for_each_fixable.rs:155:5
+   |
+LL | /     vec.iter().for_each(|elem| {
+LL | |
+LL | |         println!("{elem}");
+LL | |     })
+   | |______^
+   |
+help: try
+   |
+LL ~     for elem in vec.iter() {
+LL +
+LL +         println!("{elem}");
+LL +     }
+   |
+
+error: aborting due to 12 previous errors
 
diff --git a/src/tools/clippy/tests/ui/never_loop_iterator_reduction.rs b/src/tools/clippy/tests/ui/never_loop_iterator_reduction.rs
index 6b07b91db29a..27f1766b841d 100644
--- a/src/tools/clippy/tests/ui/never_loop_iterator_reduction.rs
+++ b/src/tools/clippy/tests/ui/never_loop_iterator_reduction.rs
@@ -1,8 +1,9 @@
 //@no-rustfix
 #![warn(clippy::never_loop)]
+#![expect(clippy::needless_return)]
 
 fn main() {
-    // diverging closure: should trigger
+    // diverging closure with no `return`: should trigger
     [0, 1].into_iter().for_each(|x| {
         //~^ never_loop
 
@@ -14,4 +15,10 @@ fn main() {
     [0, 1].into_iter().for_each(|x| {
         let _ = x + 1;
     });
+
+    // `return` should NOT trigger even though it is diverging
+    [0, 1].into_iter().for_each(|x| {
+        println!("x = {x}");
+        return;
+    });
 }
diff --git a/src/tools/clippy/tests/ui/never_loop_iterator_reduction.stderr b/src/tools/clippy/tests/ui/never_loop_iterator_reduction.stderr
index b76ee283146c..92483c85432d 100644
--- a/src/tools/clippy/tests/ui/never_loop_iterator_reduction.stderr
+++ b/src/tools/clippy/tests/ui/never_loop_iterator_reduction.stderr
@@ -1,5 +1,5 @@
 error: this iterator reduction never loops (closure always diverges)
-  --> tests/ui/never_loop_iterator_reduction.rs:6:5
+  --> tests/ui/never_loop_iterator_reduction.rs:7:5
    |
 LL | /     [0, 1].into_iter().for_each(|x| {
 LL | |
diff --git a/src/tools/clippy/tests/ui/new_without_default.fixed b/src/tools/clippy/tests/ui/new_without_default.fixed
index 9a5e90b48065..f6591820feeb 100644
--- a/src/tools/clippy/tests/ui/new_without_default.fixed
+++ b/src/tools/clippy/tests/ui/new_without_default.fixed
@@ -409,3 +409,58 @@ mod issue15778 {
         }
     }
 }
+
+pub mod issue16255 {
+    use std::fmt::Display;
+    use std::marker::PhantomData;
+
+    pub struct Foo<T> {
+        marker: PhantomData<T>,
+    }
+
+    impl<T> Default for Foo<T>
+    where
+        T: Display,
+        T: Clone,
+     {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl<T> Foo<T>
+    where
+        T: Display,
+    {
+        pub fn new() -> Self
+        //~^ new_without_default
+        where
+            T: Clone,
+        {
+            Self { marker: PhantomData }
+        }
+    }
+
+    pub struct Bar<T> {
+        marker: PhantomData<T>,
+    }
+
+    impl<T> Default for Bar<T>
+    where
+        T: Clone,
+     {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl<T> Bar<T> {
+        pub fn new() -> Self
+        //~^ new_without_default
+        where
+            T: Clone,
+        {
+            Self { marker: PhantomData }
+        }
+    }
+}
diff --git a/src/tools/clippy/tests/ui/new_without_default.rs b/src/tools/clippy/tests/ui/new_without_default.rs
index f7466aa32189..d3447f2e16b2 100644
--- a/src/tools/clippy/tests/ui/new_without_default.rs
+++ b/src/tools/clippy/tests/ui/new_without_default.rs
@@ -324,3 +324,39 @@ mod issue15778 {
         }
     }
 }
+
+pub mod issue16255 {
+    use std::fmt::Display;
+    use std::marker::PhantomData;
+
+    pub struct Foo<T> {
+        marker: PhantomData<T>,
+    }
+
+    impl<T> Foo<T>
+    where
+        T: Display,
+    {
+        pub fn new() -> Self
+        //~^ new_without_default
+        where
+            T: Clone,
+        {
+            Self { marker: PhantomData }
+        }
+    }
+
+    pub struct Bar<T> {
+        marker: PhantomData<T>,
+    }
+
+    impl<T> Bar<T> {
+        pub fn new() -> Self
+        //~^ new_without_default
+        where
+            T: Clone,
+        {
+            Self { marker: PhantomData }
+        }
+    }
+}
diff --git a/src/tools/clippy/tests/ui/new_without_default.stderr b/src/tools/clippy/tests/ui/new_without_default.stderr
index 0593dbb00fb6..6c0f73d13185 100644
--- a/src/tools/clippy/tests/ui/new_without_default.stderr
+++ b/src/tools/clippy/tests/ui/new_without_default.stderr
@@ -250,5 +250,58 @@ LL +     }
 LL + }
    |
 
-error: aborting due to 13 previous errors
+error: you should consider adding a `Default` implementation for `Foo<T>`
+  --> tests/ui/new_without_default.rs:340:9
+   |
+LL | /         pub fn new() -> Self
+LL | |
+LL | |         where
+LL | |             T: Clone,
+LL | |         {
+LL | |             Self { marker: PhantomData }
+LL | |         }
+   | |_________^
+   |
+help: try adding this
+   |
+LL ~     impl<T> Default for Foo<T>
+LL +     where
+LL +         T: Display,
+LL +         T: Clone,
+LL +      {
+LL +         fn default() -> Self {
+LL +             Self::new()
+LL +         }
+LL +     }
+LL + 
+LL ~     impl<T> Foo<T>
+   |
+
+error: you should consider adding a `Default` implementation for `Bar<T>`
+  --> tests/ui/new_without_default.rs:354:9
+   |
+LL | /         pub fn new() -> Self
+LL | |
+LL | |         where
+LL | |             T: Clone,
+LL | |         {
+LL | |             Self { marker: PhantomData }
+LL | |         }
+   | |_________^
+   |
+help: try adding this
+   |
+LL ~     impl<T> Default for Bar<T>
+LL +     where
+LL +         T: Clone,
+LL +      {
+LL +         fn default() -> Self {
+LL +             Self::new()
+LL +         }
+LL +     }
+LL + 
+LL ~     impl<T> Bar<T> {
+   |
+
+error: aborting due to 15 previous errors
 
diff --git a/src/tools/clippy/tests/ui/question_mark.fixed b/src/tools/clippy/tests/ui/question_mark.fixed
index 2c5ee0245038..b8072932c4ea 100644
--- a/src/tools/clippy/tests/ui/question_mark.fixed
+++ b/src/tools/clippy/tests/ui/question_mark.fixed
@@ -1,5 +1,5 @@
 #![feature(try_blocks)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::no_effect)]
 
 use std::sync::MutexGuard;
 
@@ -500,3 +500,18 @@ mod issue14894 {
         Ok(())
     }
 }
+
+fn wrongly_unmangled_macros() -> Option<i32> {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let x = test_expr!(42)?;
+    //~^^^ question_mark
+    Some(x);
+
+    test_expr!(42)?;
+    test_expr!(42)
+}
diff --git a/src/tools/clippy/tests/ui/question_mark.rs b/src/tools/clippy/tests/ui/question_mark.rs
index b9ff9d1565b2..b320dcd4b0bc 100644
--- a/src/tools/clippy/tests/ui/question_mark.rs
+++ b/src/tools/clippy/tests/ui/question_mark.rs
@@ -1,5 +1,5 @@
 #![feature(try_blocks)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::no_effect)]
 
 use std::sync::MutexGuard;
 
@@ -615,3 +615,23 @@ mod issue14894 {
         Ok(())
     }
 }
+
+fn wrongly_unmangled_macros() -> Option<i32> {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let Some(x) = test_expr!(42) else {
+        return None;
+    };
+    //~^^^ question_mark
+    Some(x);
+
+    if test_expr!(42).is_none() {
+        //~^ question_mark
+        return None;
+    }
+    test_expr!(42)
+}
diff --git a/src/tools/clippy/tests/ui/question_mark.stderr b/src/tools/clippy/tests/ui/question_mark.stderr
index 9b2896328e66..d645c8830adc 100644
--- a/src/tools/clippy/tests/ui/question_mark.stderr
+++ b/src/tools/clippy/tests/ui/question_mark.stderr
@@ -333,5 +333,22 @@ LL | |             return Err(reason);
 LL | |         }
    | |_________^ help: replace it with: `result?;`
 
-error: aborting due to 35 previous errors
+error: this `let...else` may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:626:5
+   |
+LL | /     let Some(x) = test_expr!(42) else {
+LL | |         return None;
+LL | |     };
+   | |______^ help: replace it with: `let x = test_expr!(42)?;`
+
+error: this block may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:632:5
+   |
+LL | /     if test_expr!(42).is_none() {
+LL | |
+LL | |         return None;
+LL | |     }
+   | |_____^ help: replace it with: `test_expr!(42)?;`
+
+error: aborting due to 37 previous errors
 
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
index 08903ef7fdda..b44009446640 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
@@ -195,3 +195,16 @@ fn issue16045() {
         }
     }
 }
+
+fn issue14989() {
+    macro_rules! x {
+        () => {
+            None::<i32>
+        };
+    }
+
+    if x! {}.is_some() {};
+    //~^ redundant_pattern_matching
+    while x! {}.is_some() {}
+    //~^ redundant_pattern_matching
+}
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
index 95eff3f9ebf9..c13cf993e786 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
@@ -231,3 +231,16 @@ fn issue16045() {
         }
     }
 }
+
+fn issue14989() {
+    macro_rules! x {
+        () => {
+            None::<i32>
+        };
+    }
+
+    if let Some(_) = (x! {}) {};
+    //~^ redundant_pattern_matching
+    while let Some(_) = (x! {}) {}
+    //~^ redundant_pattern_matching
+}
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
index 6fd0c5a6f859..5c9edfd4c50a 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
@@ -236,5 +236,17 @@ error: redundant pattern matching, consider using `is_some()`
 LL |         if let Some(_) = x.await {
    |         -------^^^^^^^---------- help: try: `if x.await.is_some()`
 
-error: aborting due to 33 previous errors
+error: redundant pattern matching, consider using `is_some()`
+  --> tests/ui/redundant_pattern_matching_option.rs:242:12
+   |
+LL |     if let Some(_) = (x! {}) {};
+   |     -------^^^^^^^---------- help: try: `if x! {}.is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> tests/ui/redundant_pattern_matching_option.rs:244:15
+   |
+LL |     while let Some(_) = (x! {}) {}
+   |     ----------^^^^^^^---------- help: try: `while x! {}.is_some()`
+
+error: aborting due to 35 previous errors
 
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
index 261d82fc35c8..8754d71aa629 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
@@ -165,3 +165,23 @@ fn issue10803() {
     // Don't lint
     let _ = matches!(x, Err(16));
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, i32>($val)
+        };
+    }
+
+    let _ = test_expr!(42).is_ok();
+
+    macro_rules! test_guard {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x: Result<i32, ()> = Ok(42);
+    let _ = x.is_ok() && test_guard!(42);
+    //~^ redundant_pattern_matching
+}
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
index 6cae4cc4b6b0..b83b02588fb6 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
@@ -205,3 +205,27 @@ fn issue10803() {
     // Don't lint
     let _ = matches!(x, Err(16));
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, i32>($val)
+        };
+    }
+
+    let _ = match test_expr!(42) {
+        //~^ redundant_pattern_matching
+        Ok(_) => true,
+        Err(_) => false,
+    };
+
+    macro_rules! test_guard {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x: Result<i32, ()> = Ok(42);
+    let _ = matches!(x, Ok(_) if test_guard!(42));
+    //~^ redundant_pattern_matching
+}
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
index 7e7d27d07a7f..dda203b753c3 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
@@ -209,5 +209,22 @@ error: redundant pattern matching, consider using `is_err()`
 LL |     let _ = matches!(x, Err(_));
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `x.is_err()`
 
-error: aborting due to 28 previous errors
+error: redundant pattern matching, consider using `is_ok()`
+  --> tests/ui/redundant_pattern_matching_result.rs:216:13
+   |
+LL |       let _ = match test_expr!(42) {
+   |  _____________^
+LL | |
+LL | |         Ok(_) => true,
+LL | |         Err(_) => false,
+LL | |     };
+   | |_____^ help: try: `test_expr!(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> tests/ui/redundant_pattern_matching_result.rs:229:13
+   |
+LL |     let _ = matches!(x, Ok(_) if test_guard!(42));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_ok() && test_guard!(42)`
+
+error: aborting due to 30 previous errors
 
diff --git a/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr b/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
index fb51313dab69..0ebc43739d6b 100644
--- a/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
+++ b/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
@@ -1,8 +1,8 @@
 error: usage of deprecated attribute
-  --> tests/ui/renamed_builtin_attr.rs:3:11
+  --> tests/ui/renamed_builtin_attr.rs:3:3
    |
 LL | #[clippy::cyclomatic_complexity = "1"]
-   |           ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `cognitive_complexity`
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `clippy::cognitive_complexity`
 
 error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.rs b/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.rs
new file mode 100644
index 000000000000..33378b386f34
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.rs
@@ -0,0 +1,12 @@
+//@no-rustfix
+#![warn(clippy::single_range_in_vec_init)]
+
+use std::ops::Range;
+
+fn issue16306(v: &[i32]) {
+    fn takes_range_slice(_: &[Range<i64>]) {}
+
+    let len = v.len();
+    takes_range_slice(&[0..len as i64]);
+    //~^ single_range_in_vec_init
+}
diff --git a/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.stderr b/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.stderr
new file mode 100644
index 000000000000..b10af21ed21c
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_range_in_vec_init_unfixable.stderr
@@ -0,0 +1,16 @@
+error: an array of `Range` that is only one element
+  --> tests/ui/single_range_in_vec_init_unfixable.rs:10:24
+   |
+LL |     takes_range_slice(&[0..len as i64]);
+   |                        ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::single-range-in-vec-init` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::single_range_in_vec_init)]`
+help: if you wanted a `Vec` that contains the entire range, try
+   |
+LL -     takes_range_slice(&[0..len as i64]);
+LL +     takes_range_slice(&(0..len as i64).collect::<std::vec::Vec<i64>>());
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui/str_to_string.fixed b/src/tools/clippy/tests/ui/str_to_string.fixed
index 2941c4dbd33d..8713c4f9bc86 100644
--- a/src/tools/clippy/tests/ui/str_to_string.fixed
+++ b/src/tools/clippy/tests/ui/str_to_string.fixed
@@ -8,3 +8,17 @@ fn main() {
     msg.to_owned();
     //~^ str_to_string
 }
+
+fn issue16271(key: &[u8]) {
+    macro_rules! t {
+        ($e:expr) => {
+            match $e {
+                Ok(e) => e,
+                Err(e) => panic!("{} failed with {}", stringify!($e), e),
+            }
+        };
+    }
+
+    let _value = t!(str::from_utf8(key)).to_owned();
+    //~^ str_to_string
+}
diff --git a/src/tools/clippy/tests/ui/str_to_string.rs b/src/tools/clippy/tests/ui/str_to_string.rs
index 4c4d2bb18062..b81759e1037b 100644
--- a/src/tools/clippy/tests/ui/str_to_string.rs
+++ b/src/tools/clippy/tests/ui/str_to_string.rs
@@ -8,3 +8,17 @@ fn main() {
     msg.to_string();
     //~^ str_to_string
 }
+
+fn issue16271(key: &[u8]) {
+    macro_rules! t {
+        ($e:expr) => {
+            match $e {
+                Ok(e) => e,
+                Err(e) => panic!("{} failed with {}", stringify!($e), e),
+            }
+        };
+    }
+
+    let _value = t!(str::from_utf8(key)).to_string();
+    //~^ str_to_string
+}
diff --git a/src/tools/clippy/tests/ui/str_to_string.stderr b/src/tools/clippy/tests/ui/str_to_string.stderr
index cb7b6b48843a..c0a38c8ebe46 100644
--- a/src/tools/clippy/tests/ui/str_to_string.stderr
+++ b/src/tools/clippy/tests/ui/str_to_string.stderr
@@ -13,5 +13,11 @@ error: `to_string()` called on a `&str`
 LL |     msg.to_string();
    |     ^^^^^^^^^^^^^^^ help: try: `msg.to_owned()`
 
-error: aborting due to 2 previous errors
+error: `to_string()` called on a `&str`
+  --> tests/ui/str_to_string.rs:22:18
+   |
+LL |     let _value = t!(str::from_utf8(key)).to_string();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t!(str::from_utf8(key)).to_owned()`
+
+error: aborting due to 3 previous errors
 
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
index 193217114d88..98fa3a4fcf70 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
@@ -1,6 +1,16 @@
 #![warn(clippy::string_from_utf8_as_bytes)]
 
+macro_rules! test_range {
+    ($start:expr, $end:expr) => {
+        $start..$end
+    };
+}
+
 fn main() {
     let _ = Some(&"Hello World!"[6..11]);
     //~^ string_from_utf8_as_bytes
+
+    let s = "Hello World!";
+    let _ = Some(&s[test_range!(6, 11)]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
index 49beb19ee40f..6354d5376ad6 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
@@ -1,6 +1,16 @@
 #![warn(clippy::string_from_utf8_as_bytes)]
 
+macro_rules! test_range {
+    ($start:expr, $end:expr) => {
+        $start..$end
+    };
+}
+
 fn main() {
     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
     //~^ string_from_utf8_as_bytes
+
+    let s = "Hello World!";
+    let _ = std::str::from_utf8(&s.as_bytes()[test_range!(6, 11)]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
index 99c8d8ae4eab..bba9ec0caf19 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
@@ -1,5 +1,5 @@
 error: calling a slice of `as_bytes()` with `from_utf8` should be not necessary
-  --> tests/ui/string_from_utf8_as_bytes.rs:4:13
+  --> tests/ui/string_from_utf8_as_bytes.rs:10:13
    |
 LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&"Hello World!"[6..11])`
@@ -7,5 +7,11 @@ LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
    = note: `-D clippy::string-from-utf8-as-bytes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::string_from_utf8_as_bytes)]`
 
-error: aborting due to 1 previous error
+error: calling a slice of `as_bytes()` with `from_utf8` should be not necessary
+  --> tests/ui/string_from_utf8_as_bytes.rs:14:13
+   |
+LL |     let _ = std::str::from_utf8(&s.as_bytes()[test_range!(6, 11)]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&s[test_range!(6, 11)])`
+
+error: aborting due to 2 previous errors
 
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.fixed b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.fixed
index f2bd306a99e4..f8be3331317c 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.fixed
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.fixed
@@ -1,6 +1,6 @@
 #![deny(clippy::trait_duplication_in_bounds)]
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait AssocConstTrait {
     #[type_const]
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs
index 8e7d843a44c0..a0d7a653993f 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_assoc_const_eq.rs
@@ -1,6 +1,6 @@
 #![deny(clippy::trait_duplication_in_bounds)]
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait AssocConstTrait {
     #[type_const]
diff --git a/src/tools/clippy/tests/ui/transmuting_null.rs b/src/tools/clippy/tests/ui/transmuting_null.rs
index 0d3b26673452..00aa35dff803 100644
--- a/src/tools/clippy/tests/ui/transmuting_null.rs
+++ b/src/tools/clippy/tests/ui/transmuting_null.rs
@@ -37,8 +37,19 @@ fn transmute_const_int() {
     }
 }
 
+fn transumute_single_expr_blocks() {
+    unsafe {
+        let _: &u64 = std::mem::transmute({ 0 as *const u64 });
+        //~^ transmuting_null
+
+        let _: &u64 = std::mem::transmute(const { u64::MIN as *const u64 });
+        //~^ transmuting_null
+    }
+}
+
 fn main() {
     one_liners();
     transmute_const();
     transmute_const_int();
+    transumute_single_expr_blocks();
 }
diff --git a/src/tools/clippy/tests/ui/transmuting_null.stderr b/src/tools/clippy/tests/ui/transmuting_null.stderr
index ed7c3396a243..e1de391813bd 100644
--- a/src/tools/clippy/tests/ui/transmuting_null.stderr
+++ b/src/tools/clippy/tests/ui/transmuting_null.stderr
@@ -25,5 +25,17 @@ error: transmuting a known null pointer into a reference
 LL |         let _: &u64 = std::mem::transmute(u64::MIN as *const u64);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: transmuting a known null pointer into a reference
+  --> tests/ui/transmuting_null.rs:42:23
+   |
+LL |         let _: &u64 = std::mem::transmute({ 0 as *const u64 });
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: transmuting a known null pointer into a reference
+  --> tests/ui/transmuting_null.rs:45:23
+   |
+LL |         let _: &u64 = std::mem::transmute(const { u64::MIN as *const u64 });
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
 
diff --git a/src/tools/clippy/tests/ui/unknown_attribute.stderr b/src/tools/clippy/tests/ui/unknown_attribute.stderr
index b306abe0a9d1..1d4d50ffc02a 100644
--- a/src/tools/clippy/tests/ui/unknown_attribute.stderr
+++ b/src/tools/clippy/tests/ui/unknown_attribute.stderr
@@ -1,8 +1,8 @@
 error: usage of unknown attribute
-  --> tests/ui/unknown_attribute.rs:3:11
+  --> tests/ui/unknown_attribute.rs:3:3
    |
 LL | #[clippy::unknown]
-   |           ^^^^^^^
+   |   ^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.fixed b/src/tools/clippy/tests/ui/unnecessary_fold.fixed
index c3eeafbc39cd..d51359349cb9 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.fixed
@@ -178,4 +178,15 @@ fn issue10000() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($e:expr) => {
+            ($e + 1) > 2
+        };
+    }
+
+    let _ = (0..3).any(|x| test_expr!(x));
+    //~^ unnecessary_fold
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.rs b/src/tools/clippy/tests/ui/unnecessary_fold.rs
index 6ab41a942625..c6eb7157ab12 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.rs
@@ -178,4 +178,15 @@ fn issue10000() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($e:expr) => {
+            ($e + 1) > 2
+        };
+    }
+
+    let _ = (0..3).fold(false, |acc: bool, x| acc || test_expr!(x));
+    //~^ unnecessary_fold
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.stderr b/src/tools/clippy/tests/ui/unnecessary_fold.stderr
index bb8aa7e18d34..560427a681a9 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.stderr
@@ -4,6 +4,7 @@ error: this `.fold` can be written more succinctly using another method
 LL |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
    |
+   = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
    = note: `-D clippy::unnecessary-fold` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fold)]`
 
@@ -21,6 +22,8 @@ error: this `.fold` can be written more succinctly using another method
    |
 LL |     let _ = (0..3).fold(true, |acc, x| acc && x > 2);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `all(|x| x > 2)`
+   |
+   = note: the `all` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
   --> tests/ui/unnecessary_fold.rs:24:25
@@ -63,12 +66,16 @@ error: this `.fold` can be written more succinctly using another method
    |
 LL |     let _: bool = (0..3).map(|x| 2 * x).fold(false, |acc, x| acc || x > 2);
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
+   |
+   = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
   --> tests/ui/unnecessary_fold.rs:110:10
    |
 LL |         .fold(false, |acc, x| acc || x > 2);
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
+   |
+   = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
   --> tests/ui/unnecessary_fold.rs:123:33
@@ -196,5 +203,13 @@ error: this `.fold` can be written more succinctly using another method
 LL |         (0..3).fold(1, |acc, x| acc * x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
-error: aborting due to 32 previous errors
+error: this `.fold` can be written more succinctly using another method
+  --> tests/ui/unnecessary_fold.rs:188:20
+   |
+LL |     let _ = (0..3).fold(false, |acc: bool, x| acc || test_expr!(x));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| test_expr!(x))`
+   |
+   = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
+
+error: aborting due to 33 previous errors
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed b/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
index 316eac0b58b7..590359bc1ad2 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
@@ -681,3 +681,12 @@ fn issue14833() {
     let mut s = HashSet::<&String>::new();
     s.remove(&"hello".to_owned());
 }
+
+#[allow(clippy::redundant_clone)]
+fn issue16351() {
+    fn take(_: impl AsRef<str>) {}
+
+    let dot = ".";
+    take(&format!("ouch{dot}"));
+    //~^ unnecessary_to_owned
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.rs b/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
index f2dbd1db3c9f..d1e3e6497c0a 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
@@ -681,3 +681,12 @@ fn issue14833() {
     let mut s = HashSet::<&String>::new();
     s.remove(&"hello".to_owned());
 }
+
+#[allow(clippy::redundant_clone)]
+fn issue16351() {
+    fn take(_: impl AsRef<str>) {}
+
+    let dot = ".";
+    take(format!("ouch{dot}").to_string());
+    //~^ unnecessary_to_owned
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr b/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
index 6c52be839301..50e3d5eb2195 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
@@ -550,5 +550,11 @@ error: unnecessary use of `to_vec`
 LL |     s.remove(&(&["b"]).to_vec());
    |              ^^^^^^^^^^^^^^^^^^ help: replace it with: `(&["b"]).as_slice()`
 
-error: aborting due to 82 previous errors
+error: unnecessary use of `to_string`
+  --> tests/ui/unnecessary_to_owned.rs:690:10
+   |
+LL |     take(format!("ouch{dot}").to_string());
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `&format!("ouch{dot}")`
+
+error: aborting due to 83 previous errors
 
diff --git a/src/tools/clippy/tests/ui/useless_conversion.fixed b/src/tools/clippy/tests/ui/useless_conversion.fixed
index adf5e58d9a1a..4832e922fa8e 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.fixed
+++ b/src/tools/clippy/tests/ui/useless_conversion.fixed
@@ -1,4 +1,5 @@
 #![deny(clippy::useless_conversion)]
+#![allow(clippy::into_iter_on_ref)]
 #![allow(clippy::needless_ifs, clippy::unnecessary_wraps, unused)]
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
@@ -131,6 +132,15 @@ fn main() {
     dont_lint_into_iter_on_copy_iter();
     dont_lint_into_iter_on_static_copy_iter();
 
+    {
+        // triggers the IntoIterator trait
+        fn consume(_: impl IntoIterator) {}
+
+        // Should suggest `*items` instead of `&**items`
+        let items = &&[1, 2, 3];
+        consume(*items); //~ useless_conversion
+    }
+
     let _: String = "foo".into();
     let _: String = From::from("foo");
     let _ = String::from("foo");
diff --git a/src/tools/clippy/tests/ui/useless_conversion.rs b/src/tools/clippy/tests/ui/useless_conversion.rs
index d95fe49e2e2b..6ef1f93a5606 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.rs
+++ b/src/tools/clippy/tests/ui/useless_conversion.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::useless_conversion)]
+#![allow(clippy::into_iter_on_ref)]
 #![allow(clippy::needless_ifs, clippy::unnecessary_wraps, unused)]
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
@@ -131,6 +132,15 @@ fn main() {
     dont_lint_into_iter_on_copy_iter();
     dont_lint_into_iter_on_static_copy_iter();
 
+    {
+        // triggers the IntoIterator trait
+        fn consume(_: impl IntoIterator) {}
+
+        // Should suggest `*items` instead of `&**items`
+        let items = &&[1, 2, 3];
+        consume(items.into_iter()); //~ useless_conversion
+    }
+
     let _: String = "foo".into();
     let _: String = From::from("foo");
     let _ = String::from("foo");
diff --git a/src/tools/clippy/tests/ui/useless_conversion.stderr b/src/tools/clippy/tests/ui/useless_conversion.stderr
index 052c664f6f2e..d28b7a5cbfb6 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.stderr
+++ b/src/tools/clippy/tests/ui/useless_conversion.stderr
@@ -1,5 +1,5 @@
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion.rs:9:13
+  --> tests/ui/useless_conversion.rs:10:13
    |
 LL |     let _ = T::from(val);
    |             ^^^^^^^^^^^^ help: consider removing `T::from()`: `val`
@@ -11,115 +11,132 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion.rs:11:5
+  --> tests/ui/useless_conversion.rs:12:5
    |
 LL |     val.into()
    |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
 
 error: useless conversion to the same type: `i32`
-  --> tests/ui/useless_conversion.rs:24:22
+  --> tests/ui/useless_conversion.rs:25:22
    |
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:55:22
+  --> tests/ui/useless_conversion.rs:56:22
    |
 LL |     if Some("ok") == lines.into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `lines`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:61:21
+  --> tests/ui/useless_conversion.rs:62:21
    |
 LL |     let mut lines = text.lines().into_iter();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:68:22
+  --> tests/ui/useless_conversion.rs:69:22
    |
 LL |     if Some("ok") == text.lines().into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> tests/ui/useless_conversion.rs:75:13
+  --> tests/ui/useless_conversion.rs:76:13
    |
 LL |     let _ = NUMBERS.into_iter().next();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> tests/ui/useless_conversion.rs:81:17
+  --> tests/ui/useless_conversion.rs:82:17
    |
 LL |     let mut n = NUMBERS.into_iter();
    |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> tests/ui/useless_conversion.rs:141:17
+   |
+LL |         consume(items.into_iter());
+   |                 ^^^^^^^^^^^^^^^^^
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> tests/ui/useless_conversion.rs:137:28
+   |
+LL |         fn consume(_: impl IntoIterator) {}
+   |                            ^^^^^^^^^^^^
+help: consider removing the `.into_iter()`
+   |
+LL -         consume(items.into_iter());
+LL +         consume(*items);
+   |
+
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:144:21
+  --> tests/ui/useless_conversion.rs:154:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:146:21
+  --> tests/ui/useless_conversion.rs:156:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:148:13
+  --> tests/ui/useless_conversion.rs:158:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:150:13
+  --> tests/ui/useless_conversion.rs:160:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:152:13
+  --> tests/ui/useless_conversion.rs:162:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
 error: useless conversion to the same type: `std::vec::IntoIter<i32>`
-  --> tests/ui/useless_conversion.rs:154:13
+  --> tests/ui/useless_conversion.rs:164:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:156:21
+  --> tests/ui/useless_conversion.rs:166:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
 error: useless conversion to the same type: `i32`
-  --> tests/ui/useless_conversion.rs:162:13
+  --> tests/ui/useless_conversion.rs:172:13
    |
 LL |     let _ = i32::from(a + b) * 3;
    |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> tests/ui/useless_conversion.rs:169:23
+  --> tests/ui/useless_conversion.rs:179:23
    |
 LL |     let _: Foo<'a'> = s2.into();
    |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> tests/ui/useless_conversion.rs:172:13
+  --> tests/ui/useless_conversion.rs:182:13
    |
 LL |     let _ = Foo::<'a'>::from(s3);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`
 
 error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
-  --> tests/ui/useless_conversion.rs:175:13
+  --> tests/ui/useless_conversion.rs:185:13
    |
 LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:208:7
+  --> tests/ui/useless_conversion.rs:218:7
    |
 LL |     b(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -127,13 +144,13 @@ LL |     b(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:198:13
+  --> tests/ui/useless_conversion.rs:208:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:210:7
+  --> tests/ui/useless_conversion.rs:220:7
    |
 LL |     c(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -141,13 +158,13 @@ LL |     c(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:199:18
+  --> tests/ui/useless_conversion.rs:209:18
    |
 LL |     fn c(_: impl IntoIterator<Item = i32>) {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:212:7
+  --> tests/ui/useless_conversion.rs:222:7
    |
 LL |     d(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -155,13 +172,13 @@ LL |     d(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:202:12
+  --> tests/ui/useless_conversion.rs:212:12
    |
 LL |         T: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:216:7
+  --> tests/ui/useless_conversion.rs:226:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter());
    |       ^^^^^^^^^^------------------------
@@ -169,13 +186,13 @@ LL |     b(vec![1, 2].into_iter().into_iter());
    |                 help: consider removing the `.into_iter()`s
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:198:13
+  --> tests/ui/useless_conversion.rs:208:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:218:7
+  --> tests/ui/useless_conversion.rs:228:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |       ^^^^^^^^^^------------------------------------
@@ -183,13 +200,13 @@ LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |                 help: consider removing the `.into_iter()`s
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:198:13
+  --> tests/ui/useless_conversion.rs:208:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:265:24
+  --> tests/ui/useless_conversion.rs:275:24
    |
 LL |         foo2::<i32, _>([1, 2, 3].into_iter());
    |                        ^^^^^^^^^------------
@@ -197,13 +214,13 @@ LL |         foo2::<i32, _>([1, 2, 3].into_iter());
    |                                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:244:12
+  --> tests/ui/useless_conversion.rs:254:12
    |
 LL |         I: IntoIterator<Item = i32> + Helper<X>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:274:14
+  --> tests/ui/useless_conversion.rs:284:14
    |
 LL |         foo3([1, 2, 3].into_iter());
    |              ^^^^^^^^^------------
@@ -211,13 +228,13 @@ LL |         foo3([1, 2, 3].into_iter());
    |                       help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:253:12
+  --> tests/ui/useless_conversion.rs:263:12
    |
 LL |         I: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:284:16
+  --> tests/ui/useless_conversion.rs:294:16
    |
 LL |         S1.foo([1, 2].into_iter());
    |                ^^^^^^------------
@@ -225,13 +242,13 @@ LL |         S1.foo([1, 2].into_iter());
    |                      help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:281:27
+  --> tests/ui/useless_conversion.rs:291:27
    |
 LL |             pub fn foo<I: IntoIterator>(&self, _: I) {}
    |                           ^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:304:44
+  --> tests/ui/useless_conversion.rs:314:44
    |
 LL |         v0.into_iter().interleave_shortest(v1.into_iter());
    |                                            ^^------------
@@ -239,67 +256,67 @@ LL |         v0.into_iter().interleave_shortest(v1.into_iter());
    |                                              help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:291:20
+  --> tests/ui/useless_conversion.rs:301:20
    |
 LL |                 J: IntoIterator,
    |                    ^^^^^^^^^^^^
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:332:58
+  --> tests/ui/useless_conversion.rs:342:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(Into::into);
    |                                                          ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `std::io::Error`
-  --> tests/ui/useless_conversion.rs:335:58
+  --> tests/ui/useless_conversion.rs:345:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(Into::into);
    |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:338:58
+  --> tests/ui/useless_conversion.rs:348:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(From::from);
    |                                                          ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `std::io::Error`
-  --> tests/ui/useless_conversion.rs:341:58
+  --> tests/ui/useless_conversion.rs:351:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(From::from);
    |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:345:31
+  --> tests/ui/useless_conversion.rs:355:31
    |
 LL |     let _: ControlFlow<()> = c.map_break(Into::into);
    |                               ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:349:31
+  --> tests/ui/useless_conversion.rs:359:31
    |
 LL |     let _: ControlFlow<()> = c.map_continue(Into::into);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `u32`
-  --> tests/ui/useless_conversion.rs:363:41
+  --> tests/ui/useless_conversion.rs:373:41
    |
 LL |     let _: Vec<u32> = [1u32].into_iter().map(Into::into).collect();
    |                                         ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion.rs:374:18
+  --> tests/ui/useless_conversion.rs:384:18
    |
 LL |     x.into_iter().map(Into::into).collect()
    |                  ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:390:29
+  --> tests/ui/useless_conversion.rs:400:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:379:32
+  --> tests/ui/useless_conversion.rs:389:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -310,13 +327,13 @@ LL +             takes_into_iter(&self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:398:29
+  --> tests/ui/useless_conversion.rs:408:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:379:32
+  --> tests/ui/useless_conversion.rs:389:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -327,13 +344,13 @@ LL +             takes_into_iter(&mut self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:407:29
+  --> tests/ui/useless_conversion.rs:417:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:379:32
+  --> tests/ui/useless_conversion.rs:389:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -344,13 +361,13 @@ LL +             takes_into_iter(*self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:416:29
+  --> tests/ui/useless_conversion.rs:426:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:379:32
+  --> tests/ui/useless_conversion.rs:389:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -361,13 +378,13 @@ LL +             takes_into_iter(&*self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:425:29
+  --> tests/ui/useless_conversion.rs:435:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:379:32
+  --> tests/ui/useless_conversion.rs:389:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -378,22 +395,22 @@ LL +             takes_into_iter(&mut *self.my_field);
    |
 
 error: useless conversion to the same type: `std::ops::Range<u32>`
-  --> tests/ui/useless_conversion.rs:440:5
+  --> tests/ui/useless_conversion.rs:450:5
    |
 LL |     R.into_iter().for_each(|_x| {});
    |     ^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `R`
 
 error: useless conversion to the same type: `std::ops::Range<u32>`
-  --> tests/ui/useless_conversion.rs:442:13
+  --> tests/ui/useless_conversion.rs:452:13
    |
 LL |     let _ = R.into_iter().map(|_x| 0);
    |             ^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `R`
 
 error: useless conversion to the same type: `std::slice::Iter<'_, i32>`
-  --> tests/ui/useless_conversion.rs:453:14
+  --> tests/ui/useless_conversion.rs:463:14
    |
 LL |     for _ in mac!(iter [1, 2]).into_iter() {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `mac!(iter [1, 2])`
 
-error: aborting due to 44 previous errors
+error: aborting due to 45 previous errors
 
diff --git a/src/tools/clippy/triagebot.toml b/src/tools/clippy/triagebot.toml
index 5f637205fa65..09dec7675e7e 100644
--- a/src/tools/clippy/triagebot.toml
+++ b/src/tools/clippy/triagebot.toml
@@ -63,7 +63,6 @@ users_on_vacation = [
     "Alexendoo",
     "y21",
     "blyxyas",
-    "samueltardieu",
 ]
 
 [assign.owners]
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 5563abe92a80..a2f3a8f00dac 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -18,7 +18,7 @@ string_enum! {
         Pretty => "pretty",
         DebugInfo => "debuginfo",
         Codegen => "codegen",
-        Rustdoc => "rustdoc",
+        RustdocHtml => "rustdoc-html",
         RustdocJson => "rustdoc-json",
         CodegenUnits => "codegen-units",
         Incremental => "incremental",
@@ -69,7 +69,7 @@ string_enum! {
         Pretty => "pretty",
         RunMake => "run-make",
         RunMakeCargo => "run-make-cargo",
-        Rustdoc => "rustdoc",
+        RustdocHtml => "rustdoc-html",
         RustdocGui => "rustdoc-gui",
         RustdocJs => "rustdoc-js",
         RustdocJsStd=> "rustdoc-js-std",
@@ -715,6 +715,11 @@ pub struct Config {
     pub override_codegen_backend: Option<String>,
     /// Whether to ignore `//@ ignore-backends`.
     pub bypass_ignore_backends: bool,
+
+    /// Number of parallel jobs configured for the build.
+    ///
+    /// This is forwarded from bootstrap's `jobs` configuration.
+    pub jobs: u32,
 }
 
 impl Config {
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index d1e0c5d95001..624f4dd7c2b1 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -15,7 +15,7 @@ use crate::directives::directive_names::{
 };
 pub(crate) use crate::directives::file::FileDirectives;
 use crate::directives::handlers::DIRECTIVE_HANDLERS_MAP;
-use crate::directives::line::{DirectiveLine, line_directive};
+use crate::directives::line::DirectiveLine;
 use crate::directives::needs::CachedNeedsConditions;
 use crate::edition::{Edition, parse_edition};
 use crate::errors::ErrorKind;
@@ -29,6 +29,7 @@ mod directive_names;
 mod file;
 mod handlers;
 mod line;
+pub(crate) use line::line_directive;
 mod line_number;
 pub(crate) use line_number::LineNumber;
 mod needs;
@@ -551,7 +552,7 @@ fn check_directive<'a>(
 
     let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
         || match mode {
-            TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
+            TestMode::RustdocHtml => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
             TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
             _ => false,
         };
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 0d3777b8e60c..21d1940d5673 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -225,6 +225,7 @@ impl ConfigBuilder {
             "--nightly-branch=",
             "--git-merge-commit-email=",
             "--minicore-path=",
+            "--jobs=0",
         ];
         let mut args: Vec<String> = args.iter().map(ToString::to_string).collect();
 
@@ -630,7 +631,7 @@ fn test_forbidden_revisions_allowed_in_non_filecheck_dir() {
     let modes = [
         "pretty",
         "debuginfo",
-        "rustdoc",
+        "rustdoc-html",
         "rustdoc-json",
         "codegen-units",
         "incremental",
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index a64c7850aad4..82e8a0da6b60 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -85,7 +85,7 @@ fn parse_config(args: Vec<String>) -> Config {
             "",
             "mode",
             "which sort of compile tests to run",
-            "pretty | debug-info | codegen | rustdoc \
+            "pretty | debug-info | codegen | rustdoc-html \
             | rustdoc-json | codegen-units | incremental | run-make | ui \
             | rustdoc-js | mir-opt | assembly | crashes",
         )
@@ -218,7 +218,8 @@ fn parse_config(args: Vec<String>) -> Config {
             "the codegen backend to use instead of the default one",
             "CODEGEN BACKEND [NAME | PATH]",
         )
-        .optflag("", "bypass-ignore-backends", "ignore `//@ ignore-backends` directives");
+        .optflag("", "bypass-ignore-backends", "ignore `//@ ignore-backends` directives")
+        .reqopt("", "jobs", "number of parallel jobs bootstrap was configured with", "JOBS");
 
     let (argv0, args_) = args.split_first().unwrap();
     if args.len() == 1 || args[1] == "-h" || args[1] == "--help" {
@@ -363,6 +364,11 @@ fn parse_config(args: Vec<String>) -> Config {
     let build_test_suite_root = opt_path(matches, "build-test-suite-root");
     assert!(build_test_suite_root.starts_with(&build_root));
 
+    let jobs = match matches.opt_str("jobs") {
+        Some(jobs) => jobs.parse::<u32>().expect("expected `--jobs` to be an `u32`"),
+        None => panic!("`--jobs` is required"),
+    };
+
     Config {
         bless: matches.opt_present("bless"),
         fail_fast: matches.opt_present("fail-fast")
@@ -481,6 +487,8 @@ fn parse_config(args: Vec<String>) -> Config {
         default_codegen_backend,
         override_codegen_backend,
         bypass_ignore_backends: matches.opt_present("bypass-ignore-backends"),
+
+        jobs,
     }
 }
 
@@ -1094,8 +1102,8 @@ fn make_test_name_and_filterable_path(
 /// of some other tests's name.
 ///
 /// For example, suppose the test suite contains these two test files:
-/// - `tests/rustdoc/primitive.rs`
-/// - `tests/rustdoc/primitive/no_std.rs`
+/// - `tests/rustdoc-html/primitive.rs`
+/// - `tests/rustdoc-html/primitive/no_std.rs`
 ///
 /// The test runner might put the output from those tests in these directories:
 /// - `$build/test/rustdoc/primitive/`
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 1216ba888328..6efdb5a99ee2 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -269,7 +269,7 @@ impl<'test> TestCx<'test> {
             TestMode::Pretty => self.run_pretty_test(),
             TestMode::DebugInfo => self.run_debuginfo_test(),
             TestMode::Codegen => self.run_codegen_test(),
-            TestMode::Rustdoc => self.run_rustdoc_test(),
+            TestMode::RustdocHtml => self.run_rustdoc_html_test(),
             TestMode::RustdocJson => self.run_rustdoc_json_test(),
             TestMode::CodegenUnits => self.run_codegen_units_test(),
             TestMode::Incremental => self.run_incremental_test(),
@@ -1758,7 +1758,7 @@ impl<'test> TestCx<'test> {
             }
             TestMode::Pretty
             | TestMode::DebugInfo
-            | TestMode::Rustdoc
+            | TestMode::RustdocHtml
             | TestMode::RustdocJson
             | TestMode::RunMake
             | TestMode::RustdocJs => {
diff --git a/src/tools/compiletest/src/runtest/debugger.rs b/src/tools/compiletest/src/runtest/debugger.rs
index c83e00c1006e..70996004a336 100644
--- a/src/tools/compiletest/src/runtest/debugger.rs
+++ b/src/tools/compiletest/src/runtest/debugger.rs
@@ -4,7 +4,7 @@ use std::io::{BufRead, BufReader};
 
 use camino::{Utf8Path, Utf8PathBuf};
 
-use crate::directives::LineNumber;
+use crate::directives::{LineNumber, line_directive};
 use crate::runtest::ProcRes;
 
 /// Representation of information to invoke a debugger and check its output
@@ -17,10 +17,16 @@ pub(super) struct DebuggerCommands {
     check_lines: Vec<(LineNumber, String)>,
     /// Source file name
     file: Utf8PathBuf,
+    /// The revision being tested, if any
+    revision: Option<String>,
 }
 
 impl DebuggerCommands {
-    pub fn parse_from(file: &Utf8Path, debugger_prefix: &str) -> Result<Self, String> {
+    pub fn parse_from(
+        file: &Utf8Path,
+        debugger_prefix: &str,
+        test_revision: Option<&str>,
+    ) -> Result<Self, String> {
         let command_directive = format!("{debugger_prefix}-command");
         let check_directive = format!("{debugger_prefix}-check");
 
@@ -37,19 +43,33 @@ impl DebuggerCommands {
                 continue;
             }
 
-            let Some(line) = line.trim_start().strip_prefix("//@").map(str::trim_start) else {
+            let Some(directive) = line_directive(file, line_number, &line) else {
                 continue;
             };
 
-            if let Some(command) = parse_name_value(&line, &command_directive) {
-                commands.push(command);
+            if !directive.applies_to_test_revision(test_revision) {
+                continue;
             }
-            if let Some(pattern) = parse_name_value(&line, &check_directive) {
-                check_lines.push((line_number, pattern));
+
+            if directive.name == command_directive
+                && let Some(command) = directive.value_after_colon()
+            {
+                commands.push(command.to_string());
+            }
+            if directive.name == check_directive
+                && let Some(pattern) = directive.value_after_colon()
+            {
+                check_lines.push((line_number, pattern.to_string()));
             }
         }
 
-        Ok(Self { commands, breakpoint_lines, check_lines, file: file.to_path_buf() })
+        Ok(Self {
+            commands,
+            breakpoint_lines,
+            check_lines,
+            file: file.to_path_buf(),
+            revision: test_revision.map(str::to_owned),
+        })
     }
 
     /// Given debugger output and lines to check, ensure that every line is
@@ -81,9 +101,11 @@ impl DebuggerCommands {
             Ok(())
         } else {
             let fname = self.file.file_name().unwrap();
+            let revision_suffix =
+                self.revision.as_ref().map_or(String::new(), |r| format!("#{}", r));
             let mut msg = format!(
-                "check directive(s) from `{}` not found in debugger output. errors:",
-                self.file
+                "check directive(s) from `{}{}` not found in debugger output. errors:",
+                self.file, revision_suffix
             );
 
             for (src_lineno, err_line) in missing {
@@ -103,18 +125,6 @@ impl DebuggerCommands {
     }
 }
 
-/// Split off from the main `parse_name_value_directive`, so that improvements
-/// to directive handling aren't held back by debuginfo test commands.
-fn parse_name_value(line: &str, name: &str) -> Option<String> {
-    if let Some(after_name) = line.strip_prefix(name)
-        && let Some(value) = after_name.strip_prefix(':')
-    {
-        Some(value.to_owned())
-    } else {
-        None
-    }
-}
-
 /// Check that the pattern in `check_line` applies to `line`. Returns `true` if they do match.
 fn check_single_line(line: &str, check_line: &str) -> bool {
     // Allow check lines to leave parts unspecified (e.g., uninitialized
diff --git a/src/tools/compiletest/src/runtest/debuginfo.rs b/src/tools/compiletest/src/runtest/debuginfo.rs
index 83b61b9be57d..9d6edaddc1b7 100644
--- a/src/tools/compiletest/src/runtest/debuginfo.rs
+++ b/src/tools/compiletest/src/runtest/debuginfo.rs
@@ -46,7 +46,7 @@ impl TestCx<'_> {
         }
 
         // Parse debugger commands etc from test files
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "cdb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "cdb", self.revision)
             .unwrap_or_else(|e| self.fatal(&e));
 
         // https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-commands
@@ -105,7 +105,7 @@ impl TestCx<'_> {
     }
 
     fn run_debuginfo_gdb_test(&self) {
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "gdb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "gdb", self.revision)
             .unwrap_or_else(|e| self.fatal(&e));
         let mut cmds = dbg_cmds.commands.join("\n");
 
@@ -366,7 +366,7 @@ impl TestCx<'_> {
         }
 
         // Parse debugger commands etc from test files
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "lldb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "lldb", self.revision)
             .unwrap_or_else(|e| self.fatal(&e));
 
         // Write debugger script:
diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
index ba3a12347367..4eb8f91fe894 100644
--- a/src/tools/compiletest/src/runtest/run_make.rs
+++ b/src/tools/compiletest/src/runtest/run_make.rs
@@ -249,6 +249,9 @@ impl TestCx<'_> {
             cmd.env("__STD_REMAP_DEBUGINFO_ENABLED", "1");
         }
 
+        // Used for `run_make_support::env::jobs`.
+        cmd.env("__BOOTSTRAP_JOBS", self.config.jobs.to_string());
+
         // We don't want RUSTFLAGS set from the outside to interfere with
         // compiler flags set in the test cases:
         cmd.env_remove("RUSTFLAGS");
diff --git a/src/tools/compiletest/src/runtest/rustdoc.rs b/src/tools/compiletest/src/runtest/rustdoc.rs
index 3c80521e51ec..8907848e0ca5 100644
--- a/src/tools/compiletest/src/runtest/rustdoc.rs
+++ b/src/tools/compiletest/src/runtest/rustdoc.rs
@@ -3,7 +3,7 @@ use std::process::Command;
 use super::{DocKind, TestCx, remove_and_create_dir_all};
 
 impl TestCx<'_> {
-    pub(super) fn run_rustdoc_test(&self) {
+    pub(super) fn run_rustdoc_html_test(&self) {
         assert!(self.revision.is_none(), "revisions not supported in this test suite");
 
         let out_dir = self.output_base_dir();
diff --git a/src/tools/compiletest/src/rustdoc_gui_test.rs b/src/tools/compiletest/src/rustdoc_gui_test.rs
index 4454ffb1f59e..f02918ae683b 100644
--- a/src/tools/compiletest/src/rustdoc_gui_test.rs
+++ b/src/tools/compiletest/src/rustdoc_gui_test.rs
@@ -50,7 +50,7 @@ fn incomplete_config_for_rustdoc_gui_test() -> Config {
     //
     // For instance, `//@ ignore-stage1` will not work at all.
     Config {
-        mode: TestMode::Rustdoc,
+        mode: TestMode::RustdocHtml,
         // E.g. this has no sensible default tbh.
         suite: TestSuite::Ui,
 
@@ -139,5 +139,6 @@ fn incomplete_config_for_rustdoc_gui_test() -> Config {
         default_codegen_backend: CodegenBackend::Llvm,
         override_codegen_backend: None,
         bypass_ignore_backends: Default::default(),
+        jobs: Default::default(),
     }
 }
diff --git a/src/tools/lint-docs/Cargo.toml b/src/tools/lint-docs/Cargo.toml
index 6e1ab84ed18d..ab99eb8ea3b7 100644
--- a/src/tools/lint-docs/Cargo.toml
+++ b/src/tools/lint-docs/Cargo.toml
@@ -7,7 +7,7 @@ description = "A script to extract the lint documentation for the rustc book."
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 serde_json = "1.0.57"
 tempfile = "3.1.0"
 walkdir = "2.3.1"
diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index 395c37e9ade8..b314aaafbdf0 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -123,22 +123,21 @@ dependencies = [
 
 [[package]]
 name = "capstone"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "015ef5d5ca1743e3f94af9509ba6bd2886523cfee46e48d15c2ef5216fd4ac9a"
+checksum = "f442ae0f2f3f1b923334b4a5386c95c69c1cfa072bafa23d6fae6d9682eb1dd4"
 dependencies = [
  "capstone-sys",
- "libc",
+ "static_assertions",
 ]
 
 [[package]]
 name = "capstone-sys"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2267cb8d16a1e4197863ec4284ffd1aec26fe7e57c58af46b02590a0235809a0"
+checksum = "a4e8087cab6731295f5a2a2bd82989ba4f41d3a428aab2e7c98d8f4db38aac05"
 dependencies = [
  "cc",
- "libc",
 ]
 
 [[package]]
@@ -786,9 +785,9 @@ checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
 [[package]]
 name = "libffi"
-version = "5.0.0"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0444124f3ffd67e1b0b0c661a7f81a278a135eb54aaad4078e79fbc8be50c8a5"
+checksum = "0498fe5655f857803e156523e644dcdcdc3b3c7edda42ea2afdae2e09b2db87b"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -796,9 +795,9 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "4.0.0"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d722da8817ea580d0669da6babe2262d7b86a1af1103da24102b8bb9c101ce7"
+checksum = "71d4f1d4ce15091955144350b75db16a96d4a63728500122706fb4d29a26afbb"
 dependencies = [
  "cc",
 ]
@@ -1404,6 +1403,12 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 4a54a7e0eb71..e7c90e45eba5 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -32,14 +32,14 @@ serde_json = { version = "1.0", optional = true }
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 # native-lib dependencies
-libffi = { version = "5.0.0", optional = true }
+libffi = { version = "5.1.0", optional = true }
 libloading = { version = "0.9", optional = true }
 serde = { version = "1.0.219", features = ["derive"], optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"], optional = true }
 ipc-channel = { version = "0.20.0", optional = true }
-capstone = { version = "0.13", optional = true }
+capstone = { version = "0.14", optional = true }
 
 [target.'cfg(all(target_os = "linux", target_pointer_width = "64", target_endian = "little"))'.dependencies]
 genmc-sys = { path = "./genmc-sys/", version = "0.1.0", optional = true }
@@ -68,6 +68,7 @@ expensive-consistency-checks = ["stack-cache"]
 tracing = ["serde_json"]
 native-lib = ["dep:libffi", "dep:libloading", "dep:capstone", "dep:ipc-channel", "dep:nix", "dep:serde"]
 jemalloc = []
+check_only = ["libffi?/check_only", "capstone?/check_only", "genmc-sys?/check_only"]
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 2832ef50adef..d5ef9c767414 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -219,7 +219,7 @@ degree documented below):
 - We have unofficial support (not maintained by the Miri team itself) for some further operating systems.
   - `solaris` / `illumos`: maintained by @devnexen. Supports the entire test suite.
   - `freebsd`: maintained by @YohDeadfall and @LorrensP-2158466. Supports the entire test suite.
-  - `android`: **maintainer wanted**. Basic OS APIs and concurrency work, but file system access is not supported.
+  - `android`: **maintainer wanted**. Supports the entire test suite.
 - For targets on other operating systems, Miri might fail before even reaching the `main` function.
 
 However, even for targets that we do support, the degree of support for accessing platform APIs
diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 2dd8fc77459a..c8e359cf2385 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -30,14 +30,15 @@ export CARGO_INCREMENTAL=0
 export CARGO_EXTRA_FLAGS="--locked"
 
 # Determine configuration for installed build (used by test-cargo-miri and `./miri bench`).
+# We use the default set of features for this.
 echo "Installing release version of Miri"
 time ./miri install
 
 # Prepare debug build for direct `./miri` invocations.
-# We enable all features to make sure the Stacked Borrows consistency check runs.
+# Here we enable some more features and checks.
 echo "Building debug version of Miri"
-export CARGO_EXTRA_FLAGS="$CARGO_EXTRA_FLAGS --all-features"
-time ./miri build # the build that all the `./miri test` below will use
+export FEATURES="--features=expensive-consistency-checks,genmc"
+time ./miri build $FEATURES # the build that all the `./miri test` below will use
 
 endgroup
 
@@ -63,7 +64,7 @@ function run_tests {
   if [ -n "${GC_STRESS-}" ]; then
     time MIRIFLAGS="${MIRIFLAGS-} -Zmiri-provenance-gc=1" ./miri test $TARGET_FLAG
   else
-    time ./miri test $TARGET_FLAG
+    time ./miri test $FEATURES $TARGET_FLAG
   fi
 
   ## advanced tests
@@ -74,20 +75,20 @@ function run_tests {
     # them. Also error locations change so we don't run the failing tests.
     # We explicitly enable debug-assertions here, they are disabled by -O but we have tests
     # which exist to check that we panic on debug assertion failures.
-    time MIRIFLAGS="${MIRIFLAGS-} -O -Zmir-opt-level=4 -Cdebug-assertions=yes" MIRI_SKIP_UI_CHECKS=1 ./miri test $TARGET_FLAG tests/{pass,panic}
+    time MIRIFLAGS="${MIRIFLAGS-} -O -Zmir-opt-level=4 -Cdebug-assertions=yes" MIRI_SKIP_UI_CHECKS=1 ./miri test $FEATURES $TARGET_FLAG tests/{pass,panic}
   fi
   if [ -n "${MANY_SEEDS-}" ]; then
     # Run many-seeds tests. (Also tests `./miri run`.)
     time for FILE in tests/many-seeds/*.rs; do
-      ./miri run "-Zmiri-many-seeds=0..$MANY_SEEDS" $TARGET_FLAG "$FILE"
+      ./miri run $FEATURES "-Zmiri-many-seeds=0..$MANY_SEEDS" $TARGET_FLAG "$FILE"
     done
+    # Smoke-test `./miri run --dep`.
+    ./miri run $FEATURES $TARGET_FLAG --dep tests/pass-dep/getrandom.rs
   fi
   if [ -n "${TEST_BENCH-}" ]; then
     # Check that the benchmarks build and run, but only once.
     time HYPERFINE="hyperfine -w0 -r1 --show-output" ./miri bench $TARGET_FLAG --no-install
   fi
-  # Smoke-test `./miri run --dep`.
-  ./miri run $TARGET_FLAG --dep tests/pass-dep/getrandom.rs
 
   ## test-cargo-miri
   # On Windows, there is always "python", not "python3" or "python2".
@@ -149,10 +150,11 @@ case $HOST_TARGET in
   i686-unknown-linux-gnu)
     # Host
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
+    # Fully, but not officially, supported tier 2
+    MANY_SEEDS=16 TEST_TARGET=aarch64-linux-android run_tests
     # Partially supported targets (tier 2)
     BASIC="empty_main integer heap_alloc libc-mem vec string btreemap" # ensures we have the basics: pre-main code, system allocator
     UNIX="hello panic/panic panic/unwind concurrency/simple atomic libc-mem libc-misc libc-random env num_cpus" # the things that are very similar across all Unixes, and hence easily supported there
-    TEST_TARGET=aarch64-linux-android  run_tests_minimal $BASIC $UNIX time hashmap random thread sync concurrency epoll eventfd prctl
     TEST_TARGET=wasm32-unknown-unknown run_tests_minimal no_std empty_main wasm # this target doesn't really have std
     TEST_TARGET=thumbv7em-none-eabihf  run_tests_minimal no_std
     ;;
diff --git a/src/tools/miri/etc/rust_analyzer_helix.toml b/src/tools/miri/etc/rust_analyzer_helix.toml
index dd222c50431a..1015b4baa6b0 100644
--- a/src/tools/miri/etc/rust_analyzer_helix.toml
+++ b/src/tools/miri/etc/rust_analyzer_helix.toml
@@ -27,7 +27,6 @@ invocationStrategy = "once"
 overrideCommand = [
     "./miri",
     "check",
-    "--no-default-features",
     "-Zunstable-options",
     "--compile-time-deps",
     "--message-format=json",
diff --git a/src/tools/miri/etc/rust_analyzer_vscode.json b/src/tools/miri/etc/rust_analyzer_vscode.json
index 97ba212f8ef9..e82c648f59ab 100644
--- a/src/tools/miri/etc/rust_analyzer_vscode.json
+++ b/src/tools/miri/etc/rust_analyzer_vscode.json
@@ -21,7 +21,6 @@
     "rust-analyzer.cargo.buildScripts.overrideCommand": [
         "./miri",
         "check",
-        "--no-default-features",
         "-Zunstable-options",
         "--compile-time-deps",
         "--message-format=json",
diff --git a/src/tools/miri/etc/rust_analyzer_zed.json b/src/tools/miri/etc/rust_analyzer_zed.json
index 7f60a931c46f..e5ff400e989e 100644
--- a/src/tools/miri/etc/rust_analyzer_zed.json
+++ b/src/tools/miri/etc/rust_analyzer_zed.json
@@ -30,7 +30,6 @@
                         "overrideCommand": [
                             "./miri",
                             "check",
-                            "--no-default-features",
                             "-Zunstable-options",
                             "--compile-time-deps",
                             "--message-format=json"
diff --git a/src/tools/miri/genmc-sys/Cargo.toml b/src/tools/miri/genmc-sys/Cargo.toml
index 6443ecd969df..37fcc58070a3 100644
--- a/src/tools/miri/genmc-sys/Cargo.toml
+++ b/src/tools/miri/genmc-sys/Cargo.toml
@@ -13,3 +13,6 @@ cc = "1.2.16"
 cmake = "0.1.54"
 git2 = { version = "0.20.2", default-features = false, features = ["https"] }
 cxx-build = { version = "1.0.173", features = ["parallel"] }
+
+[features]
+check_only = []
diff --git a/src/tools/miri/genmc-sys/build.rs b/src/tools/miri/genmc-sys/build.rs
index a22e3341d67a..4fc3ce94fb8b 100644
--- a/src/tools/miri/genmc-sys/build.rs
+++ b/src/tools/miri/genmc-sys/build.rs
@@ -202,6 +202,11 @@ fn compile_cpp_dependencies(genmc_path: &Path, always_configure: bool) {
 }
 
 fn main() {
+    // For check-only builds, we don't need to do anything.
+    if cfg!(feature = "check_only") {
+        return;
+    }
+
     // Select which path to use for the GenMC repo:
     let (genmc_path, always_configure) = if let Some(genmc_src_path) = option_env!("GENMC_SRC_PATH")
     {
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index 5a8bf76befd6..86f6253d4558 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -391,7 +391,8 @@ impl Command {
         Ok(())
     }
 
-    fn check(features: Vec<String>, flags: Vec<String>) -> Result<()> {
+    fn check(mut features: Vec<String>, flags: Vec<String>) -> Result<()> {
+        features.push("check_only".into());
         let e = MiriEnv::new()?;
         e.check(".", &features, &flags)?;
         e.check("cargo-miri", &[], &flags)?;
@@ -405,7 +406,8 @@ impl Command {
         Ok(())
     }
 
-    fn clippy(features: Vec<String>, flags: Vec<String>) -> Result<()> {
+    fn clippy(mut features: Vec<String>, flags: Vec<String>) -> Result<()> {
+        features.push("check_only".into());
         let e = MiriEnv::new()?;
         e.clippy(".", &features, &flags)?;
         e.clippy("cargo-miri", &[], &flags)?;
diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index d32b6d0d2fc7..c44422d758c5 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-7fefa09b90ca57b8a0e0e4717d672d38a0ae58b5
+f57b9e6f565a1847e83a63f3e90faa3870536c1f
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 05d3444a4eb1..fed51ed86433 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -12,6 +12,7 @@ use rustc_middle::ty::TyCtxt;
 
 pub use self::address_generator::AddressGenerator;
 use self::reuse_pool::ReusePool;
+use crate::alloc::MiriAllocParams;
 use crate::concurrency::VClock;
 use crate::diagnostics::SpanDedupDiagnostic;
 use crate::*;
@@ -162,18 +163,28 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         this.get_alloc_bytes_unchecked_raw(alloc_id)?
                     }
                 }
-                AllocKind::Function | AllocKind::VTable => {
-                    // Allocate some dummy memory to get a unique address for this function/vtable.
-                    let alloc_bytes = MiriAllocBytes::from_bytes(
-                        &[0u8; 1],
-                        Align::from_bytes(1).unwrap(),
-                        params,
-                    );
-                    let ptr = alloc_bytes.as_ptr();
-                    // Leak the underlying memory to ensure it remains unique.
-                    std::mem::forget(alloc_bytes);
-                    ptr
+                #[cfg(all(unix, feature = "native-lib"))]
+                AllocKind::Function => {
+                    if let Some(GlobalAlloc::Function { instance, .. }) =
+                        this.tcx.try_get_global_alloc(alloc_id)
+                    {
+                        let fn_sig = this.tcx.fn_sig(instance.def_id()).skip_binder().skip_binder();
+                        let fn_ptr = crate::shims::native_lib::build_libffi_closure(this, fn_sig)?;
+
+                        #[expect(
+                            clippy::as_conversions,
+                            reason = "No better way to cast a function ptr to a ptr"
+                        )]
+                        {
+                            fn_ptr as *const _
+                        }
+                    } else {
+                        dummy_alloc(params)
+                    }
                 }
+                #[cfg(not(all(unix, feature = "native-lib")))]
+                AllocKind::Function => dummy_alloc(params),
+                AllocKind::VTable => dummy_alloc(params),
                 AllocKind::TypeId | AllocKind::Dead => unreachable!(),
             };
             // We don't have to expose this pointer yet, we do that in `prepare_for_native_call`.
@@ -205,6 +216,15 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 }
 
+fn dummy_alloc(params: MiriAllocParams) -> *const u8 {
+    // Allocate some dummy memory to get a unique address for this function/vtable.
+    let alloc_bytes = MiriAllocBytes::from_bytes(&[0u8; 1], Align::from_bytes(1).unwrap(), params);
+    let ptr = alloc_bytes.as_ptr();
+    // Leak the underlying memory to ensure it remains unique.
+    std::mem::forget(alloc_bytes);
+    ptr
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     // Returns the `AllocId` that corresponds to the specified addr,
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 1f87ac60c17a..64c7096fc5c2 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -138,7 +138,6 @@ pub enum NonHaltingDiagnostic {
     NativeCallSharedMem {
         tracing: bool,
     },
-    NativeCallFnPtr,
     WeakMemoryOutdatedLoad {
         ptr: Pointer,
     },
@@ -643,11 +642,6 @@ impl<'tcx> MiriMachine<'tcx> {
             Int2Ptr { .. } => ("integer-to-pointer cast".to_string(), DiagLevel::Warning),
             NativeCallSharedMem { .. } =>
                 ("sharing memory with a native function".to_string(), DiagLevel::Warning),
-            NativeCallFnPtr =>
-                (
-                    "sharing a function pointer with a native function".to_string(),
-                    DiagLevel::Warning,
-                ),
             ExternTypeReborrow =>
                 ("reborrow of reference to `extern type`".to_string(), DiagLevel::Warning),
             GenmcCompareExchangeWeak | GenmcCompareExchangeOrderingMismatch { .. } =>
@@ -686,8 +680,6 @@ impl<'tcx> MiriMachine<'tcx> {
             Int2Ptr { .. } => format!("integer-to-pointer cast"),
             NativeCallSharedMem { .. } =>
                 format!("sharing memory with a native function called via FFI"),
-            NativeCallFnPtr =>
-                format!("sharing a function pointer with a native function called via FFI"),
             WeakMemoryOutdatedLoad { ptr } =>
                 format!("weak memory emulation: outdated value returned from load at {ptr}"),
             ExternTypeReborrow =>
@@ -785,11 +777,6 @@ impl<'tcx> MiriMachine<'tcx> {
                         ),
                     ]
                 },
-            NativeCallFnPtr => {
-                vec![note!(
-                    "calling Rust functions from C is not supported and will, in the best case, crash the program"
-                )]
-            }
             ExternTypeReborrow => {
                 assert!(self.borrow_tracker.as_ref().is_some_and(|b| {
                     matches!(
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 502cdbdc57b3..f17bd5ac4319 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -599,6 +599,9 @@ pub struct MiriMachine<'tcx> {
     pub native_lib: Vec<(libloading::Library, std::path::PathBuf)>,
     #[cfg(not(all(unix, feature = "native-lib")))]
     pub native_lib: Vec<!>,
+    /// A memory location for exchanging the current `ecx` pointer with native code.
+    #[cfg(all(unix, feature = "native-lib"))]
+    pub native_lib_ecx_interchange: &'static Cell<usize>,
 
     /// Run a garbage collector for BorTags every N basic blocks.
     pub(crate) gc_interval: u32,
@@ -790,6 +793,8 @@ impl<'tcx> MiriMachine<'tcx> {
                     lib_file_path.clone(),
                 )
             }).collect(),
+            #[cfg(all(unix, feature = "native-lib"))]
+            native_lib_ecx_interchange: Box::leak(Box::new(Cell::new(0))),
             #[cfg(not(all(unix, feature = "native-lib")))]
             native_lib: config.native_lib.iter().map(|_| {
                 panic!("calling functions from native libraries via FFI is not supported in this build of Miri")
@@ -1026,6 +1031,8 @@ impl VisitProvenance for MiriMachine<'_> {
             report_progress: _,
             basic_block_count: _,
             native_lib: _,
+            #[cfg(all(unix, feature = "native-lib"))]
+            native_lib_ecx_interchange: _,
             gc_interval: _,
             since_gc: _,
             num_cpus: _,
diff --git a/src/tools/miri/src/shims/env.rs b/src/tools/miri/src/shims/env.rs
index 6915924f2a48..7c463983320b 100644
--- a/src/tools/miri/src/shims/env.rs
+++ b/src/tools/miri/src/shims/env.rs
@@ -119,9 +119,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let this = self.eval_context_ref();
         let index = thread.to_u32();
         let target_os = &this.tcx.sess.target.os;
-        if matches!(target_os, Os::Linux | Os::NetBsd) {
-            // On Linux, the main thread has PID == TID so we uphold this. NetBSD also appears
-            // to exhibit the same behavior, though I can't find a citation.
+        if matches!(target_os, Os::Linux | Os::Android) {
+            // On Linux, the main thread has PID == TID so we uphold this.
             this.get_pid().strict_add(index)
         } else {
             // Other platforms do not display any relationship between PID and TID.
diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs
index f86933029341..694a5922b799 100644
--- a/src/tools/miri/src/shims/files.rs
+++ b/src/tools/miri/src/shims/files.rs
@@ -249,6 +249,15 @@ impl FileDescription for io::Stdin {
         finish.call(ecx, result)
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn is_tty(&self, communicate_allowed: bool) -> bool {
         communicate_allowed && self.is_terminal()
     }
@@ -279,6 +288,15 @@ impl FileDescription for io::Stdout {
         finish.call(ecx, result)
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn is_tty(&self, communicate_allowed: bool) -> bool {
         communicate_allowed && self.is_terminal()
     }
@@ -289,6 +307,15 @@ impl FileDescription for io::Stderr {
         "stderr"
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn write<'tcx>(
         self: FileDescriptionRef<Self>,
         _communicate_allowed: bool,
@@ -436,6 +463,15 @@ impl FileDescription for NullOutput {
         // We just don't write anything, but report to the user that we did.
         finish.call(ecx, Ok(len))
     }
+
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
 }
 
 /// Internal type of a file-descriptor - this is what [`FdTable`] expects
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index e51ace2fd907..345e16b8da71 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -6,7 +6,7 @@ mod backtrace;
 mod files;
 mod math;
 #[cfg(all(unix, feature = "native-lib"))]
-mod native_lib;
+pub mod native_lib;
 mod unix;
 mod windows;
 mod x86;
diff --git a/src/tools/miri/src/shims/native_lib/ffi.rs b/src/tools/miri/src/shims/native_lib/ffi.rs
deleted file mode 100644
index 196f43c6f6a6..000000000000
--- a/src/tools/miri/src/shims/native_lib/ffi.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//! Support code for dealing with libffi.
-
-use libffi::low::CodePtr;
-use libffi::middle::{Arg as ArgPtr, Cif, Type as FfiType};
-
-/// Perform the actual FFI call.
-///
-/// # Safety
-///
-/// The safety invariants of the foreign function being called must be upheld (if any).
-pub unsafe fn call<R: libffi::high::CType>(fun: CodePtr, args: &mut [OwnedArg]) -> R {
-    let cif = Cif::new(args.iter_mut().map(|arg| arg.ty.take().unwrap()), R::reify().into_middle());
-    let arg_ptrs: Vec<_> = args.iter().map(|arg| ArgPtr::new(&*arg.bytes)).collect();
-    // SAFETY: Caller upholds that the function is safe to call.
-    unsafe { cif.call(fun, &arg_ptrs) }
-}
-
-/// An argument for an FFI call.
-#[derive(Debug, Clone)]
-pub struct OwnedArg {
-    /// The type descriptor for this argument.
-    ty: Option<FfiType>,
-    /// Corresponding bytes for the value.
-    bytes: Box<[u8]>,
-}
-
-impl OwnedArg {
-    /// Instantiates an argument from a type descriptor and bytes.
-    pub fn new(ty: FfiType, bytes: Box<[u8]>) -> Self {
-        Self { ty: Some(ty), bytes }
-    }
-}
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 12abe841c052..8a761855c432 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -1,20 +1,22 @@
 //! Implements calling functions from a native library.
 
+use std::cell::Cell;
+use std::marker::PhantomData;
 use std::ops::Deref;
+use std::os::raw::c_void;
+use std::ptr;
 use std::sync::atomic::AtomicBool;
 
 use libffi::low::CodePtr;
 use libffi::middle::Type as FfiType;
 use rustc_abi::{HasDataLayout, Size};
 use rustc_data_structures::either;
-use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout};
-use rustc_middle::ty::{self, FloatTy, IntTy, Ty, UintTy};
+use rustc_middle::ty::layout::TyAndLayout;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::Symbol;
 use serde::{Deserialize, Serialize};
 
-use self::helpers::ToSoft;
-
-mod ffi;
+use crate::*;
 
 #[cfg_attr(
     not(all(
@@ -26,8 +28,21 @@ mod ffi;
 )]
 pub mod trace;
 
-use self::ffi::OwnedArg;
-use crate::*;
+/// An argument for an FFI call.
+#[derive(Debug, Clone)]
+pub struct OwnedArg {
+    /// The type descriptor for this argument.
+    ty: Option<FfiType>,
+    /// Corresponding bytes for the value.
+    bytes: Box<[u8]>,
+}
+
+impl OwnedArg {
+    /// Instantiates an argument from a type descriptor and bytes.
+    pub fn new(ty: FfiType, bytes: Box<[u8]>) -> Self {
+        Self { ty: Some(ty), bytes }
+    }
+}
 
 /// The final results of an FFI trace, containing every relevant event detected
 /// by the tracer.
@@ -76,98 +91,38 @@ impl AccessRange {
 
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
-    /// Call native host function and return the output as an immediate.
-    fn call_native_with_args(
+    /// Call native host function and return the output and the memory accesses
+    /// that occurred during the call.
+    fn call_native_raw(
         &mut self,
-        link_name: Symbol,
-        dest: &MPlaceTy<'tcx>,
         fun: CodePtr,
-        libffi_args: &mut [OwnedArg],
-    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
+        args: &mut [OwnedArg],
+        ret: (FfiType, Size),
+    ) -> InterpResult<'tcx, (Box<[u8]>, Option<MemEvents>)> {
         let this = self.eval_context_mut();
         #[cfg(target_os = "linux")]
-        let alloc = this.machine.allocator.as_ref().unwrap();
+        let alloc = this.machine.allocator.as_ref().unwrap().clone();
         #[cfg(not(target_os = "linux"))]
         // Placeholder value.
         let alloc = ();
 
-        trace::Supervisor::do_ffi(alloc, || {
-            // Call the function (`ptr`) with arguments `libffi_args`, and obtain the return value
-            // as the specified primitive integer type
-            let scalar = match dest.layout.ty.kind() {
-                // ints
-                ty::Int(IntTy::I8) => {
-                    // Unsafe because of the call to native code.
-                    // Because this is calling a C function it is not necessarily sound,
-                    // but there is no way around this and we've checked as much as we can.
-                    let x = unsafe { ffi::call::<i8>(fun, libffi_args) };
-                    Scalar::from_i8(x)
-                }
-                ty::Int(IntTy::I16) => {
-                    let x = unsafe { ffi::call::<i16>(fun, libffi_args) };
-                    Scalar::from_i16(x)
-                }
-                ty::Int(IntTy::I32) => {
-                    let x = unsafe { ffi::call::<i32>(fun, libffi_args) };
-                    Scalar::from_i32(x)
-                }
-                ty::Int(IntTy::I64) => {
-                    let x = unsafe { ffi::call::<i64>(fun, libffi_args) };
-                    Scalar::from_i64(x)
-                }
-                ty::Int(IntTy::Isize) => {
-                    let x = unsafe { ffi::call::<isize>(fun, libffi_args) };
-                    Scalar::from_target_isize(x.try_into().unwrap(), this)
-                }
-                // uints
-                ty::Uint(UintTy::U8) => {
-                    let x = unsafe { ffi::call::<u8>(fun, libffi_args) };
-                    Scalar::from_u8(x)
-                }
-                ty::Uint(UintTy::U16) => {
-                    let x = unsafe { ffi::call::<u16>(fun, libffi_args) };
-                    Scalar::from_u16(x)
-                }
-                ty::Uint(UintTy::U32) => {
-                    let x = unsafe { ffi::call::<u32>(fun, libffi_args) };
-                    Scalar::from_u32(x)
-                }
-                ty::Uint(UintTy::U64) => {
-                    let x = unsafe { ffi::call::<u64>(fun, libffi_args) };
-                    Scalar::from_u64(x)
-                }
-                ty::Uint(UintTy::Usize) => {
-                    let x = unsafe { ffi::call::<usize>(fun, libffi_args) };
-                    Scalar::from_target_usize(x.try_into().unwrap(), this)
-                }
-                ty::Float(FloatTy::F32) => {
-                    let x = unsafe { ffi::call::<f32>(fun, libffi_args) };
-                    Scalar::from_f32(x.to_soft())
-                }
-                ty::Float(FloatTy::F64) => {
-                    let x = unsafe { ffi::call::<f64>(fun, libffi_args) };
-                    Scalar::from_f64(x.to_soft())
-                }
-                // Functions with no declared return type (i.e., the default return)
-                // have the output_type `Tuple([])`.
-                ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
-                    unsafe { ffi::call::<()>(fun, libffi_args) };
-                    return interp_ok(ImmTy::uninit(dest.layout));
-                }
-                ty::RawPtr(ty, ..) if ty.is_sized(*this.tcx, this.typing_env()) => {
-                    let x = unsafe { ffi::call::<*const ()>(fun, libffi_args) };
-                    let ptr = StrictPointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
-                    Scalar::from_pointer(ptr, this)
-                }
-                _ =>
-                    return Err(err_unsup_format!(
-                        "unsupported return type for native call: {:?}",
-                        link_name
-                    ))
-                    .into(),
-            };
-            interp_ok(ImmTy::from_scalar(scalar, dest.layout))
-        })
+        // Expose InterpCx for use by closure callbacks.
+        this.machine.native_lib_ecx_interchange.set(ptr::from_mut(this).expose_provenance());
+
+        let res = trace::Supervisor::do_ffi(&alloc, || {
+            use libffi::middle::{Arg, Cif, Ret};
+
+            let cif = Cif::new(args.iter_mut().map(|arg| arg.ty.take().unwrap()), ret.0);
+            let arg_ptrs: Vec<_> = args.iter().map(|arg| Arg::new(&*arg.bytes)).collect();
+            let mut ret = vec![0u8; ret.1.bytes_usize()];
+
+            unsafe { cif.call_return_into(fun, &arg_ptrs, Ret::new::<[u8]>(&mut *ret)) };
+            ret.into()
+        });
+
+        this.machine.native_lib_ecx_interchange.set(0);
+
+        res
     }
 
     /// Get the pointer to the function of the specified name in the shared object file,
@@ -381,6 +336,30 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(OwnedArg::new(ty, bytes))
     }
 
+    fn ffi_ret_to_mem(&mut self, v: Box<[u8]>, dest: &MPlaceTy<'tcx>) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let len = v.len();
+        this.write_bytes_ptr(dest.ptr(), v)?;
+        if len == 0 {
+            return interp_ok(());
+        }
+        // We have no idea which provenance these bytes have, so we reset it to wildcard.
+        let tcx = this.tcx;
+        let (alloc_id, offset, _) = this.ptr_try_get_alloc_id(dest.ptr(), 0).unwrap();
+        let alloc = this.get_alloc_raw_mut(alloc_id)?.0;
+        alloc.process_native_write(&tcx, Some(alloc_range(offset, dest.layout.size)));
+        // Run the validation that would usually be part of `return`, also to reset
+        // any provenance and padding that would not survive the return.
+        if MiriMachine::enforce_validity(this, dest.layout) {
+            this.validate_operand(
+                &dest.clone().into(),
+                MiriMachine::enforce_validity_recursively(this, dest.layout),
+                /*reset_provenance_and_padding*/ true,
+            )?;
+        }
+        interp_ok(())
+    }
+
     /// Parses an ADT to construct the matching libffi type.
     fn adt_to_ffitype(
         &self,
@@ -388,6 +367,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         adt_def: ty::AdtDef<'tcx>,
         args: &'tcx ty::List<ty::GenericArg<'tcx>>,
     ) -> InterpResult<'tcx, FfiType> {
+        let this = self.eval_context_ref();
         // TODO: unions, etc.
         if !adt_def.is_struct() {
             throw_unsup_format!("passing an enum or union over FFI: {orig_ty}");
@@ -397,7 +377,6 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             throw_unsup_format!("passing a non-#[repr(C)] {} over FFI: {orig_ty}", adt_def.descr())
         }
 
-        let this = self.eval_context_ref();
         let mut fields = vec![];
         for field in &adt_def.non_enum_variant().fields {
             let layout = this.layout_of(field.ty(*this.tcx, args))?;
@@ -429,21 +408,92 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 Primitive::Float(Float::F32) => FfiType::f32(),
                 Primitive::Float(Float::F64) => FfiType::f64(),
                 Primitive::Pointer(AddressSpace::ZERO) => FfiType::pointer(),
-                _ =>
-                    throw_unsup_format!(
-                        "unsupported scalar argument type for native call: {}",
-                        layout.ty
-                    ),
+                _ => throw_unsup_format!("unsupported scalar type for native call: {}", layout.ty),
             });
         }
         interp_ok(match layout.ty.kind() {
             // Scalar types have already been handled above.
             ty::Adt(adt_def, args) => self.adt_to_ffitype(layout.ty, *adt_def, args)?,
-            _ => throw_unsup_format!("unsupported argument type for native call: {}", layout.ty),
+            // Rust uses `()` as return type for `void` function, which becomes `Tuple([])`.
+            ty::Tuple(t_list) if t_list.len() == 0 => FfiType::void(),
+            _ => {
+                throw_unsup_format!("unsupported type for native call: {}", layout.ty)
+            }
         })
     }
 }
 
+/// The data passed to the closure shim function used to intercept function pointer calls from
+/// native code.
+struct LibffiClosureData<'tcx> {
+    ecx_interchange: &'static Cell<usize>,
+    marker: PhantomData<MiriInterpCx<'tcx>>,
+}
+
+/// This function sets up a new libffi closure to intercept
+/// calls to rust code via function pointers passed to native code.
+///
+/// Calling this function leaks the data passed into the libffi closure as
+/// these need to be available until the execution terminates as the native
+/// code side could store a function pointer and only call it at a later point.
+pub fn build_libffi_closure<'tcx, 'this>(
+    this: &'this MiriInterpCx<'tcx>,
+    fn_sig: rustc_middle::ty::FnSig<'tcx>,
+) -> InterpResult<'tcx, unsafe extern "C" fn()> {
+    // Compute argument and return types in libffi representation.
+    let mut args = Vec::new();
+    for input in fn_sig.inputs().iter() {
+        let layout = this.layout_of(*input)?;
+        let ty = this.ty_to_ffitype(layout)?;
+        args.push(ty);
+    }
+    let res_type = fn_sig.output();
+    let res_type = {
+        let layout = this.layout_of(res_type)?;
+        this.ty_to_ffitype(layout)?
+    };
+
+    // Build the actual closure.
+    let closure_builder = libffi::middle::Builder::new().args(args).res(res_type);
+    let data = LibffiClosureData {
+        ecx_interchange: this.machine.native_lib_ecx_interchange,
+        marker: PhantomData,
+    };
+    let data = Box::leak(Box::new(data));
+    let closure = closure_builder.into_closure(libffi_closure_callback, data);
+    let closure = Box::leak(Box::new(closure));
+
+    // The actual argument/return type doesn't matter.
+    let fn_ptr = unsafe { closure.instantiate_code_ptr::<unsafe extern "C" fn()>() };
+    // Libffi returns a **reference** to a function ptr here.
+    // Therefore we need to dereference the reference to get the actual function pointer.
+    interp_ok(*fn_ptr)
+}
+
+/// A shim function to intercept calls back from native code into the interpreter
+/// via function pointers passed to the native code.
+///
+/// For now this shim only reports that such constructs are not supported by miri.
+/// As future improvement we might continue execution in the interpreter here.
+unsafe extern "C" fn libffi_closure_callback<'tcx>(
+    _cif: &libffi::low::ffi_cif,
+    _result: &mut c_void,
+    _args: *const *const c_void,
+    data: &LibffiClosureData<'tcx>,
+) {
+    let ecx = unsafe {
+        ptr::with_exposed_provenance_mut::<MiriInterpCx<'tcx>>(data.ecx_interchange.get())
+            .as_mut()
+            .expect("libffi closure called while no FFI call is active")
+    };
+    let err = err_unsup_format!("calling a function pointer through the FFI boundary");
+
+    crate::diagnostics::report_result(ecx, err.into());
+    // We abort the execution at this point as we cannot return the
+    // expected value here.
+    std::process::exit(1);
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Call the native host function, with supplied arguments.
@@ -451,6 +501,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// a native form (through `libffi` call).
     /// Then, convert the return value from the native form into something that
     /// can be stored in Miri's internal memory.
+    ///
+    /// Returns `true` if a call has been made, `false` if no functions of this name was found.
     fn call_native_fn(
         &mut self,
         link_name: Symbol,
@@ -472,18 +524,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         for arg in args.iter() {
             libffi_args.push(this.op_to_ffi_arg(arg, tracing)?);
         }
+        let ret_ty = this.ty_to_ffitype(dest.layout)?;
 
         // Prepare all exposed memory (both previously exposed, and just newly exposed since a
         // pointer was passed as argument). Uninitialised memory is left as-is, but any data
         // exposed this way is garbage anyway.
         this.visit_reachable_allocs(this.exposed_allocs(), |this, alloc_id, info| {
-            if matches!(info.kind, AllocKind::Function) {
-                static DEDUP: AtomicBool = AtomicBool::new(false);
-                if !DEDUP.swap(true, std::sync::atomic::Ordering::Relaxed) {
-                    // Newly set, so first time we get here.
-                    this.emit_diagnostic(NonHaltingDiagnostic::NativeCallFnPtr);
-                }
-            }
             // If there is no data behind this pointer, skip this.
             if !matches!(info.kind, AllocKind::LiveData) {
                 return interp_ok(());
@@ -521,15 +567,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             interp_ok(())
         })?;
 
-        // Call the function and store output, depending on return type in the function signature.
+        // Call the function and store its output.
         let (ret, maybe_memevents) =
-            this.call_native_with_args(link_name, dest, code_ptr, &mut libffi_args)?;
-
+            this.call_native_raw(code_ptr, &mut libffi_args, (ret_ty, dest.layout.size))?;
         if tracing {
             this.tracing_apply_accesses(maybe_memevents.unwrap())?;
         }
-
-        this.write_immediate(*ret, dest)?;
+        this.ffi_ret_to_mem(ret, dest)?;
         interp_ok(true)
     }
 }
diff --git a/src/tools/miri/src/shims/native_lib/trace/child.rs b/src/tools/miri/src/shims/native_lib/trace/child.rs
index 795ad4a32076..021ec2e9aeb3 100644
--- a/src/tools/miri/src/shims/native_lib/trace/child.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/child.rs
@@ -5,7 +5,7 @@ use std::rc::Rc;
 use ipc_channel::ipc;
 use nix::sys::{mman, ptrace, signal};
 use nix::unistd;
-use rustc_const_eval::interpret::InterpResult;
+use rustc_const_eval::interpret::{InterpResult, interp_ok};
 
 use super::CALLBACK_STACK_SIZE;
 use super::messages::{Confirmation, StartFfiInfo, TraceRequest};
@@ -58,16 +58,16 @@ impl Supervisor {
     /// Performs an arbitrary FFI call, enabling tracing from the supervisor.
     /// As this locks the supervisor via a mutex, no other threads may enter FFI
     /// until this function returns.
-    pub fn do_ffi<'tcx>(
+    pub fn do_ffi<'tcx, T>(
         alloc: &Rc<RefCell<IsolatedAlloc>>,
-        f: impl FnOnce() -> InterpResult<'tcx, crate::ImmTy<'tcx>>,
-    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
+        f: impl FnOnce() -> T,
+    ) -> InterpResult<'tcx, (T, Option<MemEvents>)> {
         let mut sv_guard = SUPERVISOR.lock().unwrap();
         // If the supervisor is not initialised for whatever reason, fast-return.
         // As a side-effect, even on platforms where ptracing
         // is not implemented, we enforce that only one FFI call
         // happens at a time.
-        let Some(sv) = sv_guard.as_mut() else { return f().map(|v| (v, None)) };
+        let Some(sv) = sv_guard.as_mut() else { return interp_ok((f(), None)) };
 
         // Get pointers to all the pages the supervisor must allow accesses in
         // and prepare the callback stack.
@@ -147,7 +147,7 @@ impl Supervisor {
             })
             .ok();
 
-        res.map(|v| (v, events))
+        interp_ok((res, events))
     }
 }
 
diff --git a/src/tools/miri/src/shims/native_lib/trace/stub.rs b/src/tools/miri/src/shims/native_lib/trace/stub.rs
index 22787a6f6fa7..a3f6c616301c 100644
--- a/src/tools/miri/src/shims/native_lib/trace/stub.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/stub.rs
@@ -1,4 +1,4 @@
-use rustc_const_eval::interpret::InterpResult;
+use rustc_const_eval::interpret::{InterpResult, interp_ok};
 
 static SUPERVISOR: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
@@ -13,13 +13,13 @@ impl Supervisor {
         false
     }
 
-    pub fn do_ffi<'tcx, T>(
+    pub fn do_ffi<'tcx, T, U>(
         _: T,
-        f: impl FnOnce() -> InterpResult<'tcx, crate::ImmTy<'tcx>>,
-    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<super::MemEvents>)> {
+        f: impl FnOnce() -> U,
+    ) -> InterpResult<'tcx, (U, Option<super::MemEvents>)> {
         // We acquire the lock to ensure that no two FFI calls run concurrently.
         let _g = SUPERVISOR.lock().unwrap();
-        f().map(|v| (v, None))
+        interp_ok((f(), None))
     }
 }
 
diff --git a/src/tools/miri/src/shims/unix/android/foreign_items.rs b/src/tools/miri/src/shims/unix/android/foreign_items.rs
index 6cb0d221fc03..2b290b68c78c 100644
--- a/src/tools/miri/src/shims/unix/android/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/android/foreign_items.rs
@@ -8,6 +8,7 @@ use crate::shims::unix::env::EvalContextExt as _;
 use crate::shims::unix::linux_like::epoll::EvalContextExt as _;
 use crate::shims::unix::linux_like::eventfd::EvalContextExt as _;
 use crate::shims::unix::linux_like::syscall::syscall;
+use crate::shims::unix::*;
 use crate::*;
 
 pub fn is_dyn_sym(name: &str) -> bool {
@@ -25,6 +26,74 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
         match link_name.as_str() {
+            // File related shims
+            "stat" => {
+                let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let result = this.stat(path, buf)?;
+                this.write_scalar(result, dest)?;
+            }
+            "lstat" => {
+                let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let result = this.lstat(path, buf)?;
+                this.write_scalar(result, dest)?;
+            }
+            "readdir" => {
+                let [dirp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let result = this.readdir64("dirent", dirp)?;
+                this.write_scalar(result, dest)?;
+            }
+            "pread64" => {
+                let [fd, buf, count, offset] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, usize, libc::off64_t) -> isize),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let fd = this.read_scalar(fd)?.to_i32()?;
+                let buf = this.read_pointer(buf)?;
+                let count = this.read_target_usize(count)?;
+                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
+                this.read(fd, buf, count, Some(offset), dest)?;
+            }
+            "pwrite64" => {
+                let [fd, buf, n, offset] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *const _, usize, libc::off64_t) -> isize),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let fd = this.read_scalar(fd)?.to_i32()?;
+                let buf = this.read_pointer(buf)?;
+                let count = this.read_target_usize(n)?;
+                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
+                trace!("Called pwrite64({:?}, {:?}, {:?}, {:?})", fd, buf, count, offset);
+                this.write(fd, buf, count, Some(offset), dest)?;
+            }
+            "lseek64" => {
+                let [fd, offset, whence] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, libc::off64_t, i32) -> libc::off64_t),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let fd = this.read_scalar(fd)?.to_i32()?;
+                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
+                let whence = this.read_scalar(whence)?.to_i32()?;
+                this.lseek64(fd, offset, whence, dest)?;
+            }
+            "ftruncate64" => {
+                let [fd, length] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, libc::off64_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let fd = this.read_scalar(fd)?.to_i32()?;
+                let length = this.read_scalar(length)?.to_int(length.layout.size)?;
+                let result = this.ftruncate64(fd, length)?;
+                this.write_scalar(result, dest)?;
+            }
+
             // epoll, eventfd
             "epoll_create1" => {
                 let [flag] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 64b8376ff4aa..8eacdc3583d4 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -510,7 +510,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             "pipe2" => {
                 // Currently this function does not exist on all Unixes, e.g. on macOS.
                 this.check_target_os(
-                    &[Os::Linux, Os::FreeBsd, Os::Solaris, Os::Illumos],
+                    &[Os::Linux, Os::Android, Os::FreeBsd, Os::Solaris, Os::Illumos],
                     link_name,
                 )?;
                 let [pipefd, flags] = this.check_shim_sig(
diff --git a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
index c48301c72416..fb2d3f758420 100644
--- a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
@@ -140,12 +140,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // since freebsd 12 the former form can be expected.
             "stat" | "stat@FBSD_1.0" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_stat(path, buf)?;
+                let result = this.stat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "lstat" | "lstat@FBSD_1.0" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_lstat(path, buf)?;
+                let result = this.lstat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "fstat@FBSD_1.0" => {
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index e17456c3bc0e..f43fd3fe2d18 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -527,15 +527,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(Scalar::from_i32(this.try_unwrap_io_result(result)?))
     }
 
-    fn macos_fbsd_solarish_stat(
-        &mut self,
-        path_op: &OpTy<'tcx>,
-        buf_op: &OpTy<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
+    fn stat(&mut self, path_op: &OpTy<'tcx>, buf_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos)
-        {
+        if !matches!(
+            &this.tcx.sess.target.os,
+            Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos | Os::Android
+        ) {
             panic!("`macos_fbsd_solaris_stat` should not be called on {}", this.tcx.sess.target.os);
         }
 
@@ -558,15 +556,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     // `lstat` is used to get symlink metadata.
-    fn macos_fbsd_solarish_lstat(
-        &mut self,
-        path_op: &OpTy<'tcx>,
-        buf_op: &OpTy<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
+    fn lstat(&mut self, path_op: &OpTy<'tcx>, buf_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos)
-        {
+        if !matches!(
+            &this.tcx.sess.target.os,
+            Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos | Os::Android
+        ) {
             panic!(
                 "`macos_fbsd_solaris_lstat` should not be called on {}",
                 this.tcx.sess.target.os
@@ -595,7 +591,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         if !matches!(
             &this.tcx.sess.target.os,
-            Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos | Os::Linux
+            Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos | Os::Linux | Os::Android
         ) {
             panic!("`fstat` should not be called on {}", this.tcx.sess.target.os);
         }
@@ -906,9 +902,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn readdir64(&mut self, dirent_type: &str, dirp_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        if !matches!(&this.tcx.sess.target.os, Os::Linux | Os::Solaris | Os::Illumos | Os::FreeBsd)
-        {
-            panic!("`linux_solaris_readdir64` should not be called on {}", this.tcx.sess.target.os);
+        if !matches!(
+            &this.tcx.sess.target.os,
+            Os::Linux | Os::Android | Os::Solaris | Os::Illumos | Os::FreeBsd
+        ) {
+            panic!("`readdir64` should not be called on {}", this.tcx.sess.target.os);
         }
 
         let dirp = this.read_target_usize(dirp_op)?;
diff --git a/src/tools/miri/src/shims/unix/macos/foreign_items.rs b/src/tools/miri/src/shims/unix/macos/foreign_items.rs
index dd7b95bdc82b..f798f64441b1 100644
--- a/src/tools/miri/src/shims/unix/macos/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/macos/foreign_items.rs
@@ -48,12 +48,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             "stat" | "stat$INODE64" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_stat(path, buf)?;
+                let result = this.stat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "lstat" | "lstat$INODE64" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_lstat(path, buf)?;
+                let result = this.lstat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "fstat$INODE64" => {
diff --git a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
index ae7230877a71..fa8c86b025a7 100644
--- a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
@@ -92,12 +92,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // File related shims
             "stat" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_stat(path, buf)?;
+                let result = this.stat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "lstat" => {
                 let [path, buf] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.macos_fbsd_solarish_lstat(path, buf)?;
+                let result = this.lstat(path, buf)?;
                 this.write_scalar(result, dest)?;
             }
             "readdir" => {
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index a320ac131689..cc371b43a681 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -459,7 +459,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Interpret the flag. Every flag we recognize is "subtracted" from `flags`, so
         // if there is anything left at the end, that's an unsupported flag.
-        if this.tcx.sess.target.os == Os::Linux {
+        if matches!(this.tcx.sess.target.os, Os::Linux | Os::Android) {
             // SOCK_NONBLOCK only exists on Linux.
             let sock_nonblock = this.eval_libc_i32("SOCK_NONBLOCK");
             let sock_cloexec = this.eval_libc_i32("SOCK_CLOEXEC");
diff --git a/src/tools/miri/src/shims/x86/avx2.rs b/src/tools/miri/src/shims/x86/avx2.rs
index b089a0249bd7..97b9f649c158 100644
--- a/src/tools/miri/src/shims/x86/avx2.rs
+++ b/src/tools/miri/src/shims/x86/avx2.rs
@@ -224,6 +224,42 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 shift_simd_by_scalar(this, left, right, which, dest)?;
             }
+            // Used to implement the _mm256_madd_epi16 function.
+            // Multiplies packed signed 16-bit integers in `left` and `right`, producing
+            // intermediate signed 32-bit integers. Horizontally add adjacent pairs of
+            // intermediate 32-bit integers, and pack the results in `dest`.
+            "pmadd.wd" => {
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(dest_len.strict_mul(2), left_len);
+
+                for i in 0..dest_len {
+                    let j1 = i.strict_mul(2);
+                    let left1 = this.read_scalar(&this.project_index(&left, j1)?)?.to_i16()?;
+                    let right1 = this.read_scalar(&this.project_index(&right, j1)?)?.to_i16()?;
+
+                    let j2 = j1.strict_add(1);
+                    let left2 = this.read_scalar(&this.project_index(&left, j2)?)?.to_i16()?;
+                    let right2 = this.read_scalar(&this.project_index(&right, j2)?)?.to_i16()?;
+
+                    let dest = this.project_index(&dest, i)?;
+
+                    // Multiplications are i16*i16->i32, which will not overflow.
+                    let mul1 = i32::from(left1).strict_mul(right1.into());
+                    let mul2 = i32::from(left2).strict_mul(right2.into());
+                    // However, this addition can overflow in the most extreme case
+                    // (-0x8000)*(-0x8000)+(-0x8000)*(-0x8000) = 0x80000000
+                    let res = mul1.wrapping_add(mul2);
+
+                    this.write_scalar(Scalar::from_i32(res), &dest)?;
+                }
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
diff --git a/src/tools/miri/src/shims/x86/avx512.rs b/src/tools/miri/src/shims/x86/avx512.rs
index a886f5622ced..0466ba1bd6c0 100644
--- a/src/tools/miri/src/shims/x86/avx512.rs
+++ b/src/tools/miri/src/shims/x86/avx512.rs
@@ -109,8 +109,66 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 pshufb(this, left, right, dest)?;
             }
+
+            // Used to implement the _mm512_dpbusd_epi32 function.
+            "vpdpbusd.512" | "vpdpbusd.256" | "vpdpbusd.128" => {
+                this.expect_target_feature_for_intrinsic(link_name, "avx512vnni")?;
+                if matches!(unprefixed_name, "vpdpbusd.128" | "vpdpbusd.256") {
+                    this.expect_target_feature_for_intrinsic(link_name, "avx512vl")?;
+                }
+
+                let [src, a, b] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                vpdpbusd(this, src, a, b, dest)?;
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
     }
 }
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in `a` with corresponding signed
+/// 8-bit integers in `b`, producing 4 intermediate signed 16-bit results. Sum these 4 results with
+/// the corresponding 32-bit integer in `src` (using wrapping arighmetic), and store the packed
+/// 32-bit results in `dst`.
+///
+/// <https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_dpbusd_epi32>
+/// <https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm256_dpbusd_epi32>
+/// <https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm512_dpbusd_epi32>
+fn vpdpbusd<'tcx>(
+    ecx: &mut crate::MiriInterpCx<'tcx>,
+    src: &OpTy<'tcx>,
+    a: &OpTy<'tcx>,
+    b: &OpTy<'tcx>,
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx, ()> {
+    let (src, src_len) = ecx.project_to_simd(src)?;
+    let (a, a_len) = ecx.project_to_simd(a)?;
+    let (b, b_len) = ecx.project_to_simd(b)?;
+    let (dest, dest_len) = ecx.project_to_simd(dest)?;
+
+    // fn vpdpbusd(src: i32x16, a: i32x16, b: i32x16) -> i32x16;
+    // fn vpdpbusd256(src: i32x8, a: i32x8, b: i32x8) -> i32x8;
+    // fn vpdpbusd128(src: i32x4, a: i32x4, b: i32x4) -> i32x4;
+    assert_eq!(dest_len, src_len);
+    assert_eq!(dest_len, a_len);
+    assert_eq!(dest_len, b_len);
+
+    for i in 0..dest_len {
+        let src = ecx.read_scalar(&ecx.project_index(&src, i)?)?.to_i32()?;
+        let a = ecx.read_scalar(&ecx.project_index(&a, i)?)?.to_u32()?;
+        let b = ecx.read_scalar(&ecx.project_index(&b, i)?)?.to_u32()?;
+        let dest = ecx.project_index(&dest, i)?;
+
+        let zipped = a.to_le_bytes().into_iter().zip(b.to_le_bytes());
+        let intermediate_sum: i32 = zipped
+            .map(|(a, b)| i32::from(a).strict_mul(i32::from(b.cast_signed())))
+            .fold(0, |x, y| x.strict_add(y));
+
+        // Use `wrapping_add` because `src` is an arbitrary i32 and the addition can overflow.
+        let res = Scalar::from_i32(intermediate_sum.wrapping_add(src));
+        ecx.write_scalar(res, &dest)?;
+    }
+
+    interp_ok(())
+}
diff --git a/src/tools/miri/src/shims/x86/sse2.rs b/src/tools/miri/src/shims/x86/sse2.rs
index 838981390307..3fbab9ba789e 100644
--- a/src/tools/miri/src/shims/x86/sse2.rs
+++ b/src/tools/miri/src/shims/x86/sse2.rs
@@ -278,6 +278,42 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.copy_op(&this.project_index(&left, i)?, &this.project_index(&dest, i)?)?;
                 }
             }
+            // Used to implement the _mm_madd_epi16 function.
+            // Multiplies packed signed 16-bit integers in `left` and `right`, producing
+            // intermediate signed 32-bit integers. Horizontally add adjacent pairs of
+            // intermediate 32-bit integers, and pack the results in `dest`.
+            "pmadd.wd" => {
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(dest_len.strict_mul(2), left_len);
+
+                for i in 0..dest_len {
+                    let j1 = i.strict_mul(2);
+                    let left1 = this.read_scalar(&this.project_index(&left, j1)?)?.to_i16()?;
+                    let right1 = this.read_scalar(&this.project_index(&right, j1)?)?.to_i16()?;
+
+                    let j2 = j1.strict_add(1);
+                    let left2 = this.read_scalar(&this.project_index(&left, j2)?)?.to_i16()?;
+                    let right2 = this.read_scalar(&this.project_index(&right, j2)?)?.to_i16()?;
+
+                    let dest = this.project_index(&dest, i)?;
+
+                    // Multiplications are i16*i16->i32, which will not overflow.
+                    let mul1 = i32::from(left1).strict_mul(right1.into());
+                    let mul2 = i32::from(left2).strict_mul(right2.into());
+                    // However, this addition can overflow in the most extreme case
+                    // (-0x8000)*(-0x8000)+(-0x8000)*(-0x8000) = 0x80000000
+                    let res = mul1.wrapping_add(mul2);
+
+                    this.write_scalar(Scalar::from_i32(res), &dest)?;
+                }
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs b/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs
deleted file mode 100644
index 7911133f548f..000000000000
--- a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ignore-target: windows # No libc IO on Windows
-//@compile-flags: -Zmiri-disable-isolation
-
-// FIXME: standard handles cannot be closed (https://github.com/rust-lang/rust/issues/40032)
-
-fn main() {
-    unsafe {
-        libc::close(1); //~ ERROR: cannot close stdout
-    }
-}
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr b/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr
deleted file mode 100644
index 84973ac020de..000000000000
--- a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: unsupported operation: cannot close stdout
-  --> tests/fail-dep/libc/fs/close_stdout.rs:LL:CC
-   |
-LL |         libc::close(1);
-   |         ^^^^^^^^^^^^^^ unsupported operation occurred here
-   |
-   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr b/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
index af55ccfe5e67..09501f98a9aa 100644
--- a/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
+++ b/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
@@ -15,12 +15,12 @@ LL |         let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode a
                at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
            3: std::sys::fs::PLATFORM::File::open::{closure#0}
                at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
-           4: std::sys::pal::PLATFORM::small_c_string::run_with_cstr_stack
-               at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
-           5: std::sys::pal::PLATFORM::small_c_string::run_with_cstr
-               at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
-           6: std::sys::pal::PLATFORM::small_c_string::run_path_with_cstr
-               at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
+           4: std::sys::helpers::small_c_string::run_with_cstr_stack
+               at RUSTLIB/std/src/sys/helpers/small_c_string.rs:LL:CC
+           5: std::sys::helpers::small_c_string::run_with_cstr
+               at RUSTLIB/std/src/sys/helpers/small_c_string.rs:LL:CC
+           6: std::sys::helpers::small_c_string::run_path_with_cstr
+               at RUSTLIB/std/src/sys/helpers/small_c_string.rs:LL:CC
            7: std::sys::fs::PLATFORM::File::open
                at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
            8: std::fs::OpenOptions::_open
diff --git a/src/tools/miri/tests/native-lib/aggregate_arguments.c b/src/tools/miri/tests/native-lib/aggregate_arguments.c
index 8ad687f2aec9..e315642c13a9 100644
--- a/src/tools/miri/tests/native-lib/aggregate_arguments.c
+++ b/src/tools/miri/tests/native-lib/aggregate_arguments.c
@@ -24,6 +24,14 @@ EXPORT int64_t pass_struct(const PassMe pass_me) {
   return pass_me.value + pass_me.other_value;
 }
 
+/* Test: test_return_struct */
+EXPORT PassMe return_struct(int32_t value, int64_t other_value) {
+  struct PassMe ret;
+  ret.value = value;
+  ret.other_value = other_value;
+  return ret;
+}
+
 /* Test: test_pass_struct_complex */
 
 typedef struct Part1 {
diff --git a/src/tools/miri/tests/native-lib/fail/call_function_ptr.notrace.stderr b/src/tools/miri/tests/native-lib/fail/call_function_ptr.notrace.stderr
new file mode 100644
index 000000000000..faabba9ca725
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_function_ptr.notrace.stderr
@@ -0,0 +1,31 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/call_function_ptr.rs:LL:CC
+   |
+LL |         call_fn_ptr(Some(nop));
+   |         ^^^^^^^^^^^^^^^^^^^^^^ sharing memory with a native function
+   |
+   = help: when memory is shared with a native function call, Miri stops tracking initialization and provenance for that memory
+   = help: in particular, Miri assumes that the native call initializes all memory it has access to
+   = help: Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory
+   = help: what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+
+error: unsupported operation: calling a function pointer through the FFI boundary
+  --> tests/native-lib/fail/call_function_ptr.rs:LL:CC
+   |
+LL |         call_fn_ptr(Some(nop));
+   |         ^^^^^^^^^^^^^^^^^^^^^^ unsupported operation occurred here
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
diff --git a/src/tools/miri/tests/native-lib/fail/call_function_ptr.rs b/src/tools/miri/tests/native-lib/fail/call_function_ptr.rs
new file mode 100644
index 000000000000..b68c4d4062b7
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_function_ptr.rs
@@ -0,0 +1,21 @@
+//@revisions: trace notrace
+//@[trace] only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
+//@[trace] compile-flags: -Zmiri-native-lib-enable-tracing
+//@compile-flags: -Zmiri-permissive-provenance
+
+fn main() {
+    pass_fn_ptr()
+}
+
+fn pass_fn_ptr() {
+    extern "C" {
+        fn call_fn_ptr(s: Option<extern "C" fn()>);
+    }
+
+    extern "C" fn nop() {}
+
+    unsafe {
+        call_fn_ptr(None); // this one is fine
+        call_fn_ptr(Some(nop)); //~ ERROR: unsupported operation: calling a function pointer through the FFI boundary
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/call_function_ptr.trace.stderr b/src/tools/miri/tests/native-lib/fail/call_function_ptr.trace.stderr
new file mode 100644
index 000000000000..e56a5ece782b
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_function_ptr.trace.stderr
@@ -0,0 +1,32 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/call_function_ptr.rs:LL:CC
+   |
+LL |         call_fn_ptr(Some(nop));
+   |         ^^^^^^^^^^^^^^^^^^^^^^ sharing memory with a native function
+   |
+   = help: when memory is shared with a native function call, Miri can only track initialisation and provenance on a best-effort basis
+   = help: in particular, Miri assumes that the native call initializes all memory it has written to
+   = help: Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory
+   = help: what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free
+   = help: tracing memory accesses in native code is not yet fully implemented, so there can be further imprecisions beyond what is documented here
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+
+error: unsupported operation: calling a function pointer through the FFI boundary
+  --> tests/native-lib/fail/call_function_ptr.rs:LL:CC
+   |
+LL |         call_fn_ptr(Some(nop));
+   |         ^^^^^^^^^^^^^^^^^^^^^^ unsupported operation occurred here
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_function_ptr.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
diff --git a/src/tools/miri/tests/native-lib/fail/invalid_retval.rs b/src/tools/miri/tests/native-lib/fail/invalid_retval.rs
new file mode 100644
index 000000000000..4967866b7e7f
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/invalid_retval.rs
@@ -0,0 +1,14 @@
+// Only works on Unix targets
+//@ignore-target: windows wasm
+//@only-on-host
+//@normalize-stderr-test: "OS `.*`" -> "$$OS"
+
+extern "C" {
+    fn u8_id(x: u8) -> bool;
+}
+
+fn main() {
+    unsafe {
+        u8_id(2); //~ ERROR: invalid value: encountered 0x02, but expected a boolean
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr b/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr
new file mode 100644
index 000000000000..9db29822d4f5
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr
@@ -0,0 +1,13 @@
+error: Undefined Behavior: constructing invalid value: encountered 0x02, but expected a boolean
+  --> tests/native-lib/fail/invalid_retval.rs:LL:CC
+   |
+LL |         u8_id(2);
+   |         ^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
index 55acb240612f..730e9d89441a 100644
--- a/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
+++ b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
@@ -1,6 +1,7 @@
 fn main() {
     test_pass_struct();
     test_pass_struct_complex();
+    test_return_struct();
 }
 
 /// Test passing a basic struct as an argument.
@@ -20,6 +21,23 @@ fn test_pass_struct() {
     assert_eq!(unsafe { pass_struct(pass_me) }, 42 + 1337);
 }
 
+fn test_return_struct() {
+    // Exactly two fields, so that we hit the ScalarPair case.
+    #[repr(C)]
+    struct PassMe {
+        value: i32,
+        other_value: i64,
+    }
+
+    extern "C" {
+        fn return_struct(v: i32, ov: i64) -> PassMe;
+    }
+
+    let pass_me = unsafe { return_struct(1, 2) };
+    assert_eq!(pass_me.value, 1);
+    assert_eq!(pass_me.other_value, 2);
+}
+
 /// Test passing a more complex struct as an argument.
 fn test_pass_struct_complex() {
     #[repr(C)]
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
index b6bbb4342b77..bc2fcac08f01 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
@@ -14,16 +14,3 @@ LL |     unsafe { print_pointer(&x) };
            1: main
                at tests/native-lib/pass/ptr_read_access.rs:LL:CC
 
-warning: sharing a function pointer with a native function called via FFI
-  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
-   |
-LL |         pass_fn_ptr(Some(nop)); // this one is not
-   |         ^^^^^^^^^^^^^^^^^^^^^^ sharing a function pointer with a native function
-   |
-   = help: calling Rust functions from C is not supported and will, in the best case, crash the program
-   = note: stack backtrace:
-           0: pass_fn_ptr
-               at tests/native-lib/pass/ptr_read_access.rs:LL:CC
-           1: main
-               at tests/native-lib/pass/ptr_read_access.rs:LL:CC
-
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
index 0d86ea066099..c7f30c114f16 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
@@ -15,16 +15,3 @@ LL |     unsafe { print_pointer(&x) };
            1: main
                at tests/native-lib/pass/ptr_read_access.rs:LL:CC
 
-warning: sharing a function pointer with a native function called via FFI
-  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
-   |
-LL |         pass_fn_ptr(Some(nop)); // this one is not
-   |         ^^^^^^^^^^^^^^^^^^^^^^ sharing a function pointer with a native function
-   |
-   = help: calling Rust functions from C is not supported and will, in the best case, crash the program
-   = note: stack backtrace:
-           0: pass_fn_ptr
-               at tests/native-lib/pass/ptr_read_access.rs:LL:CC
-           1: main
-               at tests/native-lib/pass/ptr_read_access.rs:LL:CC
-
diff --git a/src/tools/miri/tests/native-lib/ptr_read_access.c b/src/tools/miri/tests/native-lib/ptr_read_access.c
index 5f071ca3d424..44ba13aa54a6 100644
--- a/src/tools/miri/tests/native-lib/ptr_read_access.c
+++ b/src/tools/miri/tests/native-lib/ptr_read_access.c
@@ -68,3 +68,10 @@ EXPORT uintptr_t do_one_deref(const int32_t ***ptr) {
 EXPORT void pass_fn_ptr(void f(void)) {
   (void)f; // suppress unused warning
 }
+
+/* Test: function_ptrs */
+EXPORT void call_fn_ptr(void f(void)) {
+    if (f != NULL) {
+        f();
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/scalar_arguments.c b/src/tools/miri/tests/native-lib/scalar_arguments.c
index 10b6244bdeb4..720f1982178c 100644
--- a/src/tools/miri/tests/native-lib/scalar_arguments.c
+++ b/src/tools/miri/tests/native-lib/scalar_arguments.c
@@ -34,6 +34,10 @@ EXPORT float add_float(float x) {
   return x + 1.5f;
 }
 
+EXPORT uint8_t u8_id(uint8_t x) {
+  return x;
+}
+
 // To test that functions not marked with EXPORT cannot be called by Miri.
 int32_t not_exported(void) {
   return 0;
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-fs-flock.rs b/src/tools/miri/tests/pass-dep/libc/libc-fs-flock.rs
index 0500ba05046c..52de8c7104c2 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs-flock.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs-flock.rs
@@ -1,5 +1,6 @@
 //@ignore-target: windows # File handling is not implemented yet
 //@ignore-target: solaris # Does not have flock
+//@ignore-target: android # Does not (always?) have flock
 //@compile-flags: -Zmiri-disable-isolation
 
 use std::fs::File;
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 99685d6d976b..8c860b5db7ba 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
@@ -48,6 +48,7 @@ fn main() {
     test_nofollow_not_symlink();
     #[cfg(target_os = "macos")]
     test_ioctl();
+    test_close_stdout();
 }
 
 fn test_file_open_unix_allow_two_args() {
@@ -579,3 +580,11 @@ fn test_ioctl() {
         assert_eq!(libc::ioctl(fd, libc::FIOCLEX), 0);
     }
 }
+
+fn test_close_stdout() {
+    // This is std library UB, but that's not relevant since we're
+    // only interacting with libc here.
+    unsafe {
+        libc::close(1);
+    }
+}
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
index ffbcf633b987..db68daed5396 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
@@ -5,6 +5,7 @@ use std::thread;
 
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
+use libc_utils::*;
 
 fn main() {
     test_pipe();
@@ -13,6 +14,7 @@ fn main() {
     test_pipe_array();
     #[cfg(any(
         target_os = "linux",
+        target_os = "android",
         target_os = "illumos",
         target_os = "freebsd",
         target_os = "solaris"
@@ -25,69 +27,44 @@ fn main() {
 
 fn test_pipe() {
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::pipe(fds.as_mut_ptr()) });
 
     // Read size == data available in buffer.
-    let data = "12345".as_bytes().as_ptr();
-    let res = unsafe { libc_utils::write_all(fds[1], data as *const libc::c_void, 5) };
-    assert_eq!(res, 5);
-    let mut buf3: [u8; 5] = [0; 5];
-    let res = unsafe {
-        libc_utils::read_all(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t)
-    };
-    assert_eq!(res, 5);
-    assert_eq!(buf3, "12345".as_bytes());
+    let data = b"12345";
+    write_all_from_slice(fds[1], data).unwrap();
+    let buf3 = read_all_into_array::<5>(fds[0]).unwrap();
+    assert_eq!(&buf3, data);
 
     // Read size > data available in buffer.
-    let data = "123".as_bytes();
-    let res = unsafe { libc_utils::write_all(fds[1], data.as_ptr() as *const libc::c_void, 3) };
-    assert_eq!(res, 3);
+    let data = b"123";
+    write_all_from_slice(fds[1], data).unwrap();
     let mut buf4: [u8; 5] = [0; 5];
-    let res = unsafe { libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t) };
-    assert!(res > 0 && res <= 3);
-    let res = res as usize;
-    assert_eq!(buf4[..res], data[..res]);
-    if res < 3 {
-        // Drain the rest from the read end.
-        let res = unsafe { libc_utils::read_all(fds[0], buf4[res..].as_mut_ptr().cast(), 3 - res) };
-        assert!(res > 0);
-    }
+    let (part1, rest) = read_into_slice(fds[0], &mut buf4).unwrap();
+    assert_eq!(part1[..], data[..part1.len()]);
+    // Write 2 more bytes so we can exactly fill the `rest`.
+    write_all_from_slice(fds[1], b"34").unwrap();
+    read_all_into_slice(fds[0], rest).unwrap();
 }
 
 fn test_pipe_threaded() {
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::pipe(fds.as_mut_ptr()) });
 
     let thread1 = thread::spawn(move || {
-        let mut buf: [u8; 5] = [0; 5];
-        let res: i64 = unsafe {
-            libc_utils::read_all(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t)
-                .try_into()
-                .unwrap()
-        };
-        assert_eq!(res, 5);
-        assert_eq!(buf, "abcde".as_bytes());
+        let buf = read_all_into_array::<5>(fds[0]).unwrap();
+        assert_eq!(&buf, b"abcde");
     });
     thread::yield_now();
-    let data = "abcde".as_bytes().as_ptr();
-    let res = unsafe { libc_utils::write_all(fds[1], data as *const libc::c_void, 5) };
-    assert_eq!(res, 5);
+    write_all_from_slice(fds[1], b"abcde").unwrap();
     thread1.join().unwrap();
 
     // Read and write from different direction
     let thread2 = thread::spawn(move || {
         thread::yield_now();
-        let data = "12345".as_bytes().as_ptr();
-        let res = unsafe { libc_utils::write_all(fds[1], data as *const libc::c_void, 5) };
-        assert_eq!(res, 5);
+        write_all_from_slice(fds[1], b"12345").unwrap();
     });
-    let mut buf: [u8; 5] = [0; 5];
-    let res =
-        unsafe { libc_utils::read_all(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
-    assert_eq!(res, 5);
-    assert_eq!(buf, "12345".as_bytes());
+    let buf = read_all_into_array::<5>(fds[0]).unwrap();
+    assert_eq!(&buf, b"12345");
     thread2.join().unwrap();
 }
 
@@ -96,26 +73,17 @@ fn test_pipe_threaded() {
 fn test_race() {
     static mut VAL: u8 = 0;
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::pipe(fds.as_mut_ptr()) });
     let thread1 = thread::spawn(move || {
-        let mut buf: [u8; 1] = [0; 1];
         // write() from the main thread will occur before the read() here
         // because preemption is disabled and the main thread yields after write().
-        let res: i32 = unsafe {
-            libc_utils::read_all(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t)
-                .try_into()
-                .unwrap()
-        };
-        assert_eq!(res, 1);
-        assert_eq!(buf, "a".as_bytes());
+        let buf = read_all_into_array::<1>(fds[0]).unwrap();
+        assert_eq!(&buf, b"a");
         // The read above establishes a happens-before so it is now safe to access this global variable.
         unsafe { assert_eq!(VAL, 1) };
     });
     unsafe { VAL = 1 };
-    let data = "a".as_bytes().as_ptr();
-    let res = unsafe { libc_utils::write_all(fds[1], data as *const libc::c_void, 1) };
-    assert_eq!(res, 1);
+    write_all_from_slice(fds[1], b"a").unwrap();
     thread::yield_now();
     thread1.join().unwrap();
 }
@@ -133,46 +101,53 @@ fn test_pipe_array() {
 /// Test if pipe2 (including the O_NONBLOCK flag) is supported.
 #[cfg(any(
     target_os = "linux",
+    target_os = "android",
     target_os = "illumos",
     target_os = "freebsd",
     target_os = "solaris"
 ))]
 fn test_pipe2() {
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK) });
 }
 
 /// Basic test for pipe fcntl's F_SETFL and F_GETFL flag.
 fn test_pipe_setfl_getfl() {
     // Initialise pipe fds.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::pipe(fds.as_mut_ptr()) });
 
     // Both sides should either have O_RONLY or O_WRONLY.
-    let res = unsafe { libc::fcntl(fds[0], libc::F_GETFL) };
-    assert_eq!(res, libc::O_RDONLY);
-    let res = unsafe { libc::fcntl(fds[1], libc::F_GETFL) };
-    assert_eq!(res, libc::O_WRONLY);
+    assert_eq!(
+        errno_result(unsafe { libc::fcntl(fds[0], libc::F_GETFL) }).unwrap(),
+        libc::O_RDONLY
+    );
+    assert_eq!(
+        errno_result(unsafe { libc::fcntl(fds[1], libc::F_GETFL) }).unwrap(),
+        libc::O_WRONLY
+    );
 
     // Add the O_NONBLOCK flag with F_SETFL.
-    let res = unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) });
 
     // Test if the O_NONBLOCK flag is successfully added.
-    let res = unsafe { libc::fcntl(fds[0], libc::F_GETFL) };
-    assert_eq!(res, libc::O_RDONLY | libc::O_NONBLOCK);
+    assert_eq!(
+        errno_result(unsafe { libc::fcntl(fds[0], libc::F_GETFL) }).unwrap(),
+        libc::O_RDONLY | libc::O_NONBLOCK
+    );
 
     // The other side remains unchanged.
-    let res = unsafe { libc::fcntl(fds[1], libc::F_GETFL) };
-    assert_eq!(res, libc::O_WRONLY);
+    assert_eq!(
+        errno_result(unsafe { libc::fcntl(fds[1], libc::F_GETFL) }).unwrap(),
+        libc::O_WRONLY
+    );
 
     // Test if O_NONBLOCK flag can be unset.
-    let res = unsafe { libc::fcntl(fds[0], libc::F_SETFL, 0) };
-    assert_eq!(res, 0);
-    let res = unsafe { libc::fcntl(fds[0], libc::F_GETFL) };
-    assert_eq!(res, libc::O_RDONLY);
+    errno_check(unsafe { libc::fcntl(fds[0], libc::F_SETFL, 0) });
+    assert_eq!(
+        errno_result(unsafe { libc::fcntl(fds[0], libc::F_GETFL) }).unwrap(),
+        libc::O_RDONLY
+    );
 }
 
 /// Test the behaviour of F_SETFL/F_GETFL when a fd is blocking.
@@ -183,28 +158,24 @@ fn test_pipe_setfl_getfl() {
 ///    then writes to fds[1] to unblock main thread's `read`.
 fn test_pipe_fcntl_threaded() {
     let mut fds = [-1, -1];
-    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
-    let mut buf: [u8; 5] = [0; 5];
+    errno_check(unsafe { libc::pipe(fds.as_mut_ptr()) });
     let thread1 = thread::spawn(move || {
         // Add O_NONBLOCK flag while pipe is still blocked on read.
-        let res = unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) };
-        assert_eq!(res, 0);
+        errno_check(unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) });
 
         // Check the new flag value while the main thread is still blocked on fds[0].
-        let res = unsafe { libc::fcntl(fds[0], libc::F_GETFL) };
-        assert_eq!(res, libc::O_NONBLOCK);
+        assert_eq!(
+            errno_result(unsafe { libc::fcntl(fds[0], libc::F_GETFL) }).unwrap(),
+            libc::O_NONBLOCK
+        );
 
         // The write below will unblock the `read` in main thread: even though
         // the socket is now "non-blocking", the shim needs to deal correctly
         // with threads that were blocked before the socket was made non-blocking.
-        let data = "abcde".as_bytes().as_ptr();
-        let res = unsafe { libc_utils::write_all(fds[1], data as *const libc::c_void, 5) };
-        assert_eq!(res, 5);
+        write_all_from_slice(fds[1], b"abcde").unwrap();
     });
     // The `read` below will block.
-    let res =
-        unsafe { libc_utils::read_all(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
+    let buf = read_all_into_array::<5>(fds[0]).unwrap();
     thread1.join().unwrap();
-    assert_eq!(res, 5);
+    assert_eq!(&buf, b"abcde");
 }
diff --git a/src/tools/miri/tests/pass-dep/shims/gettid.rs b/src/tools/miri/tests/pass-dep/shims/gettid.rs
index b7a2fa49ef86..9d5ff0dc5dae 100644
--- a/src/tools/miri/tests/pass-dep/shims/gettid.rs
+++ b/src/tools/miri/tests/pass-dep/shims/gettid.rs
@@ -165,7 +165,7 @@ fn main() {
     // The value is not important, we only care that whatever the value is,
     // won't change from execution to execution.
     if cfg!(with_isolation) {
-        if cfg!(target_os = "linux") {
+        if cfg!(any(target_os = "linux", target_os = "android")) {
             // Linux starts the TID at the PID, which is 1000.
             assert_eq!(tid, 1000);
         } else {
@@ -174,8 +174,8 @@ fn main() {
         }
     }
 
-    // On Linux and NetBSD, the first TID is the PID.
-    #[cfg(any(target_os = "linux", target_os = "netbsd"))]
+    // On Linux, the first TID is the PID.
+    #[cfg(any(target_os = "linux", target_os = "android"))]
     assert_eq!(tid, unsafe { libc::getpid() } as u64);
 
     #[cfg(any(target_vendor = "apple", windows))]
diff --git a/src/tools/miri/tests/pass-dep/tempfile.rs b/src/tools/miri/tests/pass-dep/tempfile.rs
index a44a7e7d9244..885190bd776a 100644
--- a/src/tools/miri/tests/pass-dep/tempfile.rs
+++ b/src/tools/miri/tests/pass-dep/tempfile.rs
@@ -7,15 +7,8 @@ mod utils;
 
 /// Test that the [`tempfile`] crate is compatible with miri for UNIX hosts and targets
 fn main() {
-    test_tempfile();
-    test_tempfile_in();
-}
-
-fn test_tempfile() {
-    tempfile::tempfile().unwrap();
-}
-
-fn test_tempfile_in() {
+    // Only create a file in our own tmp folder; the "host" temp folder
+    // can be nonsensical for cross-tests.
     let dir_path = utils::tmp();
     tempfile::tempfile_in(dir_path).unwrap();
 }
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 648c90b5dd97..50b5dbfba1cd 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -37,7 +37,7 @@ fn main() {
         test_canonicalize();
         #[cfg(unix)]
         test_pread_pwrite();
-        #[cfg(not(any(target_os = "solaris", target_os = "illumos")))]
+        #[cfg(not(any(target_os = "solaris", target_os = "android")))]
         test_flock();
     }
 }
@@ -399,8 +399,8 @@ fn test_pread_pwrite() {
     assert_eq!(&buf1, b"  m");
 }
 
-// This function does seem to exist on Illumos but std does not expose it there.
-#[cfg(not(any(target_os = "solaris", target_os = "illumos")))]
+// The standard library does not support this operation on Solaris, Android
+#[cfg(not(any(target_os = "solaris", target_os = "android")))]
 fn test_flock() {
     let bytes = b"Hello, World!\n";
     let path = utils::prepare_with_content("miri_test_fs_flock.txt", bytes);
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-avx512.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-avx512.rs
index f95429d59ebe..42acb6c3fb37 100644
--- a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-avx512.rs
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-avx512.rs
@@ -1,6 +1,6 @@
 // We're testing x86 target specific features
 //@only-target: x86_64 i686
-//@compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bitalg,+avx512vpopcntdq
+//@compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bitalg,+avx512vpopcntdq,+avx512vnni
 
 #[cfg(target_arch = "x86")]
 use std::arch::x86::*;
@@ -13,12 +13,14 @@ fn main() {
     assert!(is_x86_feature_detected!("avx512vl"));
     assert!(is_x86_feature_detected!("avx512bitalg"));
     assert!(is_x86_feature_detected!("avx512vpopcntdq"));
+    assert!(is_x86_feature_detected!("avx512vnni"));
 
     unsafe {
         test_avx512();
         test_avx512bitalg();
         test_avx512vpopcntdq();
         test_avx512ternarylogic();
+        test_avx512vnni();
     }
 }
 
@@ -411,6 +413,101 @@ unsafe fn test_avx512ternarylogic() {
     test_mm_ternarylogic_epi32();
 }
 
+#[target_feature(enable = "avx512vnni")]
+unsafe fn test_avx512vnni() {
+    #[target_feature(enable = "avx512vnni")]
+    unsafe fn test_mm512_dpbusd_epi32() {
+        const SRC: [i32; 16] = [
+            1,
+            // Test that addition with the `src` element uses wrapping arithmetic.
+            i32::MAX,
+            i32::MIN,
+            0,
+            0,
+            7,
+            12345,
+            -9876,
+            0x01020304,
+            -1,
+            42,
+            0,
+            1_000_000_000,
+            -1_000_000_000,
+            17,
+            -17,
+        ];
+
+        // The `A` array must be interpreted as a sequence of unsigned 8-bit integers. Setting
+        // the high bit of a byte tests that this is implemented correctly.
+        const A: [i32; 16] = [
+            0x01010101,
+            i32::from_le_bytes([1; 4]),
+            i32::from_le_bytes([1; 4]),
+            i32::from_le_bytes([u8::MAX; 4]),
+            i32::from_le_bytes([u8::MAX; 4]),
+            0x02_80_01_FF,
+            0x00_FF_00_FF,
+            0x7F_80_FF_01,
+            0x10_20_30_40,
+            0xDE_AD_BE_EFu32 as i32,
+            0x00_00_00_FF,
+            0x12_34_56_78,
+            0xFF_00_FF_00u32 as i32,
+            0x01_02_03_04,
+            0xAA_55_AA_55u32 as i32,
+            0x11_22_33_44,
+        ];
+
+        // The `B` array must be interpreted as a sequence of signed 8-bit integers. Setting
+        // the high bit of a byte tests that this is implemented correctly.
+        const B: [i32; 16] = [
+            0x01010101,
+            i32::from_le_bytes([1; 4]),
+            i32::from_le_bytes([(-1i8).cast_unsigned(); 4]),
+            i32::from_le_bytes([i8::MAX.cast_unsigned(); 4]),
+            i32::from_le_bytes([i8::MIN.cast_unsigned(); 4]),
+            0xFF_01_80_7Fu32 as i32,
+            0x01_FF_01_FF,
+            0x80_7F_00_FFu32 as i32,
+            0x7F_01_FF_80u32 as i32,
+            0x01_02_03_04,
+            0xFF_FF_FF_FFu32 as i32,
+            0x80_00_7F_FFu32 as i32,
+            0x7F_80_7F_80u32 as i32,
+            0x40_C0_20_E0u32 as i32,
+            0x00_01_02_03,
+            0x7F_7E_80_81u32 as i32,
+        ];
+
+        const DST: [i32; 16] = [
+            5,
+            i32::MAX.wrapping_add(4),
+            i32::MIN.wrapping_add(-4),
+            129540,
+            -130560,
+            32390,
+            11835,
+            -9877,
+            16902884,
+            2093,
+            -213,
+            8498,
+            1000064770,
+            -1000000096,
+            697,
+            -8738,
+        ];
+
+        let src = _mm512_loadu_si512(SRC.as_ptr().cast::<__m512i>());
+        let a = _mm512_loadu_si512(A.as_ptr().cast::<__m512i>());
+        let b = _mm512_loadu_si512(B.as_ptr().cast::<__m512i>());
+        let dst = _mm512_loadu_si512(DST.as_ptr().cast::<__m512i>());
+
+        assert_eq_m512i(_mm512_dpbusd_epi32(src, a, b), dst);
+    }
+    test_mm512_dpbusd_epi32();
+}
+
 #[track_caller]
 unsafe fn assert_eq_m512i(a: __m512i, b: __m512i) {
     assert_eq!(transmute::<_, [i32; 16]>(a), transmute::<_, [i32; 16]>(b))
diff --git a/src/tools/miri/tests/utils/libc.rs b/src/tools/miri/tests/utils/libc.rs
index e42f39c64eb6..0765bacb6bd8 100644
--- a/src/tools/miri/tests/utils/libc.rs
+++ b/src/tools/miri/tests/utils/libc.rs
@@ -40,17 +40,35 @@ pub unsafe fn read_all(
     return read_so_far as libc::ssize_t;
 }
 
+/// Try to fill the given slice by reading from `fd`. Error if that many bytes could not be read.
+#[track_caller]
+pub fn read_all_into_slice(fd: libc::c_int, buf: &mut [u8]) -> Result<(), libc::ssize_t> {
+    let res = unsafe { read_all(fd, buf.as_mut_ptr().cast(), buf.len()) };
+    if res >= 0 {
+        assert_eq!(res as usize, buf.len());
+        Ok(())
+    } else {
+        Err(res)
+    }
+}
+
 /// Read exactly `N` bytes from `fd`. Error if that many bytes could not be read.
 #[track_caller]
 pub fn read_all_into_array<const N: usize>(fd: libc::c_int) -> Result<[u8; N], libc::ssize_t> {
     let mut buf = [0; N];
-    let res = unsafe { read_all(fd, buf.as_mut_ptr().cast(), buf.len()) };
-    if res >= 0 {
-        assert_eq!(res as usize, buf.len());
-        Ok(buf)
-    } else {
-        Err(res)
-    }
+    read_all_into_slice(fd, &mut buf)?;
+    Ok(buf)
+}
+
+/// Do a single read from `fd` and return the part of the buffer that was written into,
+/// and the rest.
+#[track_caller]
+pub fn read_into_slice(
+    fd: libc::c_int,
+    buf: &mut [u8],
+) -> Result<(&mut [u8], &mut [u8]), libc::ssize_t> {
+    let res = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), buf.len()) };
+    if res >= 0 { Ok(buf.split_at_mut(res as usize)) } else { Err(res) }
 }
 
 pub unsafe fn write_all(
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index 48b25f235dd6..b52dab001ef5 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -450,13 +450,14 @@ fn main() -> anyhow::Result<()> {
             "rust-docs-json",
             "rust-analyzer",
             "rustc-src",
+            "rustc-src-gpl",
             "extended",
             "clippy",
             "miri",
             "rustfmt",
-            "gcc",
             "generate-copyright",
             "bootstrap",
+            "rustc_codegen_gcc",
         ] {
             build_args.extend(["--skip".to_string(), target.to_string()]);
         }
diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index 29168b25f7f6..1aacfeaf538e 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -123,7 +123,7 @@ llvm-config = "{llvm_config}"
             "tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist",
             "tests/ui",
             "tests/crashes",
-            "tests/rustdoc",
+            "tests/rustdoc-html",
         ];
         for test_path in env.skipped_tests() {
             args.extend(["--skip", test_path]);
diff --git a/src/tools/run-make-support/src/env.rs b/src/tools/run-make-support/src/env.rs
index 507d51471df0..65b6d3db85d5 100644
--- a/src/tools/run-make-support/src/env.rs
+++ b/src/tools/run-make-support/src/env.rs
@@ -49,3 +49,17 @@ pub fn set_current_dir<P: AsRef<std::path::Path>>(dir: P) {
     std::env::set_current_dir(dir.as_ref())
         .expect(&format!("could not set current directory to \"{}\"", dir.as_ref().display()));
 }
+
+/// Number of parallel jobs bootstrap was configured with.
+///
+/// This may fallback to [`std::thread::available_parallelism`] when no explicit jobs count has been
+/// configured. Refer to bootstrap's jobs fallback logic.
+#[track_caller]
+pub fn jobs() -> u32 {
+    std::env::var_os("__BOOTSTRAP_JOBS")
+        .expect("`__BOOTSTRAP_JOBS` must be set by `compiletest`")
+        .to_str()
+        .expect("`__BOOTSTRAP_JOBS` must be a valid string")
+        .parse::<u32>()
+        .expect("`__BOOTSTRAP_JOBS` must be a valid `u32`")
+}
diff --git a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
index e2791ffe6f0a..13fb05d56547 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
@@ -26,6 +26,9 @@ const _: () = {
         krate: Crate,
     }
 
+    // FIXME: This poses an invalidation problem, if one constructs an `EditionedFileId` with a
+    // different crate then whatever the input of a memo used, it will invalidate the memo causing
+    // it to recompute even if the crate is not really used.
     /// We like to include the origin crate in an `EditionedFileId` (for use in the item tree),
     /// but this poses us a problem.
     ///
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
index 66f7e25ffac4..10cd460d1d36 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
@@ -57,8 +57,7 @@ impl HygieneId {
         Self(ctx)
     }
 
-    // FIXME: Inline this
-    pub(crate) fn lookup(self) -> SyntaxContext {
+    pub(crate) fn syntax_context(self) -> SyntaxContext {
         self.0
     }
 
@@ -73,7 +72,8 @@ pub type ExprSource = InFile<ExprPtr>;
 pub type PatPtr = AstPtr<ast::Pat>;
 pub type PatSource = InFile<PatPtr>;
 
-pub type LabelPtr = AstPtr<ast::Label>;
+/// BlockExpr -> Desugared label from try block
+pub type LabelPtr = AstPtr<Either<ast::Label, ast::BlockExpr>>;
 pub type LabelSource = InFile<LabelPtr>;
 
 pub type FieldPtr = AstPtr<ast::RecordExprField>;
@@ -942,7 +942,7 @@ impl ExpressionStoreSourceMap {
     }
 
     pub fn node_label(&self, node: InFile<&ast::Label>) -> Option<LabelId> {
-        let src = node.map(AstPtr::new);
+        let src = node.map(AstPtr::new).map(AstPtr::wrap_left);
         self.expr_only()?.label_map.get(&src).cloned()
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
index 6a2f06b0a6f6..d34ec9bbc182 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
@@ -11,7 +11,7 @@ use hir_expand::{
     ExpandError, ExpandErrorKind, ExpandResult, HirFileId, InFile, Lookup, MacroCallId,
     eager::EagerCallBackFn, mod_path::ModPath, span_map::SpanMap,
 };
-use span::{AstIdMap, Edition, SyntaxContext};
+use span::{AstIdMap, SyntaxContext};
 use syntax::ast::HasAttrs;
 use syntax::{AstNode, Parse, ast};
 use triomphe::Arc;
@@ -61,7 +61,7 @@ impl Expander {
     pub(super) fn hygiene_for_range(&self, db: &dyn DefDatabase, range: TextRange) -> HygieneId {
         match self.span_map.as_ref() {
             hir_expand::span_map::SpanMapRef::ExpansionSpanMap(span_map) => {
-                HygieneId::new(span_map.span_at(range.start()).ctx.opaque_and_semitransparent(db))
+                HygieneId::new(span_map.span_at(range.start()).ctx.opaque_and_semiopaque(db))
             }
             hir_expand::span_map::SpanMapRef::RealSpanMap(_) => HygieneId::ROOT,
         }
@@ -75,11 +75,6 @@ impl Expander {
         AttrFlags::is_cfg_enabled_for(owner, cfg_options)
     }
 
-    pub(super) fn call_syntax_ctx(&self) -> SyntaxContext {
-        // FIXME:
-        SyntaxContext::root(Edition::CURRENT_FIXME)
-    }
-
     pub(super) fn enter_expand<T: ast::AstNode>(
         &mut self,
         db: &dyn DefDatabase,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index 42b076abb2a6..4ae4271b92f5 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -1096,7 +1096,7 @@ impl<'db> ExprCollector<'db> {
             ast::Expr::WhileExpr(e) => self.collect_while_loop(syntax_ptr, e),
             ast::Expr::ForExpr(e) => self.collect_for_loop(syntax_ptr, e),
             ast::Expr::CallExpr(e) => {
-                // FIXME: Remove this once we drop support for <1.86, https://github.com/rust-lang/rust/commit/ac9cb908ac4301dfc25e7a2edee574320022ae2c
+                // FIXME(MINIMUM_SUPPORTED_TOOLCHAIN_VERSION): Remove this once we drop support for <1.86, https://github.com/rust-lang/rust/commit/ac9cb908ac4301dfc25e7a2edee574320022ae2c
                 let is_rustc_box = {
                     let attrs = e.attrs();
                     attrs.filter_map(|it| it.as_simple_atom()).any(|it| it == "rustc_box")
@@ -1649,7 +1649,7 @@ impl<'db> ExprCollector<'db> {
     fn desugar_try_block(&mut self, e: BlockExpr) -> ExprId {
         let try_from_output = self.lang_path(self.lang_items().TryTraitFromOutput);
         let label = self.generate_new_name();
-        let label = self.alloc_label_desugared(Label { name: label });
+        let label = self.alloc_label_desugared(Label { name: label }, AstPtr::new(&e).wrap_right());
         let old_label = self.current_try_block_label.replace(label);
 
         let ptr = AstPtr::new(&e).upcast();
@@ -2319,7 +2319,6 @@ impl<'db> ExprCollector<'db> {
             ast::Pat::SlicePat(p) => {
                 let SlicePatComponents { prefix, slice, suffix } = p.components();
 
-                // FIXME properly handle `RestPat`
                 Pat::Slice {
                     prefix: prefix.into_iter().map(|p| self.collect_pat(p, binding_list)).collect(),
                     slice: slice.map(|p| self.collect_pat(p, binding_list)),
@@ -2399,7 +2398,6 @@ impl<'db> ExprCollector<'db> {
                 };
                 let start = range_part_lower(p.start());
                 let end = range_part_lower(p.end());
-                // FIXME: Exclusive ended pattern range is stabilised
                 match p.op_kind() {
                     Some(range_type) => Pat::Range { start, end, range_type },
                     None => Pat::Missing,
@@ -2519,9 +2517,9 @@ impl<'db> ExprCollector<'db> {
         let mut hygiene_info = if hygiene_id.is_root() {
             None
         } else {
-            hygiene_id.lookup().outer_expn(self.db).map(|expansion| {
+            hygiene_id.syntax_context().outer_expn(self.db).map(|expansion| {
                 let expansion = self.db.lookup_intern_macro_call(expansion.into());
-                (hygiene_id.lookup().parent(self.db), expansion.def)
+                (hygiene_id.syntax_context().parent(self.db), expansion.def)
             })
         };
         let name = Name::new_lifetime(&lifetime.text());
@@ -2548,7 +2546,7 @@ impl<'db> ExprCollector<'db> {
                         // Therefore, if we got to the rib of its declaration, give up its hygiene
                         // and use its parent expansion.
 
-                        hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent(self.db));
+                        hygiene_id = HygieneId::new(parent_ctx.opaque_and_semiopaque(self.db));
                         hygiene_info = parent_ctx.outer_expn(self.db).map(|expansion| {
                             let expansion = self.db.lookup_intern_macro_call(expansion.into());
                             (parent_ctx.parent(self.db), expansion.def)
@@ -2727,17 +2725,17 @@ impl ExprCollector<'_> {
         self.store.pats.alloc(Pat::Missing)
     }
 
-    fn alloc_label(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
+    fn alloc_label(&mut self, label: Label, ptr: AstPtr<ast::Label>) -> LabelId {
+        self.alloc_label_desugared(label, ptr.wrap_left())
+    }
+
+    fn alloc_label_desugared(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
         let src = self.expander.in_file(ptr);
         let id = self.store.labels.alloc(label);
         self.store.label_map_back.insert(id, src);
         self.store.label_map.insert(src, id);
         id
     }
-    // FIXME: desugared labels don't have ptr, that's wrong and should be fixed somehow.
-    fn alloc_label_desugared(&mut self, label: Label) -> LabelId {
-        self.store.labels.alloc(label)
-    }
 
     fn is_lowering_awaitable_block(&self) -> &Awaitable {
         self.awaitable_context.as_ref().unwrap_or(&Awaitable::No("unknown"))
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs
index 32c9df3dfefb..7ef84f27f664 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs
@@ -3,6 +3,7 @@
 use base_db::FxIndexSet;
 use hir_expand::name::Name;
 use intern::{Symbol, sym};
+use span::SyntaxContext;
 use syntax::{AstPtr, AstToken as _, ast};
 
 use crate::{
@@ -49,7 +50,7 @@ impl<'db> ExprCollector<'db> {
             self.expand_macros_to_string(template.clone()).map(|it| (it, template))
         }) {
             Some(((s, is_direct_literal), template)) => {
-                let call_ctx = self.expander.call_syntax_ctx();
+                let call_ctx = SyntaxContext::root(self.def_map.edition());
                 let hygiene = self.hygiene_id_for(s.syntax().text_range());
                 let fmt = format_args::parse(
                     &s,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
index 1a2d5ebba467..482cf36f95b0 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
@@ -20,8 +20,7 @@ pub type LocalLifetimeParamId = Idx<LifetimeParamData>;
 /// Data about a generic type parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TypeParamData {
-    /// [`None`] only if the type ref is an [`crate::type_ref::TypeRef::ImplTrait`]. FIXME: Might be better to just
-    /// make it always be a value, giving impl trait a special name.
+    /// [`None`] only if the type ref is an [`crate::type_ref::TypeRef::ImplTrait`].
     pub name: Option<Name>,
     pub default: Option<TypeRefId>,
     pub provenance: TypeParamProvenance,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs
index ad8535413d67..b64199fa2697 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs
@@ -1,8 +1,6 @@
 //! HIR for references to types. Paths in these are not yet resolved. They can
 //! be directly created from an ast::TypeRef, without further queries.
 
-use std::fmt::Write;
-
 use hir_expand::name::Name;
 use intern::Symbol;
 use la_arena::Idx;
@@ -10,12 +8,11 @@ use thin_vec::ThinVec;
 
 use crate::{
     LifetimeParamId, TypeParamId,
-    builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
     expr_store::{
         ExpressionStore,
         path::{GenericArg, Path},
     },
-    hir::{ExprId, Literal},
+    hir::ExprId,
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
@@ -275,56 +272,3 @@ impl TypeBound {
 pub struct ConstRef {
     pub expr: ExprId,
 }
-
-/// A literal constant value
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum LiteralConstRef {
-    Int(i128),
-    UInt(u128),
-    Bool(bool),
-    Char(char),
-
-    /// Case of an unknown value that rustc might know but we don't
-    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
-    // constants
-    // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177
-    // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348
-    Unknown,
-}
-
-impl LiteralConstRef {
-    pub fn builtin_type(&self) -> BuiltinType {
-        match self {
-            LiteralConstRef::UInt(_) | LiteralConstRef::Unknown => {
-                BuiltinType::Uint(BuiltinUint::U128)
-            }
-            LiteralConstRef::Int(_) => BuiltinType::Int(BuiltinInt::I128),
-            LiteralConstRef::Char(_) => BuiltinType::Char,
-            LiteralConstRef::Bool(_) => BuiltinType::Bool,
-        }
-    }
-}
-
-impl From<Literal> for LiteralConstRef {
-    fn from(literal: Literal) -> Self {
-        match literal {
-            Literal::Char(c) => Self::Char(c),
-            Literal::Bool(flag) => Self::Bool(flag),
-            Literal::Int(num, _) => Self::Int(num),
-            Literal::Uint(num, _) => Self::UInt(num),
-            _ => Self::Unknown,
-        }
-    }
-}
-
-impl std::fmt::Display for LiteralConstRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            LiteralConstRef::Int(num) => num.fmt(f),
-            LiteralConstRef::UInt(num) => num.fmt(f),
-            LiteralConstRef::Bool(flag) => flag.fmt(f),
-            LiteralConstRef::Char(c) => write!(f, "'{c}'"),
-            LiteralConstRef::Unknown => f.write_char('_'),
-        }
-    }
-}
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
index 9e7868b273ef..a3278dd76c86 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
@@ -158,7 +158,7 @@ pub struct ItemScope {
     /// declared.
     declarations: ThinVec<ModuleDefId>,
 
-    impls: ThinVec<ImplId>,
+    impls: ThinVec<(ImplId, /* trait impl */ bool)>,
     builtin_derive_impls: ThinVec<BuiltinDeriveImplId>,
     extern_blocks: ThinVec<ExternBlockId>,
     unnamed_consts: ThinVec<ConstId>,
@@ -327,7 +327,15 @@ impl ItemScope {
     }
 
     pub fn impls(&self) -> impl ExactSizeIterator<Item = ImplId> + '_ {
-        self.impls.iter().copied()
+        self.impls.iter().map(|&(id, _)| id)
+    }
+
+    pub fn trait_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
+        self.impls.iter().filter(|&&(_, is_trait_impl)| is_trait_impl).map(|&(id, _)| id)
+    }
+
+    pub fn inherent_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
+        self.impls.iter().filter(|&&(_, is_trait_impl)| !is_trait_impl).map(|&(id, _)| id)
     }
 
     pub fn builtin_derive_impls(&self) -> impl ExactSizeIterator<Item = BuiltinDeriveImplId> + '_ {
@@ -472,8 +480,8 @@ impl ItemScope {
         self.legacy_macros.get(name).map(|it| &**it)
     }
 
-    pub(crate) fn define_impl(&mut self, imp: ImplId) {
-        self.impls.push(imp);
+    pub(crate) fn define_impl(&mut self, imp: ImplId, is_trait_impl: bool) {
+        self.impls.push((imp, is_trait_impl));
     }
 
     pub(crate) fn define_builtin_derive_impl(&mut self, imp: BuiltinDeriveImplId) {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
index 2e838fad2e9f..a1707f17beb0 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
@@ -614,7 +614,9 @@ pub struct Trait {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Impl {}
+pub struct Impl {
+    pub is_trait_impl: bool,
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TypeAlias {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
index d8519f7393df..3f19e001548e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
@@ -271,7 +271,7 @@ impl<'a> Ctx<'a> {
         let ast_id = self.source_ast_id_map.ast_id(impl_def);
         // Note that trait impls don't get implicit `Self` unlike traits, because here they are a
         // type alias rather than a type parameter, so this is handled by the resolver.
-        let res = Impl {};
+        let res = Impl { is_trait_impl: impl_def.trait_().is_some() };
         self.tree.small_data.insert(ast_id.upcast(), SmallModItem::Impl(res));
         ast_id
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
index c89299e6d863..4113a778eaaf 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
@@ -258,7 +258,7 @@ impl Printer<'_> {
                 w!(self, "trait {} {{ ... }}", name.display(self.db, self.edition));
             }
             ModItemId::Impl(ast_id) => {
-                let Impl {} = &self.tree[ast_id];
+                let Impl { is_trait_impl: _ } = &self.tree[ast_id];
                 self.print_ast_id(ast_id.erase());
                 w!(self, "impl {{ ... }}");
             }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
index 41d69c1fd624..eba4d87ec9f8 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -40,8 +40,12 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
 
     let crate_def_map = crate_def_map(db, krate);
 
+    if !crate_def_map.is_unstable_feature_enabled(&sym::lang_items) {
+        return None;
+    }
+
     for (_, module_data) in crate_def_map.modules() {
-        for impl_def in module_data.scope.impls() {
+        for impl_def in module_data.scope.inherent_impls() {
             lang_items.collect_lang_item(db, impl_def);
             for &(_, assoc) in impl_def.impl_items(db).items.iter() {
                 match assoc {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
index 3f136bc59172..c63f2c1d786b 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
@@ -16,7 +16,7 @@ mod proc_macros;
 
 use std::{any::TypeId, iter, ops::Range, sync};
 
-use base_db::{RootQueryDb, SourceDatabase};
+use base_db::RootQueryDb;
 use expect_test::Expect;
 use hir_expand::{
     AstId, ExpansionInfo, InFile, MacroCallId, MacroCallKind, MacroKind,
@@ -387,7 +387,7 @@ struct IdentityWhenValidProcMacroExpander;
 impl ProcMacroExpander for IdentityWhenValidProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &base_db::Env,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index 4740e3b99e3d..87ade0651762 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -2028,7 +2028,9 @@ impl ModCollector<'_, '_> {
                     let impl_id =
                         ImplLoc { container: module_id, id: InFile::new(self.file_id(), imp) }
                             .intern(db);
-                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
+                    self.def_collector.def_map.modules[self.module_id]
+                        .scope
+                        .define_impl(impl_id, self.item_tree[imp].is_trait_impl)
                 }
                 ModItemId::Function(id) => {
                     let it = &self.item_tree[id];
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/path_resolution.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/path_resolution.rs
index e4b1d2a98735..cf33cecf5fba 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/path_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/path_resolution.rs
@@ -267,7 +267,6 @@ impl DefMap {
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
-            // FIXME there must be a nicer way to write this condition
             PathKind::Plain | PathKind::Abs
                 if self.data.edition == Edition::Edition2015
                     && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
@@ -383,7 +382,6 @@ impl DefMap {
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
-            // FIXME there must be a nicer way to write this condition
             PathKind::Plain | PathKind::Abs
                 if self.data.edition == Edition::Edition2015
                     && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 263f603a0bfb..2ac0f90fb209 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -936,7 +936,7 @@ fn handle_macro_def_scope(
         // A macro is allowed to refer to variables from before its declaration.
         // Therefore, if we got to the rib of its declaration, give up its hygiene
         // and use its parent expansion.
-        *hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent(db));
+        *hygiene_id = HygieneId::new(parent_ctx.opaque_and_semiopaque(db));
         *hygiene_info = parent_ctx.outer_expn(db).map(|expansion| {
             let expansion = db.lookup_intern_macro_call(expansion.into());
             (parent_ctx.parent(db), expansion.def)
@@ -950,7 +950,7 @@ fn hygiene_info(
     hygiene_id: HygieneId,
 ) -> Option<(SyntaxContext, MacroDefId)> {
     if !hygiene_id.is_root() {
-        let ctx = hygiene_id.lookup();
+        let ctx = hygiene_id.syntax_context();
         ctx.outer_expn(db).map(|expansion| {
             let expansion = db.lookup_intern_macro_call(expansion.into());
             (ctx.parent(db), expansion.def)
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
index 40d44cd1dba2..51767f87ffb9 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
@@ -9,8 +9,8 @@ use triomphe::Arc;
 
 use crate::{
     AstId, BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallInfo,
-    EagerExpander, EditionedFileId, ExpandError, ExpandResult, ExpandTo, HirFileId, MacroCallId,
-    MacroCallKind, MacroCallLoc, MacroDefId, MacroDefKind,
+    EagerExpander, EditionedFileId, ExpandError, ExpandResult, ExpandTo, FileRange, HirFileId,
+    MacroCallId, MacroCallKind, MacroCallLoc, MacroDefId, MacroDefKind,
     attrs::Meta,
     builtin::pseudo_derive_attr_expansion,
     cfg_process::attr_macro_input_to_token_tree,
@@ -61,6 +61,9 @@ pub trait ExpandDatabase: RootQueryDb {
     #[salsa::lru(1024)]
     fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
 
+    #[salsa::transparent]
+    fn resolve_span(&self, span: Span) -> FileRange;
+
     #[salsa::transparent]
     fn parse_or_expand(&self, file_id: HirFileId) -> SyntaxNode;
 
@@ -158,6 +161,13 @@ fn syntax_context(db: &dyn ExpandDatabase, file: HirFileId, edition: Edition) ->
     }
 }
 
+fn resolve_span(db: &dyn ExpandDatabase, Span { range, anchor, ctx: _ }: Span) -> FileRange {
+    let file_id = EditionedFileId::from_span_guess_origin(db, anchor.file_id);
+    let anchor_offset =
+        db.ast_id_map(file_id.into()).get_erased(anchor.ast_id).text_range().start();
+    FileRange { file_id, range: range + anchor_offset }
+}
+
 /// This expands the given macro call, but with different arguments. This is
 /// used for completion, where we want to see what 'would happen' if we insert a
 /// token. The `token_to_map` mapped down into the expansion, with the mapped
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs b/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
index d2df9a1ff6b2..d10e122a5deb 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
@@ -100,7 +100,8 @@ impl DeclarativeMacroExpander {
                     {
                         match &*value {
                             "transparent" => ControlFlow::Break(Transparency::Transparent),
-                            "semitransparent" => ControlFlow::Break(Transparency::SemiTransparent),
+                            // "semitransparent" is for old rustc versions.
+                            "semiopaque" | "semitransparent" => ControlFlow::Break(Transparency::SemiOpaque),
                             "opaque" => ControlFlow::Break(Transparency::Opaque),
                             _ => ControlFlow::Continue(()),
                         }
@@ -140,7 +141,7 @@ impl DeclarativeMacroExpander {
                     )),
                 },
                 transparency(ast::AnyHasAttrs::from(macro_rules))
-                    .unwrap_or(Transparency::SemiTransparent),
+                    .unwrap_or(Transparency::SemiOpaque),
             ),
             ast::Macro::MacroDef(macro_def) => (
                 match macro_def.body() {
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/hygiene.rs b/src/tools/rust-analyzer/crates/hir-expand/src/hygiene.rs
index bd6f7e4f2b77..ce7650d07711 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/hygiene.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/hygiene.rs
@@ -54,7 +54,7 @@ pub fn span_with_mixed_site_ctxt(
     expn_id: MacroCallId,
     edition: Edition,
 ) -> Span {
-    span_with_ctxt_from_mark(db, span, expn_id, Transparency::SemiTransparent, edition)
+    span_with_ctxt_from_mark(db, span, expn_id, Transparency::SemiOpaque, edition)
 }
 
 fn span_with_ctxt_from_mark(
@@ -82,7 +82,7 @@ pub(super) fn apply_mark(
     }
 
     let call_site_ctxt = db.lookup_intern_macro_call(call_id.into()).ctxt;
-    let mut call_site_ctxt = if transparency == Transparency::SemiTransparent {
+    let mut call_site_ctxt = if transparency == Transparency::SemiOpaque {
         call_site_ctxt.normalize_to_macros_2_0(db)
     } else {
         call_site_ctxt.normalize_to_macro_rules(db)
@@ -117,16 +117,16 @@ fn apply_mark_internal(
     let call_id = Some(call_id);
 
     let mut opaque = ctxt.opaque(db);
-    let mut opaque_and_semitransparent = ctxt.opaque_and_semitransparent(db);
+    let mut opaque_and_semiopaque = ctxt.opaque_and_semiopaque(db);
 
     if transparency >= Transparency::Opaque {
         let parent = opaque;
         opaque = SyntaxContext::new(db, call_id, transparency, edition, parent, identity, identity);
     }
 
-    if transparency >= Transparency::SemiTransparent {
-        let parent = opaque_and_semitransparent;
-        opaque_and_semitransparent =
+    if transparency >= Transparency::SemiOpaque {
+        let parent = opaque_and_semiopaque;
+        opaque_and_semiopaque =
             SyntaxContext::new(db, call_id, transparency, edition, parent, |_| opaque, identity);
     }
 
@@ -138,6 +138,6 @@ fn apply_mark_internal(
         edition,
         parent,
         |_| opaque,
-        |_| opaque_and_semitransparent,
+        |_| opaque_and_semiopaque,
     )
 }
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
index 385c98ef8778..b49190237776 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
@@ -429,7 +429,7 @@ pub const INERT_ATTRIBUTES: &[BuiltinAttribute] = &[
     rustc_attr!(rustc_proc_macro_decls, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE),
     rustc_attr!(
         rustc_macro_transparency, Normal,
-        template!(NameValueStr: "transparent|semitransparent|opaque"), ErrorFollowing,
+        template!(NameValueStr: "transparent|semiopaque|opaque"), ErrorFollowing,
         "used internally for testing macro hygiene",
     ),
 
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs b/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
index 7b6a6135b350..05541e782efd 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
@@ -901,11 +901,8 @@ impl ExpansionInfo {
         let span = self.exp_map.span_at(token.start());
         match &self.arg_map {
             SpanMap::RealSpanMap(_) => {
-                let file_id =
-                    EditionedFileId::from_span_guess_origin(db, span.anchor.file_id).into();
-                let anchor_offset =
-                    db.ast_id_map(file_id).get_erased(span.anchor.ast_id).text_range().start();
-                InFile { file_id, value: smallvec::smallvec![span.range + anchor_offset] }
+                let range = db.resolve_span(span);
+                InFile { file_id: range.file_id.into(), value: smallvec::smallvec![range.range] }
             }
             SpanMap::ExpansionSpanMap(arg_map) => {
                 let Some(arg_node) = &self.arg.value else {
@@ -947,7 +944,7 @@ pub fn map_node_range_up_rooted(
     range: TextRange,
 ) -> Option<FileRange> {
     let mut spans = exp_map.spans_for_range(range).filter(|span| span.ctx.is_root());
-    let Span { range, anchor, ctx: _ } = spans.next()?;
+    let Span { range, anchor, ctx } = spans.next()?;
     let mut start = range.start();
     let mut end = range.end();
 
@@ -958,10 +955,7 @@ pub fn map_node_range_up_rooted(
         start = start.min(span.range.start());
         end = end.max(span.range.end());
     }
-    let file_id = EditionedFileId::from_span_guess_origin(db, anchor.file_id);
-    let anchor_offset =
-        db.ast_id_map(file_id.into()).get_erased(anchor.ast_id).text_range().start();
-    Some(FileRange { file_id, range: TextRange::new(start, end) + anchor_offset })
+    Some(db.resolve_span(Span { range: TextRange::new(start, end), anchor, ctx }))
 }
 
 /// Maps up the text range out of the expansion hierarchy back into the original file its from.
@@ -984,10 +978,7 @@ pub fn map_node_range_up(
         start = start.min(span.range.start());
         end = end.max(span.range.end());
     }
-    let file_id = EditionedFileId::from_span_guess_origin(db, anchor.file_id);
-    let anchor_offset =
-        db.ast_id_map(file_id.into()).get_erased(anchor.ast_id).text_range().start();
-    Some((FileRange { file_id, range: TextRange::new(start, end) + anchor_offset }, ctx))
+    Some((db.resolve_span(Span { range: TextRange::new(start, end), anchor, ctx }), ctx))
 }
 
 /// Looks up the span at the given offset.
@@ -997,10 +988,7 @@ pub fn span_for_offset(
     offset: TextSize,
 ) -> (FileRange, SyntaxContext) {
     let span = exp_map.span_at(offset);
-    let file_id = EditionedFileId::from_span_guess_origin(db, span.anchor.file_id);
-    let anchor_offset =
-        db.ast_id_map(file_id.into()).get_erased(span.anchor.ast_id).text_range().start();
-    (FileRange { file_id, range: span.range + anchor_offset }, span.ctx)
+    (db.resolve_span(span), span.ctx)
 }
 
 /// In Rust, macros expand token trees to token trees. When we want to turn a
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/mod_path.rs b/src/tools/rust-analyzer/crates/hir-expand/src/mod_path.rs
index 51e449fe5085..1712c28aa8ab 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/mod_path.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/mod_path.rs
@@ -401,8 +401,8 @@ pub fn resolve_crate_root(db: &dyn ExpandDatabase, mut ctxt: SyntaxContext) -> O
         result_mark = Some(mark);
         iter.next();
     }
-    // Then find the last semi-transparent mark from the end if it exists.
-    while let Some((mark, Transparency::SemiTransparent)) = iter.next() {
+    // Then find the last semi-opaque mark from the end if it exists.
+    while let Some((mark, Transparency::SemiOpaque)) = iter.next() {
         result_mark = Some(mark);
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/proc_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/proc_macro.rs
index d2614aa5f149..467eae3122df 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/proc_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/proc_macro.rs
@@ -4,7 +4,7 @@ use core::fmt;
 use std::any::Any;
 use std::{panic::RefUnwindSafe, sync};
 
-use base_db::{Crate, CrateBuilderId, CratesIdMap, Env, ProcMacroLoadingError, SourceDatabase};
+use base_db::{Crate, CrateBuilderId, CratesIdMap, Env, ProcMacroLoadingError};
 use intern::Symbol;
 use rustc_hash::FxHashMap;
 use span::Span;
@@ -25,7 +25,7 @@ pub trait ProcMacroExpander: fmt::Debug + Send + Sync + RefUnwindSafe + Any {
     /// [`ProcMacroKind::Attr`]), environment variables, and span information.
     fn expand(
         &self,
-        db: &dyn SourceDatabase,
+        db: &dyn ExpandDatabase,
         subtree: &tt::TopSubtree,
         attrs: Option<&tt::TopSubtree>,
         env: &Env,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index f11240e0f78c..5bc2446fdd2d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -7,9 +7,9 @@ use base_db::Crate;
 use hir_def::{
     ConstId, EnumVariantId, GeneralConstId, HasModule, StaticId,
     attrs::AttrFlags,
+    builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
     expr_store::Body,
-    hir::{Expr, ExprId},
-    type_ref::LiteralConstRef,
+    hir::{Expr, ExprId, Literal},
 };
 use hir_expand::Lookup;
 use rustc_type_ir::inherent::IntoKind;
@@ -23,7 +23,7 @@ use crate::{
     mir::{MirEvalError, MirLowerError},
     next_solver::{
         Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
-        ParamEnv, StoredConst, StoredGenericArgs, Ty, ValueConst,
+        StoredConst, StoredGenericArgs, Ty, ValueConst,
     },
     traits::StoredParamEnvAndCrate,
 };
@@ -81,47 +81,122 @@ impl From<MirEvalError> for ConstEvalError {
 /// Interns a constant scalar with the given type
 pub fn intern_const_ref<'a>(
     db: &'a dyn HirDatabase,
-    value: &LiteralConstRef,
+    value: &Literal,
     ty: Ty<'a>,
-    krate: Crate,
+    _krate: Crate,
 ) -> Const<'a> {
     let interner = DbInterner::new_no_crate(db);
-    let layout = db
-        .layout_of_ty(ty.store(), ParamEnvAndCrate { param_env: ParamEnv::empty(), krate }.store());
     let kind = match value {
-        LiteralConstRef::Int(i) => {
-            // FIXME: We should handle failure of layout better.
-            let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16);
+        &Literal::Uint(i, builtin_ty)
+            if builtin_ty.is_none() || ty.as_builtin() == builtin_ty.map(BuiltinType::Uint) =>
+        {
+            let memory = match ty.as_builtin() {
+                Some(BuiltinType::Uint(builtin_uint)) => match builtin_uint {
+                    BuiltinUint::U8 => Box::new([i as u8]) as Box<[u8]>,
+                    BuiltinUint::U16 => Box::new((i as u16).to_le_bytes()),
+                    BuiltinUint::U32 => Box::new((i as u32).to_le_bytes()),
+                    BuiltinUint::U64 => Box::new((i as u64).to_le_bytes()),
+                    BuiltinUint::U128 => Box::new((i).to_le_bytes()),
+                    BuiltinUint::Usize => Box::new((i as usize).to_le_bytes()),
+                },
+                _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),
+            };
             rustc_type_ir::ConstKind::Value(ValueConst::new(
                 ty,
-                ConstBytes {
-                    memory: i.to_le_bytes()[0..size].into(),
-                    memory_map: MemoryMap::default(),
-                },
+                ConstBytes { memory, memory_map: MemoryMap::default() },
             ))
         }
-        LiteralConstRef::UInt(i) => {
-            let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16);
+        &Literal::Int(i, None)
+            if ty
+                .as_builtin()
+                .is_some_and(|builtin_ty| matches!(builtin_ty, BuiltinType::Uint(_))) =>
+        {
+            let memory = match ty.as_builtin() {
+                Some(BuiltinType::Uint(builtin_uint)) => match builtin_uint {
+                    BuiltinUint::U8 => Box::new([i as u8]) as Box<[u8]>,
+                    BuiltinUint::U16 => Box::new((i as u16).to_le_bytes()),
+                    BuiltinUint::U32 => Box::new((i as u32).to_le_bytes()),
+                    BuiltinUint::U64 => Box::new((i as u64).to_le_bytes()),
+                    BuiltinUint::U128 => Box::new((i as u128).to_le_bytes()),
+                    BuiltinUint::Usize => Box::new((i as usize).to_le_bytes()),
+                },
+                _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),
+            };
             rustc_type_ir::ConstKind::Value(ValueConst::new(
                 ty,
-                ConstBytes {
-                    memory: i.to_le_bytes()[0..size].into(),
-                    memory_map: MemoryMap::default(),
-                },
+                ConstBytes { memory, memory_map: MemoryMap::default() },
             ))
         }
-        LiteralConstRef::Bool(b) => rustc_type_ir::ConstKind::Value(ValueConst::new(
+        &Literal::Int(i, builtin_ty)
+            if builtin_ty.is_none() || ty.as_builtin() == builtin_ty.map(BuiltinType::Int) =>
+        {
+            let memory = match ty.as_builtin() {
+                Some(BuiltinType::Int(builtin_int)) => match builtin_int {
+                    BuiltinInt::I8 => Box::new([i as u8]) as Box<[u8]>,
+                    BuiltinInt::I16 => Box::new((i as i16).to_le_bytes()),
+                    BuiltinInt::I32 => Box::new((i as i32).to_le_bytes()),
+                    BuiltinInt::I64 => Box::new((i as i64).to_le_bytes()),
+                    BuiltinInt::I128 => Box::new((i).to_le_bytes()),
+                    BuiltinInt::Isize => Box::new((i as isize).to_le_bytes()),
+                },
+                _ => return Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed)),
+            };
+            rustc_type_ir::ConstKind::Value(ValueConst::new(
+                ty,
+                ConstBytes { memory, memory_map: MemoryMap::default() },
+            ))
+        }
+        Literal::Float(float_type_wrapper, builtin_float)
+            if builtin_float.is_none()
+                || ty.as_builtin() == builtin_float.map(BuiltinType::Float) =>
+        {
+            let memory = match ty.as_builtin().unwrap() {
+                BuiltinType::Float(builtin_float) => match builtin_float {
+                    // FIXME:
+                    hir_def::builtin_type::BuiltinFloat::F16 => Box::new([0u8; 2]) as Box<[u8]>,
+                    hir_def::builtin_type::BuiltinFloat::F32 => {
+                        Box::new(float_type_wrapper.to_f32().to_le_bytes())
+                    }
+                    hir_def::builtin_type::BuiltinFloat::F64 => {
+                        Box::new(float_type_wrapper.to_f64().to_le_bytes())
+                    }
+                    // FIXME:
+                    hir_def::builtin_type::BuiltinFloat::F128 => Box::new([0; 16]),
+                },
+                _ => unreachable!(),
+            };
+            rustc_type_ir::ConstKind::Value(ValueConst::new(
+                ty,
+                ConstBytes { memory, memory_map: MemoryMap::default() },
+            ))
+        }
+        Literal::Bool(b) if ty.is_bool() => rustc_type_ir::ConstKind::Value(ValueConst::new(
             ty,
             ConstBytes { memory: Box::new([*b as u8]), memory_map: MemoryMap::default() },
         )),
-        LiteralConstRef::Char(c) => rustc_type_ir::ConstKind::Value(ValueConst::new(
+        Literal::Char(c) if ty.is_char() => rustc_type_ir::ConstKind::Value(ValueConst::new(
             ty,
             ConstBytes {
                 memory: (*c as u32).to_le_bytes().into(),
                 memory_map: MemoryMap::default(),
             },
         )),
-        LiteralConstRef::Unknown => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
+        Literal::String(symbol) if ty.is_str() => rustc_type_ir::ConstKind::Value(ValueConst::new(
+            ty,
+            ConstBytes {
+                memory: symbol.as_str().as_bytes().into(),
+                memory_map: MemoryMap::default(),
+            },
+        )),
+        Literal::ByteString(items) if ty.as_slice().is_some_and(|ty| ty.is_u8()) => {
+            rustc_type_ir::ConstKind::Value(ValueConst::new(
+                ty,
+                ConstBytes { memory: items.clone(), memory_map: MemoryMap::default() },
+            ))
+        }
+        // FIXME
+        Literal::CString(_items) => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
+        _ => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
     };
     Const::new(interner, kind)
 }
@@ -130,7 +205,15 @@ pub fn intern_const_ref<'a>(
 pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const<'db> {
     intern_const_ref(
         db,
-        &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt),
+        &match value {
+            Some(value) => Literal::Uint(value, Some(BuiltinUint::Usize)),
+            None => {
+                return Const::new(
+                    DbInterner::new_no_crate(db),
+                    rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
+                );
+            }
+        },
         Ty::new_uint(DbInterner::new_no_crate(db), rustc_type_ir::UintTy::Usize),
         krate,
     )
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 08f201fea90b..5f6bcb4a602c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -2209,6 +2209,7 @@ fn boxes() {
     check_number(
         r#"
 //- minicore: coerce_unsized, deref_mut, slice
+#![feature(lang_items)]
 use core::ops::{Deref, DerefMut};
 use core::{marker::Unsize, ops::CoerceUnsized};
 
@@ -2346,6 +2347,7 @@ fn c_string() {
     check_number(
         r#"
 //- minicore: index, slice
+#![feature(lang_items)]
 #[lang = "CStr"]
 pub struct CStr {
     inner: [u8]
@@ -2360,6 +2362,7 @@ const GOAL: u8 = {
     check_number(
         r#"
 //- minicore: index, slice
+#![feature(lang_items)]
 #[lang = "CStr"]
 pub struct CStr {
     inner: [u8]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index 44bbd84003da..43b428c3fa51 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -10,7 +10,8 @@ use std::{
 use base_db::{Crate, FxIndexMap};
 use either::Either;
 use hir_def::{
-    FindPathConfig, GenericDefId, HasModule, LocalFieldId, Lookup, ModuleDefId, ModuleId, TraitId,
+    FindPathConfig, GenericDefId, GenericParamId, HasModule, LocalFieldId, Lookup, ModuleDefId,
+    ModuleId, TraitId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
@@ -66,6 +67,7 @@ pub type Result<T = (), E = HirDisplayError> = std::result::Result<T, E>;
 
 pub trait HirWrite: fmt::Write {
     fn start_location_link(&mut self, _location: ModuleDefId) {}
+    fn start_location_link_generic(&mut self, _location: GenericParamId) {}
     fn end_location_link(&mut self) {}
 }
 
@@ -147,6 +149,10 @@ impl<'db> HirFormatter<'_, 'db> {
         self.fmt.start_location_link(location);
     }
 
+    pub fn start_location_link_generic(&mut self, location: GenericParamId) {
+        self.fmt.start_location_link_generic(location);
+    }
+
     pub fn end_location_link(&mut self) {
         self.fmt.end_location_link();
     }
@@ -686,7 +692,9 @@ impl<'db> HirDisplay<'db> for Const<'db> {
             ConstKind::Param(param) => {
                 let generics = generics(f.db, param.id.parent());
                 let param_data = &generics[param.id.local_id()];
+                f.start_location_link_generic(param.id.into());
                 write!(f, "{}", param_data.name().unwrap().display(f.db, f.edition()))?;
+                f.end_location_link();
                 Ok(())
             }
             ConstKind::Value(const_bytes) => render_const_scalar(
@@ -1489,6 +1497,7 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
                 match param_data {
                     TypeOrConstParamData::TypeParamData(p) => match p.provenance {
                         TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
+                            f.start_location_link_generic(param.id.into());
                             write!(
                                 f,
                                 "{}",
@@ -1496,7 +1505,8 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
                                     .clone()
                                     .unwrap_or_else(Name::missing)
                                     .display(f.db, f.edition())
-                            )?
+                            )?;
+                            f.end_location_link();
                         }
                         TypeParamProvenance::ArgumentImplTrait => {
                             let bounds = GenericPredicates::query_all(f.db, param.id.parent())
@@ -1519,7 +1529,9 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
                         }
                     },
                     TypeOrConstParamData::ConstParamData(p) => {
+                        f.start_location_link_generic(param.id.into());
                         write!(f, "{}", p.name.display(f.db, f.edition()))?;
+                        f.end_location_link();
                     }
                 }
             }
@@ -2031,7 +2043,9 @@ impl<'db> HirDisplay<'db> for Region<'db> {
             RegionKind::ReEarlyParam(param) => {
                 let generics = generics(f.db, param.id.parent);
                 let param_data = &generics[param.id.local_id];
+                f.start_location_link_generic(param.id.into());
                 write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
+                f.end_location_link();
                 Ok(())
             }
             RegionKind::ReBound(BoundVarIndexKind::Bound(db), idx) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 9307868f3982..8e1ea9c47850 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -27,8 +27,8 @@ use hir_def::{
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs, ValueNs},
     signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
     type_ref::{
-        ConstRef, LifetimeRefId, LiteralConstRef, PathId, TraitBoundModifier,
-        TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
+        ConstRef, LifetimeRefId, PathId, TraitBoundModifier, TraitRef as HirTraitRef, TypeBound,
+        TypeRef, TypeRefId,
     },
 };
 use hir_expand::name::Name;
@@ -281,21 +281,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             hir_def::hir::Expr::Path(path) => {
                 self.path_to_const(path).unwrap_or_else(|| unknown_const(const_type))
             }
-            hir_def::hir::Expr::Literal(literal) => intern_const_ref(
-                self.db,
-                &match *literal {
-                    hir_def::hir::Literal::Float(_, _)
-                    | hir_def::hir::Literal::String(_)
-                    | hir_def::hir::Literal::ByteString(_)
-                    | hir_def::hir::Literal::CString(_) => LiteralConstRef::Unknown,
-                    hir_def::hir::Literal::Char(c) => LiteralConstRef::Char(c),
-                    hir_def::hir::Literal::Bool(b) => LiteralConstRef::Bool(b),
-                    hir_def::hir::Literal::Int(val, _) => LiteralConstRef::Int(val),
-                    hir_def::hir::Literal::Uint(val, _) => LiteralConstRef::UInt(val),
-                },
-                const_type,
-                self.resolver.krate(),
-            ),
+            hir_def::hir::Expr::Literal(literal) => {
+                intern_const_ref(self.db, literal, const_type, self.resolver.krate())
+            }
             hir_def::hir::Expr::UnaryOp { expr: inner_expr, op: hir_def::hir::UnaryOp::Neg } => {
                 if let hir_def::hir::Expr::Literal(literal) = &self.store[*inner_expr] {
                     // Only handle negation for signed integers and floats
@@ -304,7 +292,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                             if let Some(negated_literal) = literal.clone().negate() {
                                 intern_const_ref(
                                     self.db,
-                                    &negated_literal.into(),
+                                    &negated_literal,
                                     const_type,
                                     self.resolver.krate(),
                                 )
@@ -862,7 +850,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                                 TermKind::Ty(ty) => {
                                     ty.walk().any(|arg| arg == dummy_self_ty.into())
                                 }
-                                // FIXME(associated_const_equality): We should walk the const instead of not doing anything
+                                // FIXME(mgca): We should walk the const instead of not doing anything
                                 TermKind::Const(_) => false,
                             };
 
@@ -1319,7 +1307,7 @@ fn type_for_struct_constructor(
     db: &dyn HirDatabase,
     def: StructId,
 ) -> Option<StoredEarlyBinder<StoredTy>> {
-    let struct_data = def.fields(db);
+    let struct_data = db.struct_signature(def);
     match struct_data.shape {
         FieldsShape::Record => None,
         FieldsShape::Unit => Some(type_for_adt(db, def.into())),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 50dbd87d693e..e4681b464fec 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -609,12 +609,7 @@ impl InherentImpls {
             map: &mut FxHashMap<SimplifiedType, Vec<ImplId>>,
         ) {
             for (_module_id, module_data) in def_map.modules() {
-                for impl_id in module_data.scope.impls() {
-                    let data = db.impl_signature(impl_id);
-                    if data.target_trait.is_some() {
-                        continue;
-                    }
-
+                for impl_id in module_data.scope.inherent_impls() {
                     let interner = DbInterner::new_no_crate(db);
                     let self_ty = db.impl_self_ty(impl_id);
                     let self_ty = self_ty.instantiate_identity();
@@ -730,7 +725,11 @@ impl TraitImpls {
             map: &mut FxHashMap<TraitId, OneTraitImplsBuilder>,
         ) {
             for (_module_id, module_data) in def_map.modules() {
-                for impl_id in module_data.scope.impls() {
+                for impl_id in module_data.scope.trait_impls() {
+                    let trait_ref = match db.impl_trait(impl_id) {
+                        Some(tr) => tr.instantiate_identity(),
+                        None => continue,
+                    };
                     // Reservation impls should be ignored during trait resolution, so we never need
                     // them during type analysis. See rust-lang/rust#64631 for details.
                     //
@@ -742,10 +741,6 @@ impl TraitImpls {
                     {
                         continue;
                     }
-                    let trait_ref = match db.impl_trait(impl_id) {
-                        Some(tr) => tr.instantiate_identity(),
-                        None => continue,
-                    };
                     let self_ty = trait_ref.self_ty();
                     let interner = DbInterner::new_no_crate(db);
                     let entry = map.entry(trait_ref.def_id.0).or_default();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 2926dc30def7..7d291f7ddbed 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -878,9 +878,11 @@ impl<'db> InferCtxt<'db> {
         self.tainted_by_errors.set(Some(e));
     }
 
-    #[instrument(level = "debug", skip(self), ret)]
-    pub fn take_opaque_types(&self) -> Vec<(OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
-        self.inner.borrow_mut().opaque_type_storage.take_opaque_types().collect()
+    #[instrument(level = "debug", skip(self))]
+    pub fn take_opaque_types(
+        &self,
+    ) -> impl IntoIterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> + use<'db> {
+        self.inner.borrow_mut().opaque_type_storage.take_opaque_types()
     }
 
     #[instrument(level = "debug", skip(self), ret)]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
index 00177d21ac76..894fe5eb7b87 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
@@ -61,7 +61,7 @@ impl<'db> OpaqueTypeStorage<'db> {
 
     pub(crate) fn take_opaque_types(
         &mut self,
-    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+    ) -> impl IntoIterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> + use<'db> {
         let OpaqueTypeStorage { opaque_types, duplicate_entries } = self;
         std::mem::take(opaque_types).into_iter().chain(std::mem::take(duplicate_entries))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 030ba37015f2..66a24d394990 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -383,6 +383,11 @@ impl<'db> Ty<'db> {
         matches!(self.kind(), TyKind::Bool)
     }
 
+    #[inline]
+    pub fn is_char(self) -> bool {
+        matches!(self.kind(), TyKind::Char)
+    }
+
     /// A scalar type is one that denotes an atomic datum, with no sub-components.
     /// (A RawPtr is scalar because it represents a non-managed pointer, so its
     /// contents are abstract to rustc.)
@@ -422,6 +427,11 @@ impl<'db> Ty<'db> {
         matches!(self.kind(), TyKind::Tuple(tys) if tys.is_empty())
     }
 
+    #[inline]
+    pub fn is_u8(self) -> bool {
+        matches!(self.kind(), TyKind::Uint(UintTy::U8))
+    }
+
     #[inline]
     pub fn is_raw_ptr(self) -> bool {
         matches!(self.kind(), TyKind::RawPtr(..))
@@ -456,6 +466,14 @@ impl<'db> Ty<'db> {
         }
     }
 
+    #[inline]
+    pub fn as_slice(self) -> Option<Ty<'db>> {
+        match self.kind() {
+            TyKind::Slice(ty) => Some(ty),
+            _ => None,
+        }
+    }
+
     #[inline]
     pub fn ty_vid(self) -> Option<TyVid> {
         match self.kind() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index 1457bb2e1017..cf7ff6f7ecca 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -132,14 +132,13 @@ fn baz() -> i32 {
                 "trait_environment_query",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
                 "expr_scopes_shim",
                 "InferenceResult::for_body_",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
+                "AttrFlags::query_",
                 "body_shim",
                 "body_with_source_map_shim",
                 "trait_environment_query",
@@ -149,6 +148,7 @@ fn baz() -> i32 {
                 "InferenceResult::for_body_",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
+                "AttrFlags::query_",
                 "body_shim",
                 "body_with_source_map_shim",
                 "trait_environment_query",
@@ -197,13 +197,13 @@ fn baz() -> i32 {
                 "body_with_source_map_shim",
                 "body_shim",
                 "AttrFlags::query_",
-                "AttrFlags::query_",
                 "function_signature_with_source_map_shim",
                 "function_signature_shim",
                 "body_with_source_map_shim",
                 "body_shim",
                 "InferenceResult::for_body_",
                 "expr_scopes_shim",
+                "AttrFlags::query_",
                 "function_signature_with_source_map_shim",
                 "function_signature_shim",
                 "body_with_source_map_shim",
@@ -245,8 +245,6 @@ $0",
                 "TraitImpls::for_crate_",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -284,9 +282,6 @@ pub struct NewStruct {
                 "crate_local_def_map",
                 "TraitImpls::for_crate_",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -324,8 +319,6 @@ $0",
                 "TraitImpls::for_crate_",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -364,12 +357,6 @@ pub enum SomeEnum {
                 "crate_local_def_map",
                 "TraitImpls::for_crate_",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "EnumVariants::of_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -407,8 +394,6 @@ $0",
                 "TraitImpls::for_crate_",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -444,8 +429,6 @@ fn bar() -> f32 {
                 "crate_local_def_map",
                 "TraitImpls::for_crate_",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -487,9 +470,6 @@ $0",
                 "TraitImpls::for_crate_",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
             ]
         "#]],
     );
@@ -533,18 +513,6 @@ impl SomeStruct {
                 "crate_local_def_map",
                 "TraitImpls::for_crate_",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "ImplItems::of_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "impl_trait_with_diagnostics_query",
-                "impl_signature_shim",
-                "impl_signature_with_source_map_shim",
-                "impl_self_ty_with_diagnostics_query",
-                "struct_signature_shim",
-                "struct_signature_with_source_map_shim",
             ]
         "#]],
     );
@@ -616,8 +584,6 @@ fn main() {
                 "trait_environment_query",
                 "lang_items",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
@@ -630,18 +596,18 @@ fn main() {
                 "expr_scopes_shim",
                 "struct_signature_shim",
                 "struct_signature_with_source_map_shim",
+                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "value_ty_query",
-                "VariantFields::firewall_",
-                "VariantFields::query_",
                 "InherentImpls::for_crate_",
-                "impl_signature_shim",
-                "impl_signature_with_source_map_shim",
                 "callable_item_signature_query",
                 "TraitImpls::for_crate_and_deps_",
                 "TraitImpls::for_crate_",
                 "impl_trait_with_diagnostics_query",
+                "impl_signature_shim",
+                "impl_signature_with_source_map_shim",
                 "impl_self_ty_with_diagnostics_query",
+                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
             ]
         "#]],
@@ -710,9 +676,6 @@ fn main() {
                 "body_with_source_map_shim",
                 "body_shim",
                 "crate_lang_items",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
-                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
@@ -722,15 +685,16 @@ fn main() {
                 "ImplTraits::return_type_impl_traits_",
                 "expr_scopes_shim",
                 "struct_signature_with_source_map_shim",
+                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
-                "VariantFields::query_",
                 "InherentImpls::for_crate_",
-                "impl_signature_with_source_map_shim",
-                "impl_signature_shim",
                 "callable_item_signature_query",
                 "TraitImpls::for_crate_",
+                "impl_signature_with_source_map_shim",
+                "impl_signature_shim",
                 "impl_trait_with_diagnostics_query",
                 "impl_self_ty_with_diagnostics_query",
+                "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
             ]
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
index c312b167596f..0b776938c5b3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
@@ -794,6 +794,8 @@ fn slice_tail_pattern() {
 fn box_pattern() {
     check_infer(
         r#"
+        #![feature(lang_items)]
+
         pub struct Global;
         #[lang = "owned_box"]
         pub struct Box<T, A = Global>(T);
@@ -805,13 +807,13 @@ fn box_pattern() {
         }
         "#,
         expect![[r#"
-            83..89 'params': Box<i32, Global>
-            101..155 '{     ...   } }': ()
-            107..153 'match ...     }': ()
-            113..119 'params': Box<i32, Global>
-            130..141 'box integer': Box<i32, Global>
-            134..141 'integer': i32
-            145..147 '{}': ()
+            108..114 'params': Box<i32, Global>
+            126..180 '{     ...   } }': ()
+            132..178 'match ...     }': ()
+            138..144 'params': Box<i32, Global>
+            155..166 'box integer': Box<i32, Global>
+            159..166 'integer': i32
+            170..172 '{}': ()
         "#]],
     );
     check_infer(
@@ -831,7 +833,6 @@ fn box_pattern() {
             76..122 'match ...     }': ()
             82..88 'params': Box<i32>
             99..110 'box integer': Box<i32>
-            103..110 'integer': i32
             114..116 '{}': ()
         "#]],
     );
@@ -1142,6 +1143,7 @@ fn my_fn(#[cfg(feature = "feature")] u8: u8, u32: u32) {}
 fn var_args() {
     check_types(
         r#"
+#![feature(lang_items)]
 #[lang = "va_list"]
 pub struct VaListImpl<'f>;
 fn my_fn(foo: ...) {}
@@ -1156,6 +1158,7 @@ fn my_fn2(bar: u32, foo: ...) {}
 fn var_args_cond() {
     check_types(
         r#"
+#![feature(lang_items)]
 #[lang = "va_list"]
 pub struct VaListImpl<'f>;
 fn my_fn(bar: u32, #[cfg(FALSE)] foo: ..., #[cfg(not(FALSE))] foo: u32) {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index f03f8d754f2a..c805f030446c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2374,6 +2374,7 @@ fn rust_destruct_option_clone() {
     check_types(
         r#"
 //- minicore: option, drop
+#![feature(lang_items)]
 fn test(o: &Option<i32>) {
     o.my_clone();
   //^^^^^^^^^^^^ Option<i32>
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index e11cc85e7ff1..a4554673cdd5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -234,6 +234,7 @@ fn main() {
     // toolchains <= 1.88.0, before sized-hierarchy.
     check_no_mismatches(
         r#"
+#![feature(lang_items)]
 #[lang = "sized"]
 pub trait Sized {}
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index db557b75071f..a9a5e96f75cc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -2702,6 +2702,8 @@ fn box_into_vec() {
     check_infer(
         r#"
 //- /core.rs crate:core
+#![feature(lang_items)]
+
 #[lang = "sized"]
 pub trait Sized {}
 
@@ -2745,22 +2747,22 @@ struct Astruct;
 impl B for Astruct {}
 "#,
         expect![[r#"
-            614..618 'self': Box<[T], A>
-            647..679 '{     ...     }': Vec<T, A>
-            693..863 '{     ...])); }': ()
-            703..706 'vec': Vec<i32, Global>
-            709..724 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>
-            709..755 '<[_]>:...i32]))': Vec<i32, Global>
-            725..754 '#[rust...1i32])': Box<[i32; 1], Global>
-            747..753 '[1i32]': [i32; 1]
-            748..752 '1i32': i32
-            765..766 'v': Vec<Box<dyn B + 'static, Global>, Global>
-            786..803 '<[_]> ...to_vec': fn into_vec<Box<dyn B + '?, Global>, Global>(Box<[Box<dyn B + '?, Global>], Global>) -> Vec<Box<dyn B + '?, Global>, Global>
-            786..860 '<[_]> ...ct)]))': Vec<Box<dyn B + '?, Global>, Global>
-            804..859 '#[rust...uct)])': Box<[Box<dyn B + '?, Global>; 1], Global>
-            826..858 '[#[rus...ruct)]': [Box<dyn B + '?, Global>; 1]
-            827..857 '#[rust...truct)': Box<Astruct, Global>
-            849..856 'Astruct': Astruct
+            639..643 'self': Box<[T], A>
+            672..704 '{     ...     }': Vec<T, A>
+            718..888 '{     ...])); }': ()
+            728..731 'vec': Vec<i32, Global>
+            734..749 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>
+            734..780 '<[_]>:...i32]))': Vec<i32, Global>
+            750..779 '#[rust...1i32])': Box<[i32; 1], Global>
+            772..778 '[1i32]': [i32; 1]
+            773..777 '1i32': i32
+            790..791 'v': Vec<Box<dyn B + 'static, Global>, Global>
+            811..828 '<[_]> ...to_vec': fn into_vec<Box<dyn B + '?, Global>, Global>(Box<[Box<dyn B + '?, Global>], Global>) -> Vec<Box<dyn B + '?, Global>, Global>
+            811..885 '<[_]> ...ct)]))': Vec<Box<dyn B + '?, Global>, Global>
+            829..884 '#[rust...uct)])': Box<[Box<dyn B + '?, Global>; 1], Global>
+            851..883 '[#[rus...ruct)]': [Box<dyn B + '?, Global>; 1]
+            852..882 '#[rust...truct)': Box<Astruct, Global>
+            874..881 'Astruct': Astruct
         "#]],
     )
 }
@@ -3647,6 +3649,8 @@ fn main() {
 fn cstring_literals() {
     check_types(
         r#"
+#![feature(lang_items)]
+
 #[lang = "CStr"]
 pub struct CStr;
 
@@ -3704,7 +3708,7 @@ fn main() {
 }
 
 #[test]
-fn macro_semitransparent_hygiene() {
+fn macro_semiopaque_hygiene() {
     check_types(
         r#"
 macro_rules! m {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index e5cfe85573b8..6f415a5289c9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -41,7 +41,6 @@ pub(crate) fn variances_of(db: &dyn HirDatabase, def: GenericDefId) -> Variances
 )]
 fn variances_of_query(db: &dyn HirDatabase, def: GenericDefId) -> StoredVariancesOf {
     tracing::debug!("variances_of(def={:?})", def);
-    let interner = DbInterner::new_no_crate(db);
     match def {
         GenericDefId::FunctionId(_) => (),
         GenericDefId::AdtId(adt) => {
@@ -55,15 +54,17 @@ fn variances_of_query(db: &dyn HirDatabase, def: GenericDefId) -> StoredVariance
                 }
             }
         }
-        _ => return VariancesOf::empty(interner).store(),
+        _ => return VariancesOf::empty(DbInterner::new_no_crate(db)).store(),
     }
 
     let generics = generics(db, def);
     let count = generics.len();
     if count == 0 {
-        return VariancesOf::empty(interner).store();
+        return VariancesOf::empty(DbInterner::new_no_crate(db)).store();
     }
-    let variances = Context { generics, variances: vec![Variance::Bivariant; count], db }.solve();
+    let variances =
+        Context { generics, variances: vec![Variance::Bivariant; count].into_boxed_slice(), db }
+            .solve();
 
     VariancesOf::new_from_slice(&variances).store()
 }
@@ -113,11 +114,11 @@ pub(crate) fn variances_of_cycle_initial(
 struct Context<'db> {
     db: &'db dyn HirDatabase,
     generics: Generics,
-    variances: Vec<Variance>,
+    variances: Box<[Variance]>,
 }
 
 impl<'db> Context<'db> {
-    fn solve(mut self) -> Vec<Variance> {
+    fn solve(mut self) -> Box<[Variance]> {
         tracing::debug!("solve(generics={:?})", self.generics);
         match self.generics.def() {
             GenericDefId::AdtId(adt) => {
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index 09c5b1cca7f3..e032a16989ff 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -330,7 +330,7 @@ impl HasSource for Label {
         let (_body, source_map) = db.body_with_source_map(self.parent);
         let src = source_map.label_syntax(self.label_id);
         let root = src.file_syntax(db);
-        Some(src.map(|ast| ast.to_node(&root)))
+        src.map(|ast| ast.to_node(&root).left()).transpose()
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 1ab57c4489cf..78be5a7e8fa9 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -50,9 +50,9 @@ use either::Either;
 use hir_def::{
     AdtId, AssocItemId, AssocItemLoc, BuiltinDeriveImplId, CallableDefId, ConstId, ConstParamId,
     DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId,
-    GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup,
-    MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId,
-    TypeOrConstParamId, TypeParamId, UnionId,
+    HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup, MacroExpander,
+    MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId, TypeOrConstParamId,
+    TypeParamId, UnionId,
     attrs::AttrFlags,
     builtin_derive::BuiltinDeriveImplMethod,
     expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
@@ -150,7 +150,7 @@ pub use {
         visibility::Visibility,
         // FIXME: This is here since some queries take it as input that are used
         // outside of hir.
-        {ModuleDefId, TraitId},
+        {GenericParamId, ModuleDefId, TraitId},
     },
     hir_expand::{
         EditionedFileId, ExpandResult, HirFileId, MacroCallId, MacroKind,
@@ -803,22 +803,21 @@ impl Module {
                 emit_def_diagnostic(db, acc, diag, edition, loc.container.krate(db));
             }
 
-            if impl_signature.target_trait.is_none()
-                && !is_inherent_impl_coherent(db, def_map, impl_id)
-            {
+            let trait_impl = impl_signature.target_trait.is_some();
+            if !trait_impl && !is_inherent_impl_coherent(db, def_map, impl_id) {
                 acc.push(IncoherentImpl { impl_: ast_id_map.get(loc.id.value), file_id }.into())
             }
 
-            if !impl_def.check_orphan_rules(db) {
+            if trait_impl && !impl_def.check_orphan_rules(db) {
                 acc.push(TraitImplOrphan { impl_: ast_id_map.get(loc.id.value), file_id }.into())
             }
 
-            let trait_ = impl_def.trait_(db);
+            let trait_ = trait_impl.then(|| impl_def.trait_(db)).flatten();
             let mut trait_is_unsafe = trait_.is_some_and(|t| t.is_unsafe(db));
             let impl_is_negative = impl_def.is_negative(db);
             let impl_is_unsafe = impl_def.is_unsafe(db);
 
-            let trait_is_unresolved = trait_.is_none() && impl_signature.target_trait.is_some();
+            let trait_is_unresolved = trait_.is_none() && trait_impl;
             if trait_is_unresolved {
                 // Ignore trait safety errors when the trait is unresolved, as otherwise we'll treat it as safe,
                 // which may not be correct.
@@ -921,6 +920,48 @@ impl Module {
                     }
                 }
 
+                // HACK: When specialization is enabled in the current crate, and there exists
+                // *any* blanket impl that provides a default implementation for the missing item,
+                // suppress the missing associated item diagnostic.
+                // This can lead to false negatives when the impl in question does not actually
+                // specialize that blanket impl, but determining the exact specialization
+                // relationship here would be significantly more expensive.
+                if !missing.is_empty() {
+                    let krate = self.krate(db).id;
+                    let def_map = crate_def_map(db, krate);
+                    if def_map.is_unstable_feature_enabled(&sym::specialization)
+                        || def_map.is_unstable_feature_enabled(&sym::min_specialization)
+                    {
+                        missing.retain(|(assoc_name, assoc_item)| {
+                            let AssocItem::Function(_) = assoc_item else {
+                                return true;
+                            };
+
+                            for &impl_ in TraitImpls::for_crate(db, krate).blanket_impls(trait_.id)
+                            {
+                                if impl_ == impl_id {
+                                    continue;
+                                }
+
+                                for (name, item) in &impl_.impl_items(db).items {
+                                    let AssocItemId::FunctionId(fn_) = item else {
+                                        continue;
+                                    };
+                                    if name != assoc_name {
+                                        continue;
+                                    }
+
+                                    if db.function_signature(*fn_).is_default() {
+                                        return false;
+                                    }
+                                }
+                            }
+
+                            true
+                        });
+                    }
+                }
+
                 if !missing.is_empty() {
                     acc.push(
                         TraitImplMissingAssocItems {
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index bf123e13f94d..6ba7a42c1946 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -1808,5 +1808,5 @@ pub(crate) fn name_hygiene(db: &dyn HirDatabase, name: InFile<&SyntaxNode>) -> H
     };
     let span_map = db.expansion_span_map(macro_file);
     let ctx = span_map.span_at(name.value.text_range().start()).ctx;
-    HygieneId::new(ctx.opaque_and_semitransparent(db))
+    HygieneId::new(ctx.opaque_and_semiopaque(db))
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
index 8daf86923d92..1c0c6e43d53b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
@@ -1,6 +1,11 @@
+use itertools::Itertools;
 use syntax::{
     SyntaxKind::WHITESPACE,
-    ast::{AstNode, BlockExpr, ElseBranch, Expr, IfExpr, MatchArm, Pat, edit::AstNodeEdit, make},
+    ast::{
+        AstNode, BlockExpr, ElseBranch, Expr, IfExpr, MatchArm, Pat, edit::AstNodeEdit, make,
+        syntax_factory::SyntaxFactory,
+    },
+    syntax_editor::Element,
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -131,8 +136,10 @@ pub(crate) fn move_arm_cond_to_match_guard(
         AssistId::refactor_rewrite("move_arm_cond_to_match_guard"),
         "Move condition to match guard",
         replace_node.text_range(),
-        |edit| {
-            edit.delete(match_arm.syntax().text_range());
+        |builder| {
+            let make = SyntaxFactory::without_mappings();
+            let mut replace_arms = vec![];
+
             // Dedent if if_expr is in a BlockExpr
             let dedent = if needs_dedent {
                 cov_mark::hit!(move_guard_ifelse_in_block);
@@ -141,47 +148,30 @@ pub(crate) fn move_arm_cond_to_match_guard(
                 cov_mark::hit!(move_guard_ifelse_else_block);
                 0
             };
-            let then_arm_end = match_arm.syntax().text_range().end();
             let indent_level = match_arm.indent_level();
-            let spaces = indent_level;
 
-            let mut first = true;
             for (cond, block) in conds_blocks {
-                if !first {
-                    edit.insert(then_arm_end, format!("\n{spaces}"));
-                } else {
-                    first = false;
-                }
-                let guard = format!("{match_pat} if {cond} => ");
-                edit.insert(then_arm_end, guard);
                 let only_expr = block.statements().next().is_none();
-                match &block.tail_expr() {
-                    Some(then_expr) if only_expr => {
-                        edit.insert(then_arm_end, then_expr.syntax().text());
-                        edit.insert(then_arm_end, ",");
-                    }
-                    _ => {
-                        let to_insert = block.dedent(dedent.into()).syntax().text();
-                        edit.insert(then_arm_end, to_insert)
-                    }
-                }
+                let expr = match block.tail_expr() {
+                    Some(then_expr) if only_expr => then_expr,
+                    _ => block.dedent(dedent.into()).into(),
+                };
+                let guard = make.match_guard(cond);
+                let new_arm = make.match_arm(match_pat.clone(), Some(guard), expr);
+                replace_arms.push(new_arm);
             }
-            if let Some(e) = tail {
+            if let Some(block) = tail {
                 cov_mark::hit!(move_guard_ifelse_else_tail);
-                let guard = format!("\n{spaces}{match_pat} => ");
-                edit.insert(then_arm_end, guard);
-                let only_expr = e.statements().next().is_none();
-                match &e.tail_expr() {
+                let only_expr = block.statements().next().is_none();
+                let expr = match block.tail_expr() {
                     Some(expr) if only_expr => {
                         cov_mark::hit!(move_guard_ifelse_expr_only);
-                        edit.insert(then_arm_end, expr.syntax().text());
-                        edit.insert(then_arm_end, ",");
+                        expr
                     }
-                    _ => {
-                        let to_insert = e.dedent(dedent.into()).syntax().text();
-                        edit.insert(then_arm_end, to_insert)
-                    }
-                }
+                    _ => block.dedent(dedent.into()).into(),
+                };
+                let new_arm = make.match_arm(match_pat, None, expr);
+                replace_arms.push(new_arm);
             } else {
                 // There's no else branch. Add a pattern without guard, unless the following match
                 // arm is `_ => ...`
@@ -193,9 +183,21 @@ pub(crate) fn move_arm_cond_to_match_guard(
                     {
                         cov_mark::hit!(move_guard_ifelse_has_wildcard);
                     }
-                    _ => edit.insert(then_arm_end, format!("\n{spaces}{match_pat} => {{}}")),
+                    _ => {
+                        let block_expr = make.expr_empty_block().into();
+                        replace_arms.push(make.match_arm(match_pat, None, block_expr));
+                    }
                 }
             }
+
+            let mut edit = builder.make_editor(match_arm.syntax());
+
+            let newline = make.whitespace(&format!("\n{indent_level}"));
+            let replace_arms = replace_arms.iter().map(|it| it.syntax().syntax_element());
+            let replace_arms = Itertools::intersperse(replace_arms, newline.syntax_element());
+            edit.replace_with_many(match_arm.syntax(), replace_arms.collect());
+
+            builder.add_file_edits(ctx.vfs_file_id(), edit);
         },
     )
 }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
index aad881f8ce4f..797df3f163da 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
@@ -781,8 +781,8 @@ fn main() {
 }
 "#,
         expect![[r#"
-            fn weird_function() (use dep::test_mod::TestTrait)      fn() DEPRECATED
             ct SPECIAL_CONST (use dep::test_mod::TestTrait)           u8 DEPRECATED
+            fn weird_function() (use dep::test_mod::TestTrait)      fn() DEPRECATED
             me random_method(…) (use dep::test_mod::TestTrait) fn(&self) DEPRECATED
         "#]],
     );
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
index 273328a8d270..b8b9a7a76816 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
@@ -44,7 +44,7 @@ const SEQUENCE_TYPES: &[&str] = &["Vec", "VecDeque", "LinkedList"];
 /// `vec.as_slice()` -> `slice`
 /// `args.into_config()` -> `config`
 /// `bytes.to_vec()` -> `vec`
-const USELESS_METHOD_PREFIXES: &[&str] = &["into_", "as_", "to_"];
+const USELESS_METHOD_PREFIXES: &[&str] = &["try_into_", "into_", "as_", "to_"];
 
 /// Useless methods that are stripped from expression
 ///
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_incorrect_safety.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_incorrect_safety.rs
index 3414e972d5c9..c5b2f499d306 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_incorrect_safety.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_incorrect_safety.rs
@@ -64,6 +64,7 @@ unsafe trait Unsafe {}
     fn drop_may_dangle() {
         check_diagnostics(
             r#"
+#![feature(lang_items)]
 #[lang = "drop"]
 trait Drop {}
 struct S<T>;
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_missing_assoc_item.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_missing_assoc_item.rs
index 0e18ce967404..2c0554470187 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_missing_assoc_item.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_missing_assoc_item.rs
@@ -156,4 +156,22 @@ impl Trait for dyn OtherTrait {}
  "#,
         )
     }
+
+    #[test]
+    fn no_false_positive_on_specialization() {
+        check_diagnostics(
+            r#"
+#![feature(specialization)]
+
+pub trait Foo {
+    fn foo();
+}
+
+impl<T> Foo for T {
+    default fn foo() {}
+}
+impl Foo for bool {}
+"#,
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index f42d3cf0dc41..0b518021e39e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -4089,6 +4089,7 @@ fn foo() {
     let fo$0o = async { S };
 }
 //- /core.rs crate:core
+#![feature(lang_items)]
 pub mod future {
     #[lang = "future_trait"]
     pub trait Future {}
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index 06ae0b1d73d1..a58dc6f03055 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -5,8 +5,8 @@ use std::{
 
 use either::Either;
 use hir::{
-    ClosureStyle, DisplayTarget, EditionedFileId, HasVisibility, HirDisplay, HirDisplayError,
-    HirWrite, InRealFile, ModuleDef, ModuleDefId, Semantics, sym,
+    ClosureStyle, DisplayTarget, EditionedFileId, GenericParam, GenericParamId, HasVisibility,
+    HirDisplay, HirDisplayError, HirWrite, InRealFile, ModuleDef, ModuleDefId, Semantics, sym,
 };
 use ide_db::{
     FileRange, MiniCore, RootDatabase, famous_defs::FamousDefs, text_edit::TextEditBuilder,
@@ -709,6 +709,21 @@ impl HirWrite for InlayHintLabelBuilder<'_> {
         });
     }
 
+    fn start_location_link_generic(&mut self, def: GenericParamId) {
+        never!(self.location.is_some(), "location link is already started");
+        self.make_new_part();
+
+        self.location = Some(if self.resolve {
+            LazyProperty::Lazy
+        } else {
+            LazyProperty::Computed({
+                let Some(location) = GenericParam::from(def).try_to_nav(self.sema) else { return };
+                let location = location.call_site();
+                FileRange { file_id: location.file_id, range: location.focus_or_full_range() }
+            })
+        });
+    }
+
     fn end_location_link(&mut self) {
         self.make_new_part();
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
index 547004687c73..c74e3104c14e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
@@ -183,7 +183,8 @@ mod tests {
     use crate::{ClosureReturnTypeHints, fixture, inlay_hints::InlayHintsConfig};
 
     use crate::inlay_hints::tests::{
-        DISABLED_CONFIG, TEST_CONFIG, check, check_edit, check_no_edit, check_with_config,
+        DISABLED_CONFIG, TEST_CONFIG, check, check_edit, check_expect, check_no_edit,
+        check_with_config,
     };
 
     #[track_caller]
@@ -1255,4 +1256,130 @@ where
 "#,
         );
     }
+
+    #[test]
+    fn type_param_inlay_hint_has_location_link() {
+        check_expect(
+            InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },
+            r#"
+fn identity<T>(t: T) -> T {
+    let x = t;
+    x
+}
+"#,
+            expect![[r#"
+                [
+                    (
+                        36..37,
+                        [
+                            InlayHintLabelPart {
+                                text: "T",
+                                linked_location: Some(
+                                    Computed(
+                                        FileRangeWrapper {
+                                            file_id: FileId(
+                                                0,
+                                            ),
+                                            range: 12..13,
+                                        },
+                                    ),
+                                ),
+                                tooltip: "",
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn const_param_inlay_hint_has_location_link() {
+        check_expect(
+            InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },
+            r#"
+fn f<const N: usize>() {
+    let x = [0; N];
+}
+"#,
+            expect![[r#"
+                [
+                    (
+                        33..34,
+                        [
+                            "[i32; ",
+                            InlayHintLabelPart {
+                                text: "N",
+                                linked_location: Some(
+                                    Computed(
+                                        FileRangeWrapper {
+                                            file_id: FileId(
+                                                0,
+                                            ),
+                                            range: 11..12,
+                                        },
+                                    ),
+                                ),
+                                tooltip: "",
+                            },
+                            "]",
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn lifetime_param_inlay_hint_has_location_link() {
+        check_expect(
+            InlayHintsConfig { type_hints: true, ..DISABLED_CONFIG },
+            r#"
+struct S<'lt>(*mut &'lt ());
+
+fn f<'a>() {
+    let x = S::<'a>(loop {});
+}
+"#,
+            expect![[r#"
+                [
+                    (
+                        51..52,
+                        [
+                            InlayHintLabelPart {
+                                text: "S",
+                                linked_location: Some(
+                                    Computed(
+                                        FileRangeWrapper {
+                                            file_id: FileId(
+                                                0,
+                                            ),
+                                            range: 7..8,
+                                        },
+                                    ),
+                                ),
+                                tooltip: "",
+                            },
+                            "<",
+                            InlayHintLabelPart {
+                                text: "'a",
+                                linked_location: Some(
+                                    Computed(
+                                        FileRangeWrapper {
+                                            file_id: FileId(
+                                                0,
+                                            ),
+                                            range: 35..37,
+                                        },
+                                    ),
+                                ),
+                                tooltip: "",
+                            },
+                            ">",
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
index c9fbdf3ae754..045559fd7f46 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
@@ -143,7 +143,7 @@ fn foo<T>() {}
                                             file_id: FileId(
                                                 1,
                                             ),
-                                            range: 446..451,
+                                            range: 470..475,
                                         },
                                     ),
                                 ),
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index ffae7bf6c7c5..4918fe4ff9a4 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -38,7 +38,8 @@ use syntax::{
 };
 
 use crate::{
-    Analysis, FilePosition, HighlightedRange, NavigationTarget, TryToNav, highlight_related,
+    Analysis, FilePosition, HighlightedRange, NavigationTarget, TryToNav,
+    doc_links::token_as_doc_comment, highlight_related,
 };
 
 /// Result of a reference search operation.
@@ -211,6 +212,13 @@ pub(crate) fn find_defs(
     syntax: &SyntaxNode,
     offset: TextSize,
 ) -> Option<Vec<Definition>> {
+    if let Some(token) = syntax.token_at_offset(offset).left_biased()
+        && let Some(doc_comment) = token_as_doc_comment(&token)
+    {
+        return doc_comment
+            .get_definition_with_descend_at(sema, offset, |def, _, _| Some(vec![def]));
+    }
+
     let token = syntax.token_at_offset(offset).find(|t| {
         matches!(
             t.kind(),
@@ -785,6 +793,23 @@ fn main() {
         );
     }
 
+    #[test]
+    fn test_find_all_refs_in_comments() {
+        check(
+            r#"
+struct Foo;
+
+/// $0[`Foo`] is just above
+struct Bar;
+"#,
+            expect![[r#"
+                Foo Struct FileId(0) 0..11 7..10
+
+                (no references)
+            "#]],
+        );
+    }
+
     #[test]
     fn search_filters_by_range() {
         check(
diff --git a/src/tools/rust-analyzer/crates/intern/src/intern.rs b/src/tools/rust-analyzer/crates/intern/src/intern.rs
index b7acd6624b99..a96dfcfa9fe3 100644
--- a/src/tools/rust-analyzer/crates/intern/src/intern.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/intern.rs
@@ -334,7 +334,7 @@ impl<T: ?Sized> InternStorage<T> {
 
 impl<T: Internable + ?Sized> InternStorage<T> {
     pub(crate) fn get(&self) -> &InternMap<T> {
-        self.map.get_or_init(DashMap::default)
+        self.map.get_or_init(|| DashMap::with_capacity_and_hasher(1024, Default::default()))
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/intern/src/intern_slice.rs b/src/tools/rust-analyzer/crates/intern/src/intern_slice.rs
index 58de6e17bdff..8857771d2e01 100644
--- a/src/tools/rust-analyzer/crates/intern/src/intern_slice.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/intern_slice.rs
@@ -292,7 +292,12 @@ impl<T: SliceInternable> InternSliceStorage<T> {
 
 impl<T: SliceInternable> InternSliceStorage<T> {
     pub(crate) fn get(&self) -> &InternMap<T> {
-        self.map.get_or_init(DashMap::default)
+        self.map.get_or_init(|| {
+            DashMap::with_capacity_and_hasher(
+                (64 * 1024) / std::mem::size_of::<T::SliceType>(),
+                Default::default(),
+            )
+        })
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 3e325b2f990d..6181413a46db 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -297,6 +297,7 @@ define_symbols! {
     iterator,
     keyword,
     lang,
+    lang_items,
     le,
     Left,
     len,
@@ -441,7 +442,6 @@ define_symbols! {
     rustc_skip_array_during_method_dispatch,
     rustc_skip_during_method_dispatch,
     rustc_force_inline,
-    semitransparent,
     shl_assign,
     shl,
     shr_assign,
diff --git a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
index 5122051fb3c2..e8d98b1ce661 100644
--- a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
@@ -11,15 +11,16 @@ extern crate rustc_driver as _;
 use std::{any::Any, collections::hash_map::Entry, mem, path::Path, sync};
 
 use crossbeam_channel::{Receiver, unbounded};
-use hir_expand::proc_macro::{
-    ProcMacro, ProcMacroExpander, ProcMacroExpansionError, ProcMacroKind, ProcMacroLoadResult,
-    ProcMacrosBuilder,
+use hir_expand::{
+    db::ExpandDatabase,
+    proc_macro::{
+        ProcMacro, ProcMacroExpander, ProcMacroExpansionError, ProcMacroKind, ProcMacroLoadResult,
+        ProcMacrosBuilder,
+    },
 };
 use ide_db::{
     ChangeWithProcMacros, FxHashMap, RootDatabase,
-    base_db::{
-        CrateGraphBuilder, Env, ProcMacroLoadingError, SourceDatabase, SourceRoot, SourceRootId,
-    },
+    base_db::{CrateGraphBuilder, Env, ProcMacroLoadingError, SourceRoot, SourceRootId},
     prime_caches,
 };
 use itertools::Itertools;
@@ -31,7 +32,8 @@ use proc_macro_api::{
     },
 };
 use project_model::{CargoConfig, PackageRoot, ProjectManifest, ProjectWorkspace};
-use span::Span;
+use span::{Span, SpanAnchor, SyntaxContext};
+use tt::{TextRange, TextSize};
 use vfs::{
     AbsPath, AbsPathBuf, FileId, VfsPath,
     file_set::FileSetConfig,
@@ -530,7 +532,7 @@ struct Expander(proc_macro_api::ProcMacro);
 impl ProcMacroExpander for Expander {
     fn expand(
         &self,
-        db: &dyn SourceDatabase,
+        db: &dyn ExpandDatabase,
         subtree: &tt::TopSubtree,
         attrs: Option<&tt::TopSubtree>,
         env: &Env,
@@ -540,11 +542,44 @@ impl ProcMacroExpander for Expander {
         current_dir: String,
     ) -> Result<tt::TopSubtree, ProcMacroExpansionError> {
         let mut cb = |req| match req {
-            SubRequest::SourceText { file_id, start, end } => {
-                let file = FileId::from_raw(file_id);
-                let text = db.file_text(file).text(db);
-                let slice = text.get(start as usize..end as usize).map(ToOwned::to_owned);
-                Ok(SubResponse::SourceTextResult { text: slice })
+            SubRequest::LocalFilePath { file_id } => {
+                let file_id = FileId::from_raw(file_id);
+                let source_root_id = db.file_source_root(file_id).source_root_id(db);
+                let source_root = db.source_root(source_root_id).source_root(db);
+                let name = source_root
+                    .path_for_file(&file_id)
+                    .and_then(|path| path.as_path())
+                    .map(|path| path.to_string());
+
+                Ok(SubResponse::LocalFilePathResult { name })
+            }
+            SubRequest::SourceText { file_id, ast_id, start, end } => {
+                let ast_id = span::ErasedFileAstId::from_raw(ast_id);
+                let editioned_file_id = span::EditionedFileId::from_raw(file_id);
+                let span = Span {
+                    range: TextRange::new(TextSize::from(start), TextSize::from(end)),
+                    anchor: SpanAnchor { file_id: editioned_file_id, ast_id },
+                    ctx: SyntaxContext::root(editioned_file_id.edition()),
+                };
+                let range = db.resolve_span(span);
+                let source = db.file_text(range.file_id.file_id(db)).text(db);
+                let text = source
+                    .get(usize::from(range.range.start())..usize::from(range.range.end()))
+                    .map(ToOwned::to_owned);
+
+                Ok(SubResponse::SourceTextResult { text })
+            }
+            SubRequest::FilePath { file_id } => {
+                let file_id = FileId::from_raw(file_id);
+                let source_root_id = db.file_source_root(file_id).source_root_id(db);
+                let source_root = db.source_root(source_root_id).source_root(db);
+                let name = source_root
+                    .path_for_file(&file_id)
+                    .and_then(|path| path.as_path())
+                    .map(|path| path.to_string())
+                    .unwrap_or_default();
+
+                Ok(SubResponse::FilePathResult { name })
             }
         };
         match self.0.expand(
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
index cf8becd922de..e41f8a5d7da7 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
@@ -10,12 +10,16 @@ use crate::{
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum SubRequest {
-    SourceText { file_id: u32, start: u32, end: u32 },
+    FilePath { file_id: u32 },
+    SourceText { file_id: u32, ast_id: u32, start: u32, end: u32 },
+    LocalFilePath { file_id: u32 },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum SubResponse {
+    FilePathResult { name: String },
     SourceTextResult { text: Option<String> },
+    LocalFilePathResult { name: Option<String> },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
index 2c6e5a16ee06..6b2db0b269d5 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
@@ -18,6 +18,7 @@ clap = {version = "4.5.42", default-features = false, features = ["std"]}
 
 [features]
 default = []
+# default = ["sysroot-abi"]
 sysroot-abi = ["proc-macro-srv/sysroot-abi", "proc-macro-api/sysroot-abi"]
 in-rust-tree = ["proc-macro-srv/in-rust-tree", "sysroot-abi"]
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/README.md b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/README.md
new file mode 100644
index 000000000000..02a67ac3ecc1
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/README.md
@@ -0,0 +1,65 @@
+# proc-macro-srv-cli
+
+A standalone binary for the `proc-macro-srv` crate that provides procedural macro expansion for rust-analyzer.
+
+## Overview
+
+rust-analyzer uses a RPC (via stdio) client-server architecture for procedural macro expansion. This is necessary because:
+
+1. Proc macros are dynamic libraries that can segfault, bringing down the entire process, so running them out of process allows rust-analyzer to recover from fatal errors.
+2. Proc macro dylibs are compiled against a specific rustc version and require matching internal APIs to load and execute, as such having this binary shipped as a rustup component allows us to always match the rustc version irrespective of the rust-analyzer version used.
+
+## The `sysroot-abi` Feature
+
+**The `sysroot-abi` feature is required for the binary to actually function.** Without it, the binary will return an error:
+
+```
+proc-macro-srv-cli needs to be compiled with the `sysroot-abi` feature to function
+```
+
+This feature is necessary because the proc-macro server needs access to unstable rustc internals (`proc_macro_internals`, `proc_macro_diagnostic`, `proc_macro_span`) which are only available on nightly or with `RUSTC_BOOTSTRAP=1`.
+rust-analyzer is a stable toolchain project though, so the feature flag is used to have it remain compilable on stable by default.
+
+### Building
+
+```bash
+# Using nightly toolchain
+cargo build -p proc-macro-srv-cli --features sysroot-abi
+
+# Or with RUSTC_BOOTSTRAP on stable
+RUSTC_BOOTSTRAP=1 cargo build -p proc-macro-srv-cli --features sysroot-abi
+```
+
+### Installing the proc-macro server
+
+For local testing purposes, you can install the proc-macro server using the xtask command:
+
+```bash
+# Recommended: use the xtask command
+cargo xtask install --proc-macro-server
+```
+
+## Testing
+
+```bash
+cargo test --features sysroot-abi -p proc-macro-srv -p proc-macro-srv-cli -p proc-macro-api
+```
+
+The tests use a test proc macro dylib built by the `proc-macro-test` crate, which compiles a small proc macro implementation during build time.
+
+**Note**: Tests only compile on nightly toolchains (or with `RUSTC_BOOTSTRAP=1`).
+
+## Usage
+
+The binary requires the `RUST_ANALYZER_INTERNALS_DO_NOT_USE` environment variable to be set. This is intentional—the binary is an implementation detail of rust-analyzer and its API is still unstable:
+
+```bash
+RUST_ANALYZER_INTERNALS_DO_NOT_USE=1 rust-analyzer-proc-macro-srv --version
+```
+
+## Related Crates
+
+- `proc-macro-srv`: The core server library that handles loading dylibs and expanding macros, but not the RPC protocol.
+- `proc-macro-api`: The client library used by rust-analyzer to communicate with this server as well as the protocol definitions.
+- `proc-macro-test`: Test harness with sample proc macros for testing
+- `proc-macro-srv-cli`: The actual server binary that handles the RPC protocol.
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
index 25a5104c5df3..b2f4b96bd255 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
@@ -81,7 +81,6 @@ fn run_new<C: Codec>() -> io::Result<()> {
                 }
 
                 bidirectional::Request::ApiVersionCheck {} => {
-                    // bidirectional::Response::ApiVersionCheck(CURRENT_API_VERSION).write::<_, C>(stdout)
                     send_response::<C>(
                         &stdout,
                         bidirectional::Response::ApiVersionCheck(CURRENT_API_VERSION),
@@ -167,28 +166,57 @@ struct ProcMacroClientHandle<'a, C: Codec> {
     buf: &'a mut C::Buf,
 }
 
-impl<C: Codec> proc_macro_srv::ProcMacroClientInterface for ProcMacroClientHandle<'_, C> {
-    fn source_text(&mut self, file_id: u32, start: u32, end: u32) -> Option<String> {
-        let req = bidirectional::BidirectionalMessage::SubRequest(
-            bidirectional::SubRequest::SourceText { file_id, start, end },
-        );
+impl<'a, C: Codec> ProcMacroClientHandle<'a, C> {
+    fn roundtrip(
+        &mut self,
+        req: bidirectional::SubRequest,
+    ) -> Option<bidirectional::BidirectionalMessage> {
+        let msg = bidirectional::BidirectionalMessage::SubRequest(req);
 
-        if req.write::<_, C>(&mut self.stdout.lock()).is_err() {
+        if msg.write::<_, C>(&mut self.stdout.lock()).is_err() {
             return None;
         }
 
-        let msg = match bidirectional::BidirectionalMessage::read::<_, C>(
-            &mut self.stdin.lock(),
-            self.buf,
-        ) {
-            Ok(Some(msg)) => msg,
-            _ => return None,
-        };
+        match bidirectional::BidirectionalMessage::read::<_, C>(&mut self.stdin.lock(), self.buf) {
+            Ok(Some(msg)) => Some(msg),
+            _ => None,
+        }
+    }
+}
 
-        match msg {
-            bidirectional::BidirectionalMessage::SubResponse(
+impl<C: Codec> proc_macro_srv::ProcMacroClientInterface for ProcMacroClientHandle<'_, C> {
+    fn file(&mut self, file_id: proc_macro_srv::span::FileId) -> String {
+        match self.roundtrip(bidirectional::SubRequest::FilePath { file_id: file_id.index() }) {
+            Some(bidirectional::BidirectionalMessage::SubResponse(
+                bidirectional::SubResponse::FilePathResult { name },
+            )) => name,
+            _ => String::new(),
+        }
+    }
+
+    fn source_text(
+        &mut self,
+        proc_macro_srv::span::Span { range, anchor, ctx: _ }: proc_macro_srv::span::Span,
+    ) -> Option<String> {
+        match self.roundtrip(bidirectional::SubRequest::SourceText {
+            file_id: anchor.file_id.as_u32(),
+            ast_id: anchor.ast_id.into_raw(),
+            start: range.start().into(),
+            end: range.end().into(),
+        }) {
+            Some(bidirectional::BidirectionalMessage::SubResponse(
                 bidirectional::SubResponse::SourceTextResult { text },
-            ) => text,
+            )) => text,
+            _ => None,
+        }
+    }
+
+    fn local_file(&mut self, file_id: proc_macro_srv::span::FileId) -> Option<String> {
+        match self.roundtrip(bidirectional::SubRequest::LocalFilePath { file_id: file_id.index() })
+        {
+            Some(bidirectional::BidirectionalMessage::SubResponse(
+                bidirectional::SubResponse::LocalFilePathResult { name },
+            )) => name,
             _ => None,
         }
     }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
index 17ffa29ce172..f2d1dfbba4cc 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
@@ -53,6 +53,7 @@ use temp_dir::TempDir;
 pub use crate::server_impl::token_id::SpanId;
 
 pub use proc_macro::Delimiter;
+pub use span;
 
 pub use crate::bridge::*;
 pub use crate::server_impl::literal_from_str;
@@ -94,7 +95,9 @@ impl<'env> ProcMacroSrv<'env> {
 pub type ProcMacroClientHandle<'a> = &'a mut (dyn ProcMacroClientInterface + Sync + Send);
 
 pub trait ProcMacroClientInterface {
-    fn source_text(&mut self, file_id: u32, start: u32, end: u32) -> Option<String>;
+    fn file(&mut self, file_id: span::FileId) -> String;
+    fn source_text(&mut self, span: Span) -> Option<String>;
+    fn local_file(&mut self, file_id: span::FileId) -> Option<String>;
 }
 
 const EXPANDER_STACK_SIZE: usize = 8 * 1024 * 1024;
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 5d9090c060e0..32725afc5527 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -127,13 +127,11 @@ impl server::Span for RaSpanServer<'_> {
     fn debug(&mut self, span: Self::Span) -> String {
         format!("{:?}", span)
     }
-    fn file(&mut self, _: Self::Span) -> String {
-        // FIXME
-        String::new()
+    fn file(&mut self, span: Self::Span) -> String {
+        self.callback.as_mut().map(|cb| cb.file(span.anchor.file_id.file_id())).unwrap_or_default()
     }
-    fn local_file(&mut self, _: Self::Span) -> Option<String> {
-        // FIXME
-        None
+    fn local_file(&mut self, span: Self::Span) -> Option<String> {
+        self.callback.as_mut().and_then(|cb| cb.local_file(span.anchor.file_id.file_id()))
     }
     fn save_span(&mut self, _span: Self::Span) -> usize {
         // FIXME, quote is incompatible with third-party tools
@@ -152,11 +150,7 @@ impl server::Span for RaSpanServer<'_> {
     /// See PR:
     /// https://github.com/rust-lang/rust/pull/55780
     fn source_text(&mut self, span: Self::Span) -> Option<String> {
-        let file_id = span.anchor.file_id;
-        let start: u32 = span.range.start().into();
-        let end: u32 = span.range.end().into();
-
-        self.callback.as_mut()?.source_text(file_id.file_id().index(), start, end)
+        self.callback.as_mut()?.source_text(span)
     }
 
     fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lib.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lib.rs
index 971ae2a601f7..4a37bb34aba3 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lib.rs
@@ -16,6 +16,9 @@ extern crate rustc_driver as _;
 
 extern crate ra_ap_rustc_type_ir as rustc_type_ir;
 
+/*
+    If you bump this, grep for `FIXME(MINIMUM_SUPPORTED_TOOLCHAIN_VERSION)` to check for old support code we can drop
+*/
 /// Any toolchain less than this version will likely not work with rust-analyzer built from this revision.
 pub const MINIMUM_SUPPORTED_TOOLCHAIN_VERSION: semver::Version = semver::Version {
     major: 1,
diff --git a/src/tools/rust-analyzer/crates/span/src/hygiene.rs b/src/tools/rust-analyzer/crates/span/src/hygiene.rs
index 6805417177cd..fdfa94dfee4e 100644
--- a/src/tools/rust-analyzer/crates/span/src/hygiene.rs
+++ b/src/tools/rust-analyzer/crates/span/src/hygiene.rs
@@ -19,9 +19,8 @@
 //! # The Call-site Hierarchy
 //!
 //! `ExpnData::call_site` in rustc, [`MacroCallLoc::call_site`] in rust-analyzer.
-use std::fmt;
-
 use crate::Edition;
+use std::fmt;
 
 /// A syntax context describes a hierarchy tracking order of macro definitions.
 #[cfg(feature = "salsa")]
@@ -47,7 +46,7 @@ const _: () = {
         edition: Edition,
         parent: SyntaxContext,
         opaque: SyntaxContext,
-        opaque_and_semitransparent: SyntaxContext,
+        opaque_and_semiopaque: SyntaxContext,
     }
 
     impl PartialEq for SyntaxContextData {
@@ -215,7 +214,7 @@ const _: () = {
             edition: T2,
             parent: T3,
             opaque: impl FnOnce(SyntaxContext) -> SyntaxContext,
-            opaque_and_semitransparent: impl FnOnce(SyntaxContext) -> SyntaxContext,
+            opaque_and_semiopaque: impl FnOnce(SyntaxContext) -> SyntaxContext,
         ) -> Self
         where
             Db: ?Sized + salsa::Database,
@@ -242,7 +241,7 @@ const _: () = {
                     edition: zalsa_::interned::Lookup::into_owned(data.2),
                     parent: zalsa_::interned::Lookup::into_owned(data.3),
                     opaque: opaque(zalsa_::FromId::from_id(id)),
-                    opaque_and_semitransparent: opaque_and_semitransparent(
+                    opaque_and_semiopaque: opaque_and_semiopaque(
                         zalsa_::FromId::from_id(id),
                     ),
                 },
@@ -302,7 +301,7 @@ const _: () = {
             }
         }
 
-        /// This context, but with all transparent and semi-transparent expansions filtered away.
+        /// This context, but with all transparent and semi-opaque expansions filtered away.
         pub fn opaque<Db>(self, db: &'db Db) -> SyntaxContext
         where
             Db: ?Sized + zalsa_::Database,
@@ -318,7 +317,7 @@ const _: () = {
         }
 
         /// This context, but with all transparent expansions filtered away.
-        pub fn opaque_and_semitransparent<Db>(self, db: &'db Db) -> SyntaxContext
+        pub fn opaque_and_semiopaque<Db>(self, db: &'db Db) -> SyntaxContext
         where
             Db: ?Sized + zalsa_::Database,
         {
@@ -326,7 +325,7 @@ const _: () = {
                 Some(id) => {
                     let zalsa = db.zalsa();
                     let fields = SyntaxContext::ingredient(zalsa).data(zalsa, id);
-                    fields.opaque_and_semitransparent
+                    fields.opaque_and_semiopaque
                 }
                 None => self,
             }
@@ -406,7 +405,7 @@ impl<'db> SyntaxContext {
 
     #[inline]
     pub fn normalize_to_macro_rules(self, db: &'db dyn salsa::Database) -> SyntaxContext {
-        self.opaque_and_semitransparent(db)
+        self.opaque_and_semiopaque(db)
     }
 
     pub fn is_opaque(self, db: &'db dyn salsa::Database) -> bool {
@@ -477,13 +476,13 @@ pub enum Transparency {
     /// Identifier produced by a transparent expansion is always resolved at call-site.
     /// Call-site spans in procedural macros, hygiene opt-out in `macro` should use this.
     Transparent,
-    /// Identifier produced by a semi-transparent expansion may be resolved
+    /// Identifier produced by a semi-opaque expansion may be resolved
     /// either at call-site or at definition-site.
     /// If it's a local variable, label or `$crate` then it's resolved at def-site.
     /// Otherwise it's resolved at call-site.
     /// `macro_rules` macros behave like this, built-in macros currently behave like this too,
     /// but that's an implementation detail.
-    SemiTransparent,
+    SemiOpaque,
     /// Identifier produced by an opaque expansion is always resolved at definition-site.
     /// Def-site spans in procedural macros, identifiers from `macro` by default use this.
     Opaque,
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index b9c389c7694e..d81f27d7c3b1 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -738,7 +738,7 @@ struct IdentityProcMacroExpander;
 impl ProcMacroExpander for IdentityProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -761,7 +761,7 @@ struct Issue18089ProcMacroExpander;
 impl ProcMacroExpander for Issue18089ProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -797,7 +797,7 @@ struct AttributeInputReplaceProcMacroExpander;
 impl ProcMacroExpander for AttributeInputReplaceProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         _: &TopSubtree,
         attrs: Option<&TopSubtree>,
         _: &Env,
@@ -821,7 +821,7 @@ struct Issue18840ProcMacroExpander;
 impl ProcMacroExpander for Issue18840ProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         fn_: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -858,7 +858,7 @@ struct MirrorProcMacroExpander;
 impl ProcMacroExpander for MirrorProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         input: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -897,7 +897,7 @@ struct ShortenProcMacroExpander;
 impl ProcMacroExpander for ShortenProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         input: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -942,7 +942,7 @@ struct Issue17479ProcMacroExpander;
 impl ProcMacroExpander for Issue17479ProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -973,7 +973,7 @@ struct Issue18898ProcMacroExpander;
 impl ProcMacroExpander for Issue18898ProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -1027,7 +1027,7 @@ struct DisallowCfgProcMacroExpander;
 impl ProcMacroExpander for DisallowCfgProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &Env,
@@ -1059,7 +1059,7 @@ struct GenerateSuffixedTypeProcMacroExpander;
 impl ProcMacroExpander for GenerateSuffixedTypeProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _attrs: Option<&TopSubtree>,
         _env: &Env,
diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index b7c09391ec37..c3429356d9e5 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -80,6 +80,7 @@
 //!     offset_of:
 
 #![rustc_coherence_is_core]
+#![feature(lang_items)]
 
 pub mod marker {
     // region:sized
@@ -545,11 +546,11 @@ pub mod ptr {
     // endregion:non_null
 
     // region:addr_of
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     pub macro addr_of($place:expr) {
         &raw const $place
     }
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     pub macro addr_of_mut($place:expr) {
         &raw mut $place
     }
diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 00d83e906848..57f6bf69beb0 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -5584,9 +5584,9 @@
             }
         },
         "node_modules/qs": {
-            "version": "6.14.0",
-            "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
-            "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+            "version": "6.14.1",
+            "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
+            "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",
             "dev": true,
             "license": "BSD-3-Clause",
             "dependencies": {
diff --git a/src/tools/rustfmt/src/attr.rs b/src/tools/rustfmt/src/attr.rs
index 381c938ae806..d03d33514046 100644
--- a/src/tools/rustfmt/src/attr.rs
+++ b/src/tools/rustfmt/src/attr.rs
@@ -336,8 +336,8 @@ impl Rewrite for ast::Attribute {
             rewrite_doc_comment(snippet, shape.comment(context.config), context.config)
         } else {
             let should_skip = self
-                .ident()
-                .map(|s| context.skip_context.attributes.skip(s.name.as_str()))
+                .name()
+                .map(|s| context.skip_context.attributes.skip(s.as_str()))
                 .unwrap_or(false);
             let prefix = attr_prefix(self);
 
diff --git a/src/tools/tidy/Cargo.toml b/src/tools/tidy/Cargo.toml
index 47b59543c59c..cbf27ea87a07 100644
--- a/src/tools/tidy/Cargo.toml
+++ b/src/tools/tidy/Cargo.toml
@@ -8,6 +8,7 @@ autobins = false
 build_helper = { path = "../../build_helper" }
 cargo_metadata = "0.21"
 regex = "1"
+globset = "0.4.18"
 miropt-test-tools = { path = "../miropt-test-tools" }
 walkdir = "2"
 ignore = "0.4.18"
diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index a45af7fcf158..1c81a485608a 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -21,13 +21,18 @@ use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str::FromStr;
-use std::{fmt, fs, io};
+use std::{env, fmt, fs, io};
+
+use build_helper::ci::CiEnv;
 
 use crate::CiInfo;
 use crate::diagnostics::TidyCtx;
 
 mod rustdoc_js;
 
+#[cfg(test)]
+mod tests;
+
 const MIN_PY_REV: (u32, u32) = (3, 9);
 const MIN_PY_REV_STR: &str = "≥3.9";
 
@@ -43,6 +48,7 @@ const RUFF_CACHE_PATH: &[&str] = &["cache", "ruff_cache"];
 const PIP_REQ_PATH: &[&str] = &["src", "tools", "tidy", "config", "requirements.txt"];
 
 const SPELLCHECK_DIRS: &[&str] = &["compiler", "library", "src/bootstrap", "src/librustdoc"];
+const SPELLCHECK_VER: &str = "1.38.1";
 
 pub fn check(
     root_path: &Path,
@@ -115,6 +121,7 @@ fn check_impl(
             .collect(),
         None => vec![],
     };
+    lint_args.retain(|ck| ck.is_non_if_installed_or_matches(root_path, outdir));
     if lint_args.iter().any(|ck| ck.auto) {
         crate::files_modified_batch_filter(ci_info, &mut lint_args, |ck, path| {
             ck.is_non_auto_or_matches(path)
@@ -421,21 +428,11 @@ fn py_runner(
 /// Create a virtuaenv at a given path if it doesn't already exist, or validate
 /// the install if it does. Returns the path to that venv's python executable.
 fn get_or_create_venv(venv_path: &Path, src_reqs_path: &Path) -> Result<PathBuf, Error> {
-    let mut should_create = true;
-    let dst_reqs_path = venv_path.join("requirements.txt");
     let mut py_path = venv_path.to_owned();
     py_path.extend(REL_PY_PATH);
 
-    if let Ok(req) = fs::read_to_string(&dst_reqs_path) {
-        if req == fs::read_to_string(src_reqs_path)? {
-            // found existing environment
-            should_create = false;
-        } else {
-            eprintln!("requirements.txt file mismatch, recreating environment");
-        }
-    }
-
-    if should_create {
+    if !has_py_tools(venv_path, src_reqs_path)? {
+        let dst_reqs_path = venv_path.join("requirements.txt");
         eprintln!("removing old virtual environment");
         if venv_path.is_dir() {
             fs::remove_dir_all(venv_path).unwrap_or_else(|_| {
@@ -450,6 +447,18 @@ fn get_or_create_venv(venv_path: &Path, src_reqs_path: &Path) -> Result<PathBuf,
     Ok(py_path)
 }
 
+fn has_py_tools(venv_path: &Path, src_reqs_path: &Path) -> Result<bool, Error> {
+    let dst_reqs_path = venv_path.join("requirements.txt");
+    if let Ok(req) = fs::read_to_string(&dst_reqs_path) {
+        if req == fs::read_to_string(src_reqs_path)? {
+            return Ok(true);
+        }
+        eprintln!("requirements.txt file mismatch");
+    }
+
+    Ok(false)
+}
+
 /// Attempt to create a virtualenv at this path. Cycles through all expected
 /// valid python versions to find one that is installed.
 fn create_venv_at_path(path: &Path) -> Result<(), Error> {
@@ -591,23 +600,26 @@ fn install_requirements(
     Ok(())
 }
 
+/// Returns `Ok` if shellcheck is installed, `Err` otherwise.
+fn has_shellcheck() -> Result<(), Error> {
+    match Command::new("shellcheck").arg("--version").status() {
+        Ok(_) => Ok(()),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Err(Error::MissingReq(
+            "shellcheck",
+            "shell file checks",
+            Some(
+                "see <https://github.com/koalaman/shellcheck#installing> \
+                for installation instructions"
+                    .to_owned(),
+            ),
+        )),
+        Err(e) => Err(e.into()),
+    }
+}
+
 /// Check that shellcheck is installed then run it at the given path
 fn shellcheck_runner(args: &[&OsStr]) -> Result<(), Error> {
-    match Command::new("shellcheck").arg("--version").status() {
-        Ok(_) => (),
-        Err(e) if e.kind() == io::ErrorKind::NotFound => {
-            return Err(Error::MissingReq(
-                "shellcheck",
-                "shell file checks",
-                Some(
-                    "see <https://github.com/koalaman/shellcheck#installing> \
-                    for installation instructions"
-                        .to_owned(),
-                ),
-            ));
-        }
-        Err(e) => return Err(e.into()),
-    }
+    has_shellcheck()?;
 
     let status = Command::new("shellcheck").args(args).status()?;
     if status.success() { Ok(()) } else { Err(Error::FailedCheck("shellcheck")) }
@@ -621,7 +633,7 @@ fn spellcheck_runner(
     args: &[&str],
 ) -> Result<(), Error> {
     let bin_path =
-        crate::ensure_version_or_cargo_install(outdir, cargo, "typos-cli", "typos", "1.38.1")?;
+        ensure_version_or_cargo_install(outdir, cargo, "typos-cli", "typos", SPELLCHECK_VER)?;
     match Command::new(bin_path).current_dir(src_root).args(args).status() {
         Ok(status) => {
             if status.success() {
@@ -675,6 +687,83 @@ fn find_with_extension(
     Ok(output)
 }
 
+/// Check if the given executable is installed and the version is expected.
+fn ensure_version(build_dir: &Path, bin_name: &str, version: &str) -> Result<PathBuf, Error> {
+    let bin_path = build_dir.join("misc-tools").join("bin").join(bin_name);
+
+    match Command::new(&bin_path).arg("--version").output() {
+        Ok(output) => {
+            let Some(v) = str::from_utf8(&output.stdout).unwrap().trim().split_whitespace().last()
+            else {
+                return Err(Error::Generic("version check failed".to_string()));
+            };
+
+            if v != version {
+                return Err(Error::Version { program: "", required: "", installed: v.to_string() });
+            }
+            Ok(bin_path)
+        }
+        Err(e) => Err(Error::Io(e)),
+    }
+}
+
+/// If the given executable is installed with the given version, use that,
+/// otherwise install via cargo.
+fn ensure_version_or_cargo_install(
+    build_dir: &Path,
+    cargo: &Path,
+    pkg_name: &str,
+    bin_name: &str,
+    version: &str,
+) -> Result<PathBuf, Error> {
+    if let Ok(bin_path) = ensure_version(build_dir, bin_name, version) {
+        return Ok(bin_path);
+    }
+
+    eprintln!("building external tool {bin_name} from package {pkg_name}@{version}");
+
+    let tool_root_dir = build_dir.join("misc-tools");
+    let tool_bin_dir = tool_root_dir.join("bin");
+    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
+
+    // use --force to ensure that if the required version is bumped, we update it.
+    // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
+    // modify PATH so that cargo doesn't print a warning telling the user to modify the path.
+    let mut cmd = Command::new(cargo);
+    cmd.args(["install", "--locked", "--force", "--quiet"])
+        .arg("--root")
+        .arg(&tool_root_dir)
+        .arg("--target-dir")
+        .arg(tool_root_dir.join("target"))
+        .arg(format!("{pkg_name}@{version}"))
+        .env(
+            "PATH",
+            env::join_paths(
+                env::split_paths(&env::var("PATH").unwrap())
+                    .chain(std::iter::once(tool_bin_dir.clone())),
+            )
+            .expect("build dir contains invalid char"),
+        );
+
+    // On CI, we set opt-level flag for quicker installation.
+    // Since lower opt-level decreases the tool's performance,
+    // we don't set this option on local.
+    if CiEnv::is_ci() {
+        cmd.env("RUSTFLAGS", "-Copt-level=0");
+    }
+
+    let cargo_exit_code = cmd.spawn()?.wait()?;
+    if !cargo_exit_code.success() {
+        return Err(Error::Generic("cargo install failed".to_string()));
+    }
+    assert!(
+        matches!(bin_path.try_exists(), Ok(true)),
+        "cargo install did not produce the expected binary"
+    );
+    eprintln!("finished building tool {bin_name}");
+    Ok(bin_path)
+}
+
 #[derive(Debug)]
 enum Error {
     Io(io::Error),
@@ -723,7 +812,7 @@ impl From<io::Error> for Error {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 enum ExtraCheckParseError {
     #[allow(dead_code, reason = "shown through Debug")]
     UnknownKind(String),
@@ -736,10 +825,16 @@ enum ExtraCheckParseError {
     Empty,
     /// `auto` specified without lang part.
     AutoRequiresLang,
+    /// `if-installed` specified without lang part.
+    IfInstalledRequiresLang,
 }
 
+#[derive(PartialEq, Debug)]
 struct ExtraCheckArg {
+    /// Only run the check if files to check have been modified.
     auto: bool,
+    /// Only run the check if the requisite software is already installed.
+    if_installed: bool,
     lang: ExtraCheckLang,
     /// None = run all extra checks for the given lang
     kind: Option<ExtraCheckKind>,
@@ -750,6 +845,58 @@ impl ExtraCheckArg {
         self.lang == lang && self.kind.map(|k| k == kind).unwrap_or(true)
     }
 
+    fn is_non_if_installed_or_matches(&self, root_path: &Path, build_dir: &Path) -> bool {
+        if !self.if_installed {
+            return true;
+        }
+
+        match self.lang {
+            ExtraCheckLang::Spellcheck => {
+                match ensure_version(build_dir, "typos", SPELLCHECK_VER) {
+                    Ok(_) => true,
+                    Err(Error::Version { installed, .. }) => {
+                        eprintln!(
+                            "warning: the tool `typos` is detected, but version {installed} doesn't match with the expected version {SPELLCHECK_VER}"
+                        );
+                        false
+                    }
+                    _ => false,
+                }
+            }
+            ExtraCheckLang::Shell => has_shellcheck().is_ok(),
+            ExtraCheckLang::Js => {
+                match self.kind {
+                    Some(ExtraCheckKind::Lint) => {
+                        // If Lint is enabled, check both eslint and es-check.
+                        rustdoc_js::has_tool(build_dir, "eslint")
+                            && rustdoc_js::has_tool(build_dir, "es-check")
+                    }
+                    Some(ExtraCheckKind::Typecheck) => {
+                        // If Typecheck is enabled, check tsc.
+                        rustdoc_js::has_tool(build_dir, "tsc")
+                    }
+                    None => {
+                        // No kind means it will check both Lint and Typecheck.
+                        rustdoc_js::has_tool(build_dir, "eslint")
+                            && rustdoc_js::has_tool(build_dir, "es-check")
+                            && rustdoc_js::has_tool(build_dir, "tsc")
+                    }
+                    Some(_) => unreachable!("js shouldn't have other type of ExtraCheckKind"),
+                }
+            }
+            ExtraCheckLang::Py | ExtraCheckLang::Cpp => {
+                let venv_path = build_dir.join("venv");
+                let mut reqs_path = root_path.to_owned();
+                reqs_path.extend(PIP_REQ_PATH);
+                let Ok(v) = has_py_tools(&venv_path, &reqs_path) else {
+                    return false;
+                };
+
+                v
+            }
+        }
+    }
+
     /// Returns `false` if this is an auto arg and the passed filename does not trigger the auto rule
     fn is_non_auto_or_matches(&self, filepath: &str) -> bool {
         if !self.auto {
@@ -792,22 +939,44 @@ impl FromStr for ExtraCheckArg {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut auto = false;
+        let mut if_installed = false;
         let mut parts = s.split(':');
-        let Some(mut first) = parts.next() else {
-            return Err(ExtraCheckParseError::Empty);
+        let mut first = match parts.next() {
+            Some("") | None => return Err(ExtraCheckParseError::Empty),
+            Some(part) => part,
         };
-        if first == "auto" {
-            let Some(part) = parts.next() else {
-                return Err(ExtraCheckParseError::AutoRequiresLang);
-            };
-            auto = true;
-            first = part;
+
+        // The loop allows users to specify `auto` and `if-installed` in any order.
+        // Both auto:if-installed:<check> and if-installed:auto:<check> are valid.
+        loop {
+            match (first, auto, if_installed) {
+                ("auto", false, _) => {
+                    let Some(part) = parts.next() else {
+                        return Err(ExtraCheckParseError::AutoRequiresLang);
+                    };
+                    auto = true;
+                    first = part;
+                }
+                ("if-installed", _, false) => {
+                    let Some(part) = parts.next() else {
+                        return Err(ExtraCheckParseError::IfInstalledRequiresLang);
+                    };
+                    if_installed = true;
+                    first = part;
+                }
+                _ => break,
+            }
         }
         let second = parts.next();
         if parts.next().is_some() {
             return Err(ExtraCheckParseError::TooManyParts);
         }
-        let arg = Self { auto, lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? };
+        let arg = Self {
+            auto,
+            if_installed,
+            lang: first.parse()?,
+            kind: second.map(|s| s.parse()).transpose()?,
+        };
         if !arg.has_supported_kind() {
             return Err(ExtraCheckParseError::UnsupportedKindForLang);
         }
@@ -816,7 +985,7 @@ impl FromStr for ExtraCheckArg {
     }
 }
 
-#[derive(PartialEq, Copy, Clone)]
+#[derive(PartialEq, Copy, Clone, Debug)]
 enum ExtraCheckLang {
     Py,
     Shell,
@@ -840,7 +1009,7 @@ impl FromStr for ExtraCheckLang {
     }
 }
 
-#[derive(PartialEq, Copy, Clone)]
+#[derive(PartialEq, Copy, Clone, Debug)]
 enum ExtraCheckKind {
     Lint,
     Fmt,
diff --git a/src/tools/tidy/src/extra_checks/rustdoc_js.rs b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
index 944d8a44112f..6ad5a6665071 100644
--- a/src/tools/tidy/src/extra_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
@@ -21,6 +21,11 @@ fn spawn_cmd(cmd: &mut Command) -> Result<Child, io::Error> {
     })
 }
 
+pub(super) fn has_tool(outdir: &Path, name: &str) -> bool {
+    let bin_path = node_module_bin(outdir, name);
+    Command::new(bin_path).arg("--version").status().is_ok()
+}
+
 /// install all js dependencies from package.json.
 pub(super) fn npm_install(root_path: &Path, outdir: &Path, npm: &Path) -> Result<(), super::Error> {
     npm::install(root_path, outdir, npm)?;
diff --git a/src/tools/tidy/src/extra_checks/tests.rs b/src/tools/tidy/src/extra_checks/tests.rs
new file mode 100644
index 000000000000..5d274069a80c
--- /dev/null
+++ b/src/tools/tidy/src/extra_checks/tests.rs
@@ -0,0 +1,86 @@
+use std::str::FromStr;
+
+use crate::extra_checks::{ExtraCheckArg, ExtraCheckKind, ExtraCheckLang, ExtraCheckParseError};
+
+#[test]
+fn test_extra_check_arg_from_str_ok() {
+    let test_cases = [
+        (
+            "auto:if-installed:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "if-installed:auto:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "auto:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: false,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "if-installed:spellcheck",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "spellcheck",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: false,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "js:lint",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: false,
+                lang: ExtraCheckLang::Js,
+                kind: Some(ExtraCheckKind::Lint),
+            },
+        ),
+    ];
+
+    for (s, expected) in test_cases {
+        assert_eq!(ExtraCheckArg::from_str(s), Ok(expected));
+    }
+}
+
+#[test]
+fn test_extra_check_arg_from_str_err() {
+    let test_cases = [
+        ("some:spellcheck", ExtraCheckParseError::UnknownLang("some".to_string())),
+        ("spellcheck:some", ExtraCheckParseError::UnknownKind("some".to_string())),
+        ("spellcheck:lint", ExtraCheckParseError::UnsupportedKindForLang),
+        ("auto:spellcheck:some", ExtraCheckParseError::UnknownKind("some".to_string())),
+        ("auto:js:lint:some", ExtraCheckParseError::TooManyParts),
+        ("some", ExtraCheckParseError::UnknownLang("some".to_string())),
+        ("auto", ExtraCheckParseError::AutoRequiresLang),
+        ("if-installed", ExtraCheckParseError::IfInstalledRequiresLang),
+        ("", ExtraCheckParseError::Empty),
+    ];
+
+    for (s, expected) in test_cases {
+        assert_eq!(ExtraCheckArg::from_str(s), Err(expected));
+    }
+}
diff --git a/src/tools/tidy/src/features.rs b/src/tools/tidy/src/features.rs
index 08061bd834e3..43e6c18382af 100644
--- a/src/tools/tidy/src/features.rs
+++ b/src/tools/tidy/src/features.rs
@@ -107,7 +107,7 @@ pub fn check(
             &tests_path.join("ui"),
             &tests_path.join("ui-fulldeps"),
             &tests_path.join("rustdoc-ui"),
-            &tests_path.join("rustdoc"),
+            &tests_path.join("rustdoc-html"),
         ],
         |path, _is_dir| {
             filter_dirs(path)
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 45187a0b6450..b3e17b73237d 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -379,7 +379,6 @@ ui/borrowck/issue-88434-minimal-example.rs
 ui/borrowck/issue-88434-removal-index-should-be-less.rs
 ui/borrowck/issue-91206.rs
 ui/borrowck/issue-92015.rs
-ui/borrowck/issue-92157.rs
 ui/borrowck/issue-93078.rs
 ui/borrowck/issue-93093.rs
 ui/borrowck/issue-95079-missing-move-in-nested-closure.rs
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 756f9790e04a..425f43e42b7f 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -4,9 +4,7 @@
 //! to be used by tools.
 
 use std::ffi::OsStr;
-use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::{env, io};
 
 use build_helper::ci::CiEnv;
 use build_helper::git::{GitConfig, get_closest_upstream_commit};
@@ -158,77 +156,6 @@ pub fn files_modified(ci_info: &CiInfo, pred: impl Fn(&str) -> bool) -> bool {
     !v.is_empty()
 }
 
-/// If the given executable is installed with the given version, use that,
-/// otherwise install via cargo.
-pub fn ensure_version_or_cargo_install(
-    build_dir: &Path,
-    cargo: &Path,
-    pkg_name: &str,
-    bin_name: &str,
-    version: &str,
-) -> io::Result<PathBuf> {
-    let tool_root_dir = build_dir.join("misc-tools");
-    let tool_bin_dir = tool_root_dir.join("bin");
-    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
-
-    // ignore the process exit code here and instead just let the version number check fail.
-    // we also importantly don't return if the program wasn't installed,
-    // instead we want to continue to the fallback.
-    'ck: {
-        // FIXME: rewrite as if-let chain once this crate is 2024 edition.
-        let Ok(output) = Command::new(&bin_path).arg("--version").output() else {
-            break 'ck;
-        };
-        let Ok(s) = str::from_utf8(&output.stdout) else {
-            break 'ck;
-        };
-        let Some(v) = s.trim().split_whitespace().last() else {
-            break 'ck;
-        };
-        if v == version {
-            return Ok(bin_path);
-        }
-    }
-
-    eprintln!("building external tool {bin_name} from package {pkg_name}@{version}");
-    // use --force to ensure that if the required version is bumped, we update it.
-    // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
-    // modify PATH so that cargo doesn't print a warning telling the user to modify the path.
-    let mut cmd = Command::new(cargo);
-    cmd.args(["install", "--locked", "--force", "--quiet"])
-        .arg("--root")
-        .arg(&tool_root_dir)
-        .arg("--target-dir")
-        .arg(tool_root_dir.join("target"))
-        .arg(format!("{pkg_name}@{version}"))
-        .env(
-            "PATH",
-            env::join_paths(
-                env::split_paths(&env::var("PATH").unwrap())
-                    .chain(std::iter::once(tool_bin_dir.clone())),
-            )
-            .expect("build dir contains invalid char"),
-        );
-
-    // On CI, we set opt-level flag for quicker installation.
-    // Since lower opt-level decreases the tool's performance,
-    // we don't set this option on local.
-    if CiEnv::is_ci() {
-        cmd.env("RUSTFLAGS", "-Copt-level=0");
-    }
-
-    let cargo_exit_code = cmd.spawn()?.wait()?;
-    if !cargo_exit_code.success() {
-        return Err(io::Error::other("cargo install failed"));
-    }
-    assert!(
-        matches!(bin_path.try_exists(), Ok(true)),
-        "cargo install did not produce the expected binary"
-    );
-    eprintln!("finished building tool {bin_name}");
-    Ok(bin_path)
-}
-
 pub mod alphabetical;
 pub mod bins;
 pub mod debug_artifacts;
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index e5945a72d32a..e6423aeeba99 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -24,7 +24,6 @@
 //!   - `sys/`
 //!   - `os/`
 //!
-//! `std/sys_common` should _not_ contain platform-specific code.
 //! Finally, because std contains tests with platform-specific
 //! `ignore` attributes, once the parser encounters `mod tests`,
 //! platform-specific cfgs are allowed. Not sure yet how to deal with
diff --git a/src/tools/tidy/src/triagebot.rs b/src/tools/tidy/src/triagebot.rs
index 01401c94d730..a74d980cfcb7 100644
--- a/src/tools/tidy/src/triagebot.rs
+++ b/src/tools/tidy/src/triagebot.rs
@@ -1,11 +1,23 @@
 //! Tidy check to ensure paths mentioned in triagebot.toml exist in the project.
 
+use std::collections::HashSet;
 use std::path::Path;
+use std::sync::LazyLock;
 
 use toml::Value;
 
 use crate::diagnostics::TidyCtx;
 
+static SUBMODULES: LazyLock<Vec<&'static Path>> = LazyLock::new(|| {
+    // WORKSPACES doesn't list all submodules but it's contains the main at least
+    crate::deps::WORKSPACES
+        .iter()
+        .map(|ws| ws.submodules.iter())
+        .flatten()
+        .map(|p| Path::new(p))
+        .collect()
+});
+
 pub fn check(path: &Path, tidy_ctx: TidyCtx) {
     let mut check = tidy_ctx.start_check("triagebot");
     let triagebot_path = path.join("triagebot.toml");
@@ -22,6 +34,9 @@ pub fn check(path: &Path, tidy_ctx: TidyCtx) {
 
     // Check [mentions."*"] sections, i.e. [mentions."compiler/rustc_const_eval/src/"]
     if let Some(Value::Table(mentions)) = config.get("mentions") {
+        let mut builder = globset::GlobSetBuilder::new();
+        let mut glob_entries = Vec::new();
+
         for (entry_key, entry_val) in mentions.iter() {
             // If the type is set to something other than "filename", then this is not a path.
             if entry_val.get("type").is_some_and(|t| t.as_str().unwrap_or_default() != "filename") {
@@ -33,8 +48,52 @@ pub fn check(path: &Path, tidy_ctx: TidyCtx) {
             let full_path = path.join(clean_path);
 
             if !full_path.exists() {
+                // The full-path doesn't exists, maybe it's a glob, let's add it to the glob set builder
+                // to be checked against all the file and directories in the repository.
+                let trimmed_path = clean_path.trim_end_matches('/');
+                builder.add(globset::Glob::new(&format!("{trimmed_path}{{,/*}}")).unwrap());
+                glob_entries.push(clean_path.to_string());
+            } else if is_in_submodule(Path::new(clean_path)) {
                 check.error(format!(
-                    "triagebot.toml [mentions.*] contains path '{clean_path}' which doesn't exist"
+                    "triagebot.toml [mentions.*] '{clean_path}' cannot match inside a submodule"
+                ));
+            }
+        }
+
+        let gs = builder.build().unwrap();
+
+        let mut found = HashSet::new();
+        let mut matches = Vec::new();
+
+        let cloned_path = path.to_path_buf();
+
+        // Walk the entire repository and match any entry against the remaining paths
+        for entry in ignore::WalkBuilder::new(&path)
+            .filter_entry(move |entry| {
+                // Ignore entries inside submodules as triagebot cannot detect them
+                let entry_path = entry.path().strip_prefix(&cloned_path).unwrap();
+                is_not_in_submodule(entry_path)
+            })
+            .build()
+            .flatten()
+        {
+            // Strip the prefix as mentions entries are always relative to the repo
+            let entry_path = entry.path().strip_prefix(path).unwrap();
+
+            // Find the matches and add them to the found set
+            gs.matches_into(entry_path, &mut matches);
+            found.extend(matches.iter().copied());
+
+            // Early-exist if all the globs have been matched
+            if found.len() == glob_entries.len() {
+                break;
+            }
+        }
+
+        for (i, clean_path) in glob_entries.iter().enumerate() {
+            if !found.contains(&i) {
+                check.error(format!(
+                    "triagebot.toml [mentions.*] contains '{clean_path}' which doesn't match any file or directory in the repository"
                 ));
             }
         }
@@ -93,3 +152,11 @@ pub fn check(path: &Path, tidy_ctx: TidyCtx) {
         }
     }
 }
+
+fn is_not_in_submodule(path: &Path) -> bool {
+    SUBMODULES.contains(&path) || !SUBMODULES.iter().any(|p| path.starts_with(*p))
+}
+
+fn is_in_submodule(path: &Path) -> bool {
+    !SUBMODULES.contains(&path) && SUBMODULES.iter().any(|p| path.starts_with(*p))
+}
diff --git a/src/tools/wasm-component-ld/Cargo.toml b/src/tools/wasm-component-ld/Cargo.toml
index 744b67c17f65..2d44358c7433 100644
--- a/src/tools/wasm-component-ld/Cargo.toml
+++ b/src/tools/wasm-component-ld/Cargo.toml
@@ -10,4 +10,4 @@ name = "wasm-component-ld"
 path = "src/main.rs"
 
 [dependencies]
-wasm-component-ld = "0.5.19"
+wasm-component-ld = "0.5.20"
diff --git a/tests/assembly-llvm/naked-functions/aix.rs b/tests/assembly-llvm/naked-functions/aix.rs
index 3cc84fa0c9c6..8391331d8341 100644
--- a/tests/assembly-llvm/naked-functions/aix.rs
+++ b/tests/assembly-llvm/naked-functions/aix.rs
@@ -9,7 +9,7 @@
 //@[aix] needs-llvm-components: powerpc
 
 #![crate_type = "lib"]
-#![feature(no_core, asm_experimental_arch, f128, linkage, fn_align)]
+#![feature(no_core, asm_experimental_arch)]
 #![no_core]
 
 // tests that naked functions work for the `powerpc64-ibm-aix` target.
diff --git a/tests/assembly-llvm/naked-functions/hidden.rs b/tests/assembly-llvm/naked-functions/hidden.rs
new file mode 100644
index 000000000000..7686dbab07fb
--- /dev/null
+++ b/tests/assembly-llvm/naked-functions/hidden.rs
@@ -0,0 +1,41 @@
+//@ revisions: macos-x86 macos-aarch64 linux-x86
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@[macos-aarch64] compile-flags: --target aarch64-apple-darwin
+//@[macos-aarch64] needs-llvm-components: aarch64
+//
+//@[macos-x86] compile-flags: --target x86_64-apple-darwin
+//@[macos-x86] needs-llvm-components: x86
+//
+//@[linux-x86] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux-x86] needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+// Tests that naked functions that are not externally linked (e.g. via `no_mangle`)
+// are marked as `Visibility::Hidden` and emit `.private_extern` or `.hidden`.
+//
+// Without this directive, LTO may fail because the symbol is not visible.
+// See also https://github.com/rust-lang/rust/issues/148307.
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: .p2align 2
+// macos-x86,macos-aarch64: .private_extern
+// linux-x86: .globl
+// linux-x86: .hidden
+// CHECK: ret
+#[unsafe(naked)]
+extern "C" fn ret() {
+    naked_asm!("ret")
+}
+
+// CHECK-LABEL: entry
+#[no_mangle]
+pub fn entry() {
+    ret()
+}
diff --git a/tests/assembly-llvm/rust-abi-arg-attr.rs b/tests/assembly-llvm/rust-abi-arg-attr.rs
index 4f3673ccfc3b..2d13feb021ba 100644
--- a/tests/assembly-llvm/rust-abi-arg-attr.rs
+++ b/tests/assembly-llvm/rust-abi-arg-attr.rs
@@ -1,3 +1,4 @@
+//@ add-minicore
 //@ assembly-output: emit-asm
 //@ revisions: riscv64 riscv64-zbb loongarch64
 //@ compile-flags: -C opt-level=3
@@ -14,45 +15,8 @@
 #![no_std]
 #![no_core]
 // FIXME: Migrate these code after PR #130693 is landed.
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i8 {}
-impl Copy for u32 {}
-impl Copy for i32 {}
-
-#[lang = "neg"]
-trait Neg {
-    type Output;
-
-    fn neg(self) -> Self::Output;
-}
-
-impl Neg for i8 {
-    type Output = i8;
-
-    fn neg(self) -> Self::Output {
-        -self
-    }
-}
-
-#[lang = "Ordering"]
-#[repr(i8)]
-enum Ordering {
-    Less = -1,
-    Equal = 0,
-    Greater = 1,
-}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_intrinsic]
 fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering;
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 288a5b50dd5e..95b217c13031 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -210,8 +210,16 @@ impl Neg for isize {
     }
 }
 
+impl Neg for i8 {
+    type Output = i8;
+
+    fn neg(self) -> i8 {
+        loop {}
+    }
+}
+
 #[lang = "sync"]
-trait Sync {}
+pub trait Sync {}
 impl_marker_trait!(
     Sync => [
         char, bool,
@@ -280,6 +288,16 @@ pub enum c_void {
     __variant2,
 }
 
+#[lang = "Ordering"]
+#[repr(i8)]
+pub enum Ordering {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+}
+
+impl Copy for Ordering {}
+
 #[lang = "const_param_ty"]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 pub trait ConstParamTy_ {}
diff --git a/tests/codegen-llvm/direct-access-external-data.rs b/tests/codegen-llvm/direct-access-external-data.rs
index 5b2ff41ef052..73dc08dc2b57 100644
--- a/tests/codegen-llvm/direct-access-external-data.rs
+++ b/tests/codegen-llvm/direct-access-external-data.rs
@@ -1,21 +1,48 @@
-//@ only-loongarch64-unknown-linux-gnu
+//@ ignore-powerpc64 (handles dso_local differently)
+//@ ignore-apple (handles dso_local differently)
 
-//@ revisions: DEFAULT DIRECT INDIRECT
+//@ revisions: DEFAULT PIE DIRECT INDIRECT
 //@ [DEFAULT] compile-flags: -C relocation-model=static
-//@ [DIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=yes
+//@ [PIE] compile-flags: -C relocation-model=pie
+//@ [DIRECT] compile-flags: -C relocation-model=pie -Z direct-access-external-data=yes
 //@ [INDIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=no
 
 #![crate_type = "rlib"]
+#![feature(linkage)]
 
-// DEFAULT: @VAR = external {{.*}} global i32
-// DIRECT: @VAR = external dso_local {{.*}} global i32
-// INDIRECT: @VAR = external {{.*}} global i32
+unsafe extern "C" {
+    // CHECK: @VAR = external
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i32
+    safe static VAR: i32;
 
-extern "C" {
-    static VAR: i32;
+    // When "linkage" is used, we generate an indirection global.
+    // Check dso_local is still applied to the actual global.
+    // CHECK: @EXTERNAL = external
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i8
+    #[linkage = "external"]
+    safe static EXTERNAL: *const u32;
+
+    // CHECK: @WEAK = extern_weak
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i8
+    #[linkage = "extern_weak"]
+    safe static WEAK: *const u32;
 }
 
 #[no_mangle]
-pub fn get() -> i32 {
-    unsafe { VAR }
+pub fn refer() {
+    core::hint::black_box(VAR);
+    core::hint::black_box(EXTERNAL);
+    core::hint::black_box(WEAK);
 }
diff --git a/tests/codegen-llvm/gpu_offload/gpu_host.rs b/tests/codegen-llvm/gpu_offload/gpu_host.rs
index b4d17143720a..dcbd65b14427 100644
--- a/tests/codegen-llvm/gpu_offload/gpu_host.rs
+++ b/tests/codegen-llvm/gpu_offload/gpu_host.rs
@@ -1,15 +1,10 @@
-//@ compile-flags: -Zoffload=Enable -Zunstable-options -C opt-level=3  -Clto=fat
+//@ compile-flags: -Zoffload=Test -Zunstable-options -C opt-level=3  -Clto=fat
 //@ no-prefer-dynamic
-//@ needs-enzyme
+//@ needs-offload
 
 // This test is verifying that we generate __tgt_target_data_*_mapper before and after a call to the
 // kernel_1. Better documentation to what each global or variable means is available in the gpu
-// offlaod code, or the LLVM offload documentation. This code does not launch any GPU kernels yet,
-// and will be rewritten once a proper offload frontend has landed.
-//
-// We currently only handle memory transfer for specific calls to functions named `kernel_{num}`,
-// when inside of a function called main. This, too, is a temporary workaround for not having a
-// frontend.
+// offload code, or the LLVM offload documentation.
 
 #![feature(rustc_attrs)]
 #![feature(core_intrinsics)]
@@ -22,6 +17,20 @@ fn main() {
     core::hint::black_box(&x);
 }
 
+#[unsafe(no_mangle)]
+#[inline(never)]
+pub fn kernel_1(x: &mut [f32; 256]) {
+    core::intrinsics::offload(_kernel_1, [256, 1, 1], [32, 1, 1], (x,))
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+pub fn _kernel_1(x: &mut [f32; 256]) {
+    for i in 0..256 {
+        x[i] = 21.0;
+    }
+}
+
 // CHECK: %struct.ident_t = type { i32, i32, i32, i32, ptr }
 // CHECK: %struct.__tgt_offload_entry = type { i64, i16, i16, i32, ptr, ptr, i64, i64, ptr }
 // CHECK: %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
@@ -36,8 +45,9 @@ fn main() {
 // CHECK: @.offloading.entry_name._kernel_1 = internal unnamed_addr constant [10 x i8] c"_kernel_1\00", section ".llvm.rodata.offloading", align 1
 // CHECK: @.offloading.entry._kernel_1 = internal constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @._kernel_1.region_id, ptr @.offloading.entry_name._kernel_1, i64 0, i64 0, ptr null }, section "llvm_offload_entries", align 8
 
-// CHECK: Function Attrs: nounwind
 // CHECK: declare i32 @__tgt_target_kernel(ptr, i64, i32, i32, ptr, ptr)
+// CHECK: declare void @__tgt_register_lib(ptr) local_unnamed_addr
+// CHECK: declare void @__tgt_unregister_lib(ptr) local_unnamed_addr
 
 // CHECK: define{{( dso_local)?}} void @main()
 // CHECK-NEXT: start:
@@ -94,17 +104,3 @@ fn main() {
 // CHECK-NEXT:   call void @__tgt_unregister_lib(ptr nonnull %EmptyDesc)
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
-
-#[unsafe(no_mangle)]
-#[inline(never)]
-pub fn kernel_1(x: &mut [f32; 256]) {
-    core::intrinsics::offload(_kernel_1, [256, 1, 1], [32, 1, 1], (x,))
-}
-
-#[unsafe(no_mangle)]
-#[inline(never)]
-pub fn _kernel_1(x: &mut [f32; 256]) {
-    for i in 0..256 {
-        x[i] = 21.0;
-    }
-}
diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs
new file mode 100644
index 000000000000..9ec4ec8eeb15
--- /dev/null
+++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs
@@ -0,0 +1,174 @@
+// Tests output of multiple permutations of `Option::or`
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+
+#![crate_type = "lib"]
+
+use std::num::NonZero;
+
+// CHECK-LABEL: @or_match_u8
+// CHECK-SAME: (i1{{.+}}%0, i8 %1, i1{{.+}}%optb.0, i8 %optb.1)
+#[no_mangle]
+pub fn or_match_u8(opta: Option<u8>, optb: Option<u8>) -> Option<u8> {
+    // CHECK: start:
+    // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %0, i8 %1, i8 %optb.1
+    // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%0, %optb.0|%optb.0, %0}}
+    // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0
+    // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1
+    // CHECK: ret { i1, i8 } [[R]]
+    match opta {
+        Some(x) => Some(x),
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @or_match_alt_u8
+// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1)
+#[no_mangle]
+pub fn or_match_alt_u8(opta: Option<u8>, optb: Option<u8>) -> Option<u8> {
+    // CHECK: start:
+    // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1
+    // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}}
+    // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0
+    // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1
+    // CHECK: ret { i1, i8 } [[R]]
+    match opta {
+        Some(_) => opta,
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @option_or_u8
+// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1)
+#[no_mangle]
+pub fn option_or_u8(opta: Option<u8>, optb: Option<u8>) -> Option<u8> {
+    // CHECK: start:
+    // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1
+    // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}}
+    // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0
+    // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1
+    // CHECK: ret { i1, i8 } [[R]]
+    opta.or(optb)
+}
+
+// CHECK-LABEL: @if_some_u8
+// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1)
+#[no_mangle]
+pub fn if_some_u8(opta: Option<u8>, optb: Option<u8>) -> Option<u8> {
+    // CHECK: start:
+    // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1
+    // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}}
+    // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0
+    // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1
+    // CHECK: ret { i1, i8 } [[R]]
+    if opta.is_some() { opta } else { optb }
+}
+
+// Tests a case where an input is a type that is represented as `BackendRepr::Memory`
+
+// CHECK-LABEL: @or_match_slice_u8
+// CHECK-SAME: (i16 %0, i16 %1)
+#[no_mangle]
+pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> {
+    // CHECK: start:
+    // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1
+    // CHECK: ret i16 [[R]]
+    match opta {
+        Some(x) => Some(x),
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @or_match_slice_alt_u8
+// CHECK-SAME: (i16 %0, i16 %1)
+#[no_mangle]
+pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> {
+    // CHECK: start:
+    // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1
+    // CHECK: ret i16 [[R]]
+    match opta {
+        Some(_) => opta,
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @option_or_slice_u8
+// CHECK-SAME: (i16 %0, i16 %1)
+#[no_mangle]
+pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> {
+    // CHECK: start:
+    // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1
+    // CHECK: ret i16 [[R]]
+    opta.or(optb)
+}
+
+// CHECK-LABEL: @if_some_slice_u8
+// CHECK-SAME: (i16 %0, i16 %1)
+#[no_mangle]
+pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> {
+    // CHECK: start:
+    // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1
+    // CHECK: ret i16 [[R]]
+    if opta.is_some() { opta } else { optb }
+}
+
+// Test a niche optimization case of `NonZero<u8>`
+
+// CHECK-LABEL: @or_match_nz_u8
+// CHECK-SAME: (i8{{.+}}%0, i8{{.+}}%optb)
+#[no_mangle]
+pub fn or_match_nz_u8(opta: Option<NonZero<u8>>, optb: Option<NonZero<u8>>) -> Option<NonZero<u8>> {
+    // CHECK: start:
+    // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %0, 0
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %0
+    // CHECK: ret i8 [[R]]
+    match opta {
+        Some(x) => Some(x),
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @or_match_alt_nz_u8
+// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb)
+#[no_mangle]
+pub fn or_match_alt_nz_u8(
+    opta: Option<NonZero<u8>>,
+    optb: Option<NonZero<u8>>,
+) -> Option<NonZero<u8>> {
+    // CHECK: start:
+    // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta
+    // CHECK: ret i8 [[R]]
+    match opta {
+        Some(_) => opta,
+        None => optb,
+    }
+}
+
+// CHECK-LABEL: @option_or_nz_u8
+// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb)
+#[no_mangle]
+pub fn option_or_nz_u8(
+    opta: Option<NonZero<u8>>,
+    optb: Option<NonZero<u8>>,
+) -> Option<NonZero<u8>> {
+    // CHECK: start:
+    // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta
+    // CHECK: ret i8 [[R]]
+    opta.or(optb)
+}
+
+// CHECK-LABEL: @if_some_nz_u8
+// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb)
+#[no_mangle]
+pub fn if_some_nz_u8(opta: Option<NonZero<u8>>, optb: Option<NonZero<u8>>) -> Option<NonZero<u8>> {
+    // CHECK: start:
+    // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0
+    // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta
+    // CHECK: ret i8 [[R]]
+    if opta.is_some() { opta } else { optb }
+}
diff --git a/tests/codegen-units/item-collection/opaque-return-impls.rs b/tests/codegen-units/item-collection/opaque-return-impls.rs
index d54951b933fd..54ab656c53db 100644
--- a/tests/codegen-units/item-collection/opaque-return-impls.rs
+++ b/tests/codegen-units/item-collection/opaque-return-impls.rs
@@ -44,7 +44,7 @@ pub fn foo2() -> Box<dyn TestTrait2> {
 //~ MONO_ITEM fn <TestStruct2 as TestTrait2>::test_func2
 //~ MONO_ITEM fn alloc::alloc::exchange_malloc
 //~ MONO_ITEM fn foo2
-//~ MONO_ITEM fn std::alloc::Global::alloc_impl
+//~ MONO_ITEM fn std::alloc::Global::alloc_impl_runtime
 //~ MONO_ITEM fn std::boxed::Box::<TestStruct2>::new
 //~ MONO_ITEM fn std::alloc::Layout::from_size_align_unchecked::precondition_check
 //~ MONO_ITEM fn std::ptr::Alignment::new_unchecked::precondition_check
diff --git a/tests/crashes/132985.rs b/tests/crashes/132985.rs
deleted file mode 100644
index 2735074f44d1..000000000000
--- a/tests/crashes/132985.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ known-bug: #132985
-//@ aux-build:aux132985.rs
-
-#![allow(incomplete_features)]
-#![feature(min_generic_const_args)]
-#![feature(adt_const_params)]
-
-extern crate aux132985;
-use aux132985::Foo;
-
-fn bar<const N: Foo>() {}
-
-fn baz() {
-    bar::<{ Foo }>();
-}
-
-fn main() {}
diff --git a/tests/crashes/133965.rs b/tests/crashes/133965.rs
deleted file mode 100644
index 69f533ccbe98..000000000000
--- a/tests/crashes/133965.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ known-bug: #133965
-//@ needs-rustc-debug-assertions
-
-struct NonGeneric {}
-
-#[derive(Default)]
-struct NonGeneric<'a, const N: usize> {}
-
-pub fn main() {}
diff --git a/tests/crashes/136138.rs b/tests/crashes/136138.rs
deleted file mode 100644
index c3893dc9c8e6..000000000000
--- a/tests/crashes/136138.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ known-bug: #136138
-#![feature(min_generic_const_args)]
-struct U;
-struct S<const N: U>()
-where
-    S<{ U }>:;
-fn main() {}
diff --git a/tests/crashes/136379.rs b/tests/crashes/136379.rs
deleted file mode 100644
index 077b373e3b5d..000000000000
--- a/tests/crashes/136379.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ known-bug: #136379
-#![feature(min_generic_const_args)]
-pub struct S();
-
-impl S {
-    pub fn f() -> [u8; S] {
-        []
-    }
-}
-
-pub fn main() {}
diff --git a/tests/crashes/138132.rs b/tests/crashes/138132.rs
deleted file mode 100644
index 3e31117c526a..000000000000
--- a/tests/crashes/138132.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ known-bug: #138132
-#![feature(min_generic_const_args)]
-struct b(Box<[u8; c]>);
-impl b {
-    fn d(self) {
-        self.0.e()
-    }
-}
-struct c<'a>(&'a u8);
-fn main() {}
diff --git a/tests/crashes/139596.rs b/tests/crashes/139596.rs
deleted file mode 100644
index 590cfddf83e2..000000000000
--- a/tests/crashes/139596.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ known-bug: #139596
-
-#![feature(min_generic_const_args)]
-struct Colour;
-
-struct Led<const C: Colour>;
-
-fn main() {
-    Led::<{ Colour}>;
-}
diff --git a/tests/crashes/mgca/ace-with-const-ctor.rs b/tests/crashes/mgca/ace-with-const-ctor.rs
deleted file mode 100644
index 9e49bca06d52..000000000000
--- a/tests/crashes/mgca/ace-with-const-ctor.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ known-bug: #132980
-// Originally a rustdoc test. Should be moved back there with @has checks
-// readded once fixed.
-// Previous issue (before mgca): https://github.com/rust-lang/rust/issues/105952
-#![crate_name = "foo"]
-#![feature(associated_const_equality, min_generic_const_args)]
-pub enum ParseMode {
-    Raw,
-}
-pub trait Parse {
-    #[type_const]
-    const PARSE_MODE: ParseMode;
-}
-pub trait RenderRaw {}
-
-impl<T: Parse<PARSE_MODE = { ParseMode::Raw }>> RenderRaw for T {}
diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs
index 0dff383be825..ba3a4452041a 100644
--- a/tests/debuginfo/macro-stepping.rs
+++ b/tests/debuginfo/macro-stepping.rs
@@ -14,8 +14,10 @@
 #[macro_use]
 extern crate macro_stepping; // exports new_scope!()
 
-//@ compile-flags:-g -Zmir-enable-passes=-SingleUseConsts
-// SingleUseConsts shouldn't need to be disabled, see #128945
+//@ compile-flags: -g
+// FIXME(#128945): SingleUseConsts shouldn't need to be disabled.
+//@ revisions: default-mir-passes no-SingleUseConsts-mir-pass
+//@ [no-SingleUseConsts-mir-pass] compile-flags: -Zmir-enable-passes=-SingleUseConsts
 
 // === GDB TESTS ===================================================================================
 
@@ -48,7 +50,7 @@ extern crate macro_stepping; // exports new_scope!()
 //@ gdb-check:[...]#inc-loc2[...]
 //@ gdb-command:next
 //@ gdb-command:frame
-//@ gdb-check:[...]#inc-loc3[...]
+//@ [no-SingleUseConsts-mir-pass] gdb-check:[...]#inc-loc3[...]
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/incremental/const-generic-type-cycle.rs b/tests/incremental/const-generic-type-cycle.rs
index 40a40ebd13fe..5bcbc1d5dafe 100644
--- a/tests/incremental/const-generic-type-cycle.rs
+++ b/tests/incremental/const-generic-type-cycle.rs
@@ -14,7 +14,6 @@ trait Bar<const N: usize> {}
 trait Bar<const N: dyn BB> {}
 //[cfail]~^ ERROR cycle detected when computing type of `Bar::N`
 //[cfail]~| ERROR cycle detected when computing type of `Bar::N`
-//[cfail]~| ERROR cycle detected when computing type of `Bar::N`
 //[cfail]~| ERROR `(dyn Bar<{ 2 + 1 }> + 'static)` is forbidden as the type of a const generic parameter
 
 trait BB = Bar<{ 2 + 1 }>;
diff --git a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
index a1fe278c6520..40527446e5dd 100644
--- a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
@@ -1,36 +1,36 @@
 // MIR for `address_of_reborrow` after SimplifyCfg-initial
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
-| 1: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:10:10: 10:25, inferred_ty: *const dyn std::marker::Send
-| 2: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
-| 3: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
-| 4: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
-| 5: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
-| 6: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
-| 7: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
-| 8: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
-| 9: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
-| 10: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
-| 11: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:21:10: 21:25, inferred_ty: *const dyn std::marker::Send
-| 12: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
-| 13: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
-| 14: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
-| 15: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
-| 16: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
-| 17: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
-| 18: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
-| 19: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
-| 20: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
-| 21: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:31:10: 31:23, inferred_ty: *mut dyn std::marker::Send
-| 22: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
-| 23: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
-| 24: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
-| 25: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
-| 26: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
-| 27: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
-| 28: user_ty: Canonical { value: Ty(*mut [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:37:12: 37:22, inferred_ty: *mut [i32]
-| 29: user_ty: Canonical { value: Ty(*mut [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:37:12: 37:22, inferred_ty: *mut [i32]
+| 0: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
+| 1: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:10:10: 10:25, inferred_ty: *const dyn std::marker::Send
+| 2: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 3: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 4: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
+| 5: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
+| 6: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
+| 7: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
+| 8: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
+| 9: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
+| 10: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
+| 11: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:21:10: 21:25, inferred_ty: *const dyn std::marker::Send
+| 12: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 13: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 14: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
+| 15: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
+| 16: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
+| 17: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
+| 18: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
+| 19: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
+| 20: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
+| 21: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:31:10: 31:23, inferred_ty: *mut dyn std::marker::Send
+| 22: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 23: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, var_kinds: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 24: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
+| 25: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
+| 26: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
+| 27: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, var_kinds: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
+| 28: user_ty: Canonical { value: Ty(*mut [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:37:12: 37:22, inferred_ty: *mut [i32]
+| 29: user_ty: Canonical { value: Ty(*mut [i32]), max_universe: U0, var_kinds: [] }, span: $DIR/address_of.rs:37:12: 37:22, inferred_ty: *mut [i32]
 |
 fn address_of_reborrow() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
index b9d26c67538e..aa7d75242b40 100644
--- a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
@@ -1,8 +1,8 @@
 // MIR for `main` after SimplifyCfg-initial
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(std::option::Option<std::boxed::Box<u32>>), max_universe: U0, variables: [] }, span: $DIR/basic_assignment.rs:38:17: 38:33, inferred_ty: std::option::Option<std::boxed::Box<u32>>
-| 1: user_ty: Canonical { value: Ty(std::option::Option<std::boxed::Box<u32>>), max_universe: U0, variables: [] }, span: $DIR/basic_assignment.rs:38:17: 38:33, inferred_ty: std::option::Option<std::boxed::Box<u32>>
+| 0: user_ty: Canonical { value: Ty(std::option::Option<std::boxed::Box<u32>>), max_universe: U0, var_kinds: [] }, span: $DIR/basic_assignment.rs:38:17: 38:33, inferred_ty: std::option::Option<std::boxed::Box<u32>>
+| 1: user_ty: Canonical { value: Ty(std::option::Option<std::boxed::Box<u32>>), max_universe: U0, var_kinds: [] }, span: $DIR/basic_assignment.rs:38:17: 38:33, inferred_ty: std::option::Option<std::boxed::Box<u32>>
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/issue_101867.main.built.after.mir b/tests/mir-opt/building/issue_101867.main.built.after.mir
index fa35658a16d4..83281dea44db 100644
--- a/tests/mir-opt/building/issue_101867.main.built.after.mir
+++ b/tests/mir-opt/building/issue_101867.main.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `main` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(std::option::Option<u8>), max_universe: U0, variables: [] }, span: $DIR/issue_101867.rs:5:12: 5:22, inferred_ty: std::option::Option<u8>
-| 1: user_ty: Canonical { value: Ty(std::option::Option<u8>), max_universe: U0, variables: [] }, span: $DIR/issue_101867.rs:5:12: 5:22, inferred_ty: std::option::Option<u8>
+| 0: user_ty: Canonical { value: Ty(std::option::Option<u8>), max_universe: U0, var_kinds: [] }, span: $DIR/issue_101867.rs:5:12: 5:22, inferred_ty: std::option::Option<u8>
+| 1: user_ty: Canonical { value: Ty(std::option::Option<u8>), max_universe: U0, var_kinds: [] }, span: $DIR/issue_101867.rs:5:12: 5:22, inferred_ty: std::option::Option<u8>
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
index 5cf182c21c31..0c73bd8ac654 100644
--- a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
+++ b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
@@ -1,10 +1,10 @@
 // MIR for `main` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(*mut Test), max_universe: U0, variables: [] }, span: $DIR/receiver_ptr_mutability.rs:16:14: 16:23, inferred_ty: *mut Test
-| 1: user_ty: Canonical { value: Ty(*mut Test), max_universe: U0, variables: [] }, span: $DIR/receiver_ptr_mutability.rs:16:14: 16:23, inferred_ty: *mut Test
-| 2: user_ty: Canonical { value: Ty(&&&&*mut Test), max_universe: U0, variables: [Region(U0), Region(U0), Region(U0), Region(U0)] }, span: $DIR/receiver_ptr_mutability.rs:20:18: 20:31, inferred_ty: &&&&*mut Test
-| 3: user_ty: Canonical { value: Ty(&&&&*mut Test), max_universe: U0, variables: [Region(U0), Region(U0), Region(U0), Region(U0)] }, span: $DIR/receiver_ptr_mutability.rs:20:18: 20:31, inferred_ty: &&&&*mut Test
+| 0: user_ty: Canonical { value: Ty(*mut Test), max_universe: U0, var_kinds: [] }, span: $DIR/receiver_ptr_mutability.rs:16:14: 16:23, inferred_ty: *mut Test
+| 1: user_ty: Canonical { value: Ty(*mut Test), max_universe: U0, var_kinds: [] }, span: $DIR/receiver_ptr_mutability.rs:16:14: 16:23, inferred_ty: *mut Test
+| 2: user_ty: Canonical { value: Ty(&&&&*mut Test), max_universe: U0, var_kinds: [Region(U0), Region(U0), Region(U0), Region(U0)] }, span: $DIR/receiver_ptr_mutability.rs:20:18: 20:31, inferred_ty: &&&&*mut Test
+| 3: user_ty: Canonical { value: Ty(&&&&*mut Test), max_universe: U0, var_kinds: [Region(U0), Region(U0), Region(U0), Region(U0)] }, span: $DIR/receiver_ptr_mutability.rs:20:18: 20:31, inferred_ty: &&&&*mut Test
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
index bbf504d311f6..4b6aa46129a4 100644
--- a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `let_else` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:36:20: 36:45, inferred_ty: (u32, u64, &char)
-| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:36:20: 36:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:36:20: 36:45, inferred_ty: (u32, u64, &char)
+| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:36:20: 36:45, inferred_ty: (u32, u64, &char)
 |
 fn let_else() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
index 7bf2551e99f2..3814980b4306 100644
--- a/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `let_else_bindless` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:41:20: 41:45, inferred_ty: (u32, u64, &char)
-| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:41:20: 41:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:41:20: 41:45, inferred_ty: (u32, u64, &char)
+| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:41:20: 41:45, inferred_ty: (u32, u64, &char)
 |
 fn let_else_bindless() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_init.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_init.built.after.mir
index 0cf681d8ab2c..dd05ef37de3c 100644
--- a/tests/mir-opt/building/user_type_annotations.let_init.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_init.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `let_init` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:26:20: 26:45, inferred_ty: (u32, u64, &char)
-| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:26:20: 26:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:26:20: 26:45, inferred_ty: (u32, u64, &char)
+| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:26:20: 26:45, inferred_ty: (u32, u64, &char)
 |
 fn let_init() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_init_bindless.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_init_bindless.built.after.mir
index 968813c826e4..d949e1945339 100644
--- a/tests/mir-opt/building/user_type_annotations.let_init_bindless.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_init_bindless.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `let_init_bindless` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:31:20: 31:45, inferred_ty: (u32, u64, &char)
-| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:31:20: 31:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:31:20: 31:45, inferred_ty: (u32, u64, &char)
+| 1: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:31:20: 31:45, inferred_ty: (u32, u64, &char)
 |
 fn let_init_bindless() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_uninit.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_uninit.built.after.mir
index b6fdc4ff46dc..22bf17bd7898 100644
--- a/tests/mir-opt/building/user_type_annotations.let_uninit.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_uninit.built.after.mir
@@ -1,7 +1,7 @@
 // MIR for `let_uninit` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:16:20: 16:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:16:20: 16:45, inferred_ty: (u32, u64, &char)
 |
 fn let_uninit() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.let_uninit_bindless.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_uninit_bindless.built.after.mir
index 472dbfb63043..aad2de0e7d6e 100644
--- a/tests/mir-opt/building/user_type_annotations.let_uninit_bindless.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_uninit_bindless.built.after.mir
@@ -1,7 +1,7 @@
 // MIR for `let_uninit_bindless` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:21:20: 21:45, inferred_ty: (u32, u64, &char)
+| 0: user_ty: Canonical { value: Ty((u32, u64, &'static char)), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:21:20: 21:45, inferred_ty: (u32, u64, &char)
 |
 fn let_uninit_bindless() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.match_assoc_const.built.after.mir b/tests/mir-opt/building/user_type_annotations.match_assoc_const.built.after.mir
index ff4b0bf7600d..8ec5028250b0 100644
--- a/tests/mir-opt/building/user_type_annotations.match_assoc_const.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.match_assoc_const.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `match_assoc_const` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:55:9: 55:44, inferred_ty: u32
-| 1: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:55:9: 55:44, inferred_ty: u32
+| 0: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:55:9: 55:44, inferred_ty: u32
+| 1: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:55:9: 55:44, inferred_ty: u32
 |
 fn match_assoc_const() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/building/user_type_annotations.match_assoc_const_range.built.after.mir b/tests/mir-opt/building/user_type_annotations.match_assoc_const_range.built.after.mir
index 4cc433f475f6..61e5d9b459d0 100644
--- a/tests/mir-opt/building/user_type_annotations.match_assoc_const_range.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.match_assoc_const_range.built.after.mir
@@ -1,10 +1,10 @@
 // MIR for `match_assoc_const_range` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:63:11: 63:46, inferred_ty: u32
-| 1: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:63:11: 63:46, inferred_ty: u32
-| 2: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:64:9: 64:44, inferred_ty: u32
-| 3: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/user_type_annotations.rs:64:9: 64:44, inferred_ty: u32
+| 0: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:63:11: 63:46, inferred_ty: u32
+| 1: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:63:11: 63:46, inferred_ty: u32
+| 2: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:64:9: 64:44, inferred_ty: u32
+| 3: user_ty: Canonical { value: TypeOf(DefId(0:11 ~ user_type_annotations[ee8e]::MyTrait::FOO), UserArgs { args: [MyStruct, 'static], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/user_type_annotations.rs:64:9: 64:44, inferred_ty: u32
 |
 fn match_assoc_const_range() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
index 2aa92fd34ebf..bcf0ad7c165f 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
@@ -26,12 +26,12 @@
                   scope 4 {
                       debug _x => _8;
                   }
-                  scope 18 (inlined foo) {
+                  scope 19 (inlined foo) {
                       let mut _27: *const [()];
                   }
               }
-              scope 16 (inlined slice_from_raw_parts::<()>) {
-                  scope 17 (inlined std::ptr::from_raw_parts::<[()], ()>) {
+              scope 17 (inlined slice_from_raw_parts::<()>) {
+                  scope 18 (inlined std::ptr::from_raw_parts::<[()], ()>) {
                   }
               }
           }
@@ -49,19 +49,21 @@
               scope 7 {
                   let _21: std::ptr::NonNull<[u8]>;
                   scope 8 {
-                      scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) {
-                          scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) {
-                              scope 13 (inlined NonNull::<[u8]>::cast::<u8>) {
+                      scope 12 (inlined NonNull::<[u8]>::as_mut_ptr) {
+                          scope 13 (inlined NonNull::<[u8]>::as_non_null_ptr) {
+                              scope 14 (inlined NonNull::<[u8]>::cast::<u8>) {
                                   let mut _25: *mut [u8];
-                                  scope 14 (inlined NonNull::<[u8]>::as_ptr) {
+                                  scope 15 (inlined NonNull::<[u8]>::as_ptr) {
                                   }
                               }
                           }
-                          scope 15 (inlined NonNull::<u8>::as_ptr) {
+                          scope 16 (inlined NonNull::<u8>::as_ptr) {
                           }
                       }
                   }
                   scope 10 (inlined <std::alloc::Global as Allocator>::allocate) {
+                      scope 11 (inlined std::alloc::Global::alloc_impl) {
+                      }
                   }
               }
               scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) {
@@ -192,8 +194,8 @@
 +         _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
           StorageDead(_24);
           StorageLive(_19);
--         _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable];
-+         _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
+-         _19 = std::alloc::Global::alloc_impl_runtime(copy _18, const false) -> [return: bb7, unwind unreachable];
++         _19 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
index 408ff60712e1..1b75a2bcba8b 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
@@ -26,12 +26,12 @@
                   scope 4 {
                       debug _x => _8;
                   }
-                  scope 18 (inlined foo) {
+                  scope 19 (inlined foo) {
                       let mut _27: *const [()];
                   }
               }
-              scope 16 (inlined slice_from_raw_parts::<()>) {
-                  scope 17 (inlined std::ptr::from_raw_parts::<[()], ()>) {
+              scope 17 (inlined slice_from_raw_parts::<()>) {
+                  scope 18 (inlined std::ptr::from_raw_parts::<[()], ()>) {
                   }
               }
           }
@@ -49,19 +49,21 @@
               scope 7 {
                   let _21: std::ptr::NonNull<[u8]>;
                   scope 8 {
-                      scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) {
-                          scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) {
-                              scope 13 (inlined NonNull::<[u8]>::cast::<u8>) {
+                      scope 12 (inlined NonNull::<[u8]>::as_mut_ptr) {
+                          scope 13 (inlined NonNull::<[u8]>::as_non_null_ptr) {
+                              scope 14 (inlined NonNull::<[u8]>::cast::<u8>) {
                                   let mut _25: *mut [u8];
-                                  scope 14 (inlined NonNull::<[u8]>::as_ptr) {
+                                  scope 15 (inlined NonNull::<[u8]>::as_ptr) {
                                   }
                               }
                           }
-                          scope 15 (inlined NonNull::<u8>::as_ptr) {
+                          scope 16 (inlined NonNull::<u8>::as_ptr) {
                           }
                       }
                   }
                   scope 10 (inlined <std::alloc::Global as Allocator>::allocate) {
+                      scope 11 (inlined std::alloc::Global::alloc_impl) {
+                      }
                   }
               }
               scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) {
@@ -192,8 +194,8 @@
 +         _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
           StorageDead(_24);
           StorageLive(_19);
--         _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable];
-+         _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
+-         _19 = std::alloc::Global::alloc_impl_runtime(copy _18, const false) -> [return: bb7, unwind unreachable];
++         _19 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
diff --git a/tests/mir-opt/issue_72181_1.main.built.after.mir b/tests/mir-opt/issue_72181_1.main.built.after.mir
index 79eaf9668330..398a4bcb3ab3 100644
--- a/tests/mir-opt/issue_72181_1.main.built.after.mir
+++ b/tests/mir-opt/issue_72181_1.main.built.after.mir
@@ -1,8 +1,8 @@
 // MIR for `main` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(Void), max_universe: U0, variables: [] }, span: $DIR/issue_72181_1.rs:17:12: 17:16, inferred_ty: Void
-| 1: user_ty: Canonical { value: Ty(Void), max_universe: U0, variables: [] }, span: $DIR/issue_72181_1.rs:17:12: 17:16, inferred_ty: Void
+| 0: user_ty: Canonical { value: Ty(Void), max_universe: U0, var_kinds: [] }, span: $DIR/issue_72181_1.rs:17:12: 17:16, inferred_ty: Void
+| 1: user_ty: Canonical { value: Ty(Void), max_universe: U0, var_kinds: [] }, span: $DIR/issue_72181_1.rs:17:12: 17:16, inferred_ty: Void
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/issue_99325.main.built.after.32bit.mir b/tests/mir-opt/issue_99325.main.built.after.32bit.mir
index 48a399eb39ce..9e48cf038bf2 100644
--- a/tests/mir-opt/issue_99325.main.built.after.32bit.mir
+++ b/tests/mir-opt/issue_99325.main.built.after.32bit.mir
@@ -1,8 +1,8 @@
 // MIR for `main` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [&*b"AAAA"], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/issue_99325.rs:13:16: 13:46, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
-| 1: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [UnevaluatedConst { def: DefId(0:8 ~ issue_99325[d56d]::main::{constant#1}), args: [] }], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/issue_99325.rs:14:16: 14:68, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
+| 0: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [&*b"AAAA"], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/issue_99325.rs:13:16: 13:46, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
+| 1: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [UnevaluatedConst { def: DefId(0:8 ~ issue_99325[d56d]::main::{constant#1}), args: [] }], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/issue_99325.rs:14:16: 14:68, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/issue_99325.main.built.after.64bit.mir b/tests/mir-opt/issue_99325.main.built.after.64bit.mir
index 48a399eb39ce..9e48cf038bf2 100644
--- a/tests/mir-opt/issue_99325.main.built.after.64bit.mir
+++ b/tests/mir-opt/issue_99325.main.built.after.64bit.mir
@@ -1,8 +1,8 @@
 // MIR for `main` after built
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [&*b"AAAA"], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/issue_99325.rs:13:16: 13:46, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
-| 1: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [UnevaluatedConst { def: DefId(0:8 ~ issue_99325[d56d]::main::{constant#1}), args: [] }], user_self_ty: None }), max_universe: U0, variables: [] }, span: $DIR/issue_99325.rs:14:16: 14:68, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
+| 0: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [&*b"AAAA"], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/issue_99325.rs:13:16: 13:46, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
+| 1: user_ty: Canonical { value: TypeOf(DefId(0:3 ~ issue_99325[d56d]::function_with_bytes), UserArgs { args: [UnevaluatedConst { def: DefId(0:8 ~ issue_99325[d56d]::main::{constant#1}), args: [] }], user_self_ty: None }), max_universe: U0, var_kinds: [] }, span: $DIR/issue_99325.rs:14:16: 14:68, inferred_ty: fn() -> &'static [u8] {function_with_bytes::<&*b"AAAA">}
 |
 fn main() -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-abort.diff
index 8777ac426d78..3cf28f4b60af 100644
--- a/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-abort.diff
@@ -48,8 +48,8 @@
                   let _29: &str;
                   scope 7 (inlined String::as_str) {
                       let _30: &[u8];
-                      let mut _31: &std::vec::Vec<u8>;
                       scope 8 (inlined Vec::<u8>::as_slice) {
+                          let _31: *const [u8];
                           let mut _32: *const u8;
                           let mut _33: usize;
                           scope 9 (inlined Vec::<u8>::as_ptr) {
@@ -71,160 +71,86 @@
                                   }
                               }
                           }
-                          scope 18 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                              let _35: ();
-                              let mut _36: *mut ();
-                              let _37: *const [u8];
-                              scope 19 (inlined ub_checks::check_language_ub) {
-                                  scope 20 (inlined ub_checks::check_language_ub::runtime) {
-                                  }
-                              }
-                              scope 21 (inlined std::mem::size_of::<u8>) {
-                              }
-                              scope 22 (inlined std::mem::align_of::<u8>) {
-                              }
-                              scope 23 (inlined slice_from_raw_parts::<u8>) {
-                                  scope 24 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                                  }
-                              }
-                          }
                       }
-                      scope 25 (inlined from_utf8_unchecked) {
+                      scope 18 (inlined from_utf8_unchecked) {
                       }
                   }
-                  scope 26 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+                  scope 19 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 27 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
-                  scope 28 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+              scope 20 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
+                  scope 21 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 29 (inlined core::str::traits::<impl PartialEq for str>::eq) {
-                  let mut _38: &&[u8];
-                  let _39: &[u8];
-                  let mut _40: &&[u8];
-                  let _41: &[u8];
-                  scope 30 (inlined core::str::<impl str>::as_bytes) {
+              scope 22 (inlined core::str::traits::<impl PartialEq for str>::eq) {
+                  let mut _35: &&[u8];
+                  let _36: &[u8];
+                  let mut _37: &&[u8];
+                  let _38: &[u8];
+                  scope 23 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 31 (inlined core::str::<impl str>::as_bytes) {
+                  scope 24 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 32 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
-                      scope 33 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
-                          scope 34 (inlined <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal) {
-                              let mut _42: bool;
-                              let mut _43: usize;
-                              let mut _44: usize;
-                              let _45: usize;
-                              let mut _46: i32;
-                              let mut _47: *const u8;
-                              let mut _48: *const u8;
-                              scope 35 {
-                                  scope 37 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _50: *const [u8];
-                                  }
-                                  scope 38 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _51: *const [u8];
-                                  }
-                              }
-                              scope 36 (inlined std::mem::size_of_val::<[u8]>) {
-                                  let mut _49: *const [u8];
-                              }
-                          }
+                  scope 25 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
+                      scope 26 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
                       }
                   }
               }
           }
       }
-      scope 39 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) {
-          let mut _52: &std::string::String;
-          let mut _53: &str;
-          scope 40 (inlined <String as PartialEq<str>>::eq) {
-              scope 41 (inlined #[track_caller] <String as Index<RangeFull>>::index) {
-                  let _54: &str;
-                  scope 42 (inlined String::as_str) {
-                      let _55: &[u8];
-                      let mut _56: &std::vec::Vec<u8>;
-                      scope 43 (inlined Vec::<u8>::as_slice) {
-                          let mut _57: *const u8;
-                          let mut _58: usize;
-                          scope 44 (inlined Vec::<u8>::as_ptr) {
-                              scope 45 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
-                                  scope 46 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
-                                      scope 47 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
-                                          let mut _59: std::ptr::NonNull<u8>;
-                                          scope 48 (inlined Unique::<u8>::cast::<u8>) {
-                                              scope 49 (inlined NonNull::<u8>::cast::<u8>) {
-                                                  scope 50 (inlined NonNull::<u8>::as_ptr) {
+      scope 27 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) {
+          let mut _39: &std::string::String;
+          let mut _40: &str;
+          scope 28 (inlined <String as PartialEq<str>>::eq) {
+              scope 29 (inlined #[track_caller] <String as Index<RangeFull>>::index) {
+                  let _41: &str;
+                  scope 30 (inlined String::as_str) {
+                      let _42: &[u8];
+                      scope 31 (inlined Vec::<u8>::as_slice) {
+                          let _43: *const [u8];
+                          let mut _44: *const u8;
+                          let mut _45: usize;
+                          scope 32 (inlined Vec::<u8>::as_ptr) {
+                              scope 33 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
+                                  scope 34 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
+                                      scope 35 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
+                                          let mut _46: std::ptr::NonNull<u8>;
+                                          scope 36 (inlined Unique::<u8>::cast::<u8>) {
+                                              scope 37 (inlined NonNull::<u8>::cast::<u8>) {
+                                                  scope 38 (inlined NonNull::<u8>::as_ptr) {
                                                   }
                                               }
                                           }
-                                          scope 51 (inlined Unique::<u8>::as_non_null_ptr) {
+                                          scope 39 (inlined Unique::<u8>::as_non_null_ptr) {
                                           }
                                       }
-                                      scope 52 (inlined NonNull::<u8>::as_ptr) {
+                                      scope 40 (inlined NonNull::<u8>::as_ptr) {
                                       }
                                   }
                               }
                           }
-                          scope 53 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                              let _60: ();
-                              let mut _61: *mut ();
-                              let _62: *const [u8];
-                              scope 54 (inlined ub_checks::check_language_ub) {
-                                  scope 55 (inlined ub_checks::check_language_ub::runtime) {
-                                  }
-                              }
-                              scope 56 (inlined std::mem::size_of::<u8>) {
-                              }
-                              scope 57 (inlined std::mem::align_of::<u8>) {
-                              }
-                              scope 58 (inlined slice_from_raw_parts::<u8>) {
-                                  scope 59 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                                  }
-                              }
-                          }
                       }
-                      scope 60 (inlined from_utf8_unchecked) {
+                      scope 41 (inlined from_utf8_unchecked) {
                       }
                   }
-                  scope 61 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+                  scope 42 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 62 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
-                  scope 63 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+              scope 43 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
+                  scope 44 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 64 (inlined core::str::traits::<impl PartialEq for str>::eq) {
-                  let mut _63: &&[u8];
-                  let _64: &[u8];
-                  let mut _65: &&[u8];
-                  let _66: &[u8];
-                  scope 65 (inlined core::str::<impl str>::as_bytes) {
+              scope 45 (inlined core::str::traits::<impl PartialEq for str>::eq) {
+                  let mut _47: &&[u8];
+                  let _48: &[u8];
+                  let mut _49: &&[u8];
+                  let _50: &[u8];
+                  scope 46 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 66 (inlined core::str::<impl str>::as_bytes) {
+                  scope 47 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 67 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
-                      scope 68 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
-                          scope 69 (inlined <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal) {
-                              let mut _67: bool;
-                              let mut _68: usize;
-                              let mut _69: usize;
-                              let _70: usize;
-                              let mut _71: i32;
-                              let mut _72: *const u8;
-                              let mut _73: *const u8;
-                              scope 70 {
-                                  scope 72 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _75: *const [u8];
-                                  }
-                                  scope 73 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _76: *const [u8];
-                                  }
-                              }
-                              scope 71 (inlined std::mem::size_of_val::<[u8]>) {
-                                  let mut _74: *const [u8];
-                              }
-                          }
+                  scope 48 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
+                      scope 49 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
                       }
                   }
               }
@@ -253,7 +179,7 @@
       bb3: {
           _1 = chained_conditions::BacktraceStyle::Off;
 -         goto -> bb18;
-+         goto -> bb37;
++         goto -> bb23;
       }
   
       bb4: {
@@ -272,15 +198,27 @@
           _27 = copy (*_8);
           _28 = copy (*_10);
           StorageLive(_29);
-          StorageLive(_35);
           StorageLive(_30);
-          StorageLive(_34);
+          StorageLive(_31);
           StorageLive(_32);
+          StorageLive(_34);
           _34 = copy ((((((*_27).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
           _32 = copy _34 as *const u8 (Transmute);
+          StorageDead(_34);
           StorageLive(_33);
           _33 = copy (((*_27).0: std::vec::Vec<u8>).1: usize);
-          switchInt(UbChecks) -> [0: bb21, otherwise: bb19];
+          _31 = *const [u8] from (copy _32, move _33);
+          StorageDead(_33);
+          StorageDead(_32);
+          _30 = &(*_31);
+          StorageDead(_31);
+          _29 = copy _30 as &str (Transmute);
+          StorageDead(_30);
+          StorageLive(_36);
+          StorageLive(_38);
+          _36 = copy _29 as &[u8] (Transmute);
+          _38 = copy _28 as &[u8] (Transmute);
+          _7 = <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal(move _36, move _38) -> [return: bb19, unwind unreachable];
       }
   
       bb5: {
@@ -311,27 +249,39 @@
           StorageLive(_17);
           _20 = const chained_conditions::promoted[0];
           _17 = &(*_20);
-          StorageLive(_52);
-          StorageLive(_53);
-          _52 = copy (*_15);
-          _53 = copy (*_17);
-          StorageLive(_54);
-          StorageLive(_60);
-          StorageLive(_55);
-          StorageLive(_59);
-          StorageLive(_57);
-          _59 = copy ((((((*_52).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-          _57 = copy _59 as *const u8 (Transmute);
-          StorageLive(_58);
-          _58 = copy (((*_52).0: std::vec::Vec<u8>).1: usize);
-          switchInt(UbChecks) -> [0: bb29, otherwise: bb27];
+          StorageLive(_39);
+          StorageLive(_40);
+          _39 = copy (*_15);
+          _40 = copy (*_17);
+          StorageLive(_41);
+          StorageLive(_42);
+          StorageLive(_43);
+          StorageLive(_44);
+          StorageLive(_46);
+          _46 = copy ((((((*_39).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+          _44 = copy _46 as *const u8 (Transmute);
+          StorageDead(_46);
+          StorageLive(_45);
+          _45 = copy (((*_39).0: std::vec::Vec<u8>).1: usize);
+          _43 = *const [u8] from (copy _44, move _45);
+          StorageDead(_45);
+          StorageDead(_44);
+          _42 = &(*_43);
+          StorageDead(_43);
+          _41 = copy _42 as &str (Transmute);
+          StorageDead(_42);
+          StorageLive(_48);
+          StorageLive(_50);
+          _48 = copy _41 as &[u8] (Transmute);
+          _50 = copy _40 as &[u8] (Transmute);
+          _14 = <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal(move _48, move _50) -> [return: bb20, unwind unreachable];
       }
   
       bb7: {
           StorageDead(_5);
           StorageDead(_6);
 -         goto -> bb18;
-+         goto -> bb39;
++         goto -> bb21;
       }
   
       bb8: {
@@ -354,14 +304,14 @@
           StorageDead(_13);
           _1 = chained_conditions::BacktraceStyle::Short;
 -         goto -> bb18;
-+         goto -> bb37;
++         goto -> bb23;
       }
   
       bb10: {
           StorageDead(_12);
           StorageDead(_13);
 -         goto -> bb18;
-+         goto -> bb39;
++         goto -> bb21;
       }
   
       bb11: {
@@ -406,223 +356,39 @@
       }
   
       bb19: {
-          StorageLive(_36);
-          _36 = copy _34 as *mut () (Transmute);
-          _35 = std::slice::from_raw_parts::precondition_check(move _36, const <u8 as std::mem::SizedTypeProperties>::SIZE, const <u8 as std::mem::SizedTypeProperties>::ALIGN, copy _33) -> [return: bb20, unwind unreachable];
-      }
-  
-      bb20: {
+          StorageDead(_38);
           StorageDead(_36);
-          goto -> bb21;
-      }
-  
-      bb21: {
-          StorageLive(_37);
-          _37 = *const [u8] from (copy _32, copy _33);
-          _30 = &(*_37);
-          StorageDead(_37);
-          StorageDead(_33);
-          StorageDead(_32);
-          StorageDead(_34);
-          _29 = copy _30 as &str (Transmute);
-          StorageDead(_30);
-          StorageLive(_39);
-          StorageLive(_41);
-          _39 = copy _29 as &[u8] (Transmute);
-          _41 = copy _28 as &[u8] (Transmute);
-          StorageLive(_45);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_42);
-          StorageLive(_43);
-          _43 = PtrMetadata(copy _39);
-          StorageLive(_44);
-          _44 = PtrMetadata(copy _41);
-          _42 = Ne(move _43, move _44);
-          switchInt(move _42) -> [0: bb24, otherwise: bb23];
-      }
-  
-      bb22: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageDead(_45);
-          StorageDead(_41);
-          StorageDead(_39);
-          StorageDead(_35);
           StorageDead(_29);
           StorageDead(_28);
           StorageDead(_27);
           switchInt(move _7) -> [0: bb6, otherwise: bb5];
       }
   
-      bb23: {
-          StorageDead(_44);
-          StorageDead(_43);
-          _7 = const false;
-          StorageDead(_42);
--         goto -> bb22;
-+         goto -> bb35;
-      }
-  
-      bb24: {
-          StorageDead(_44);
-          StorageDead(_43);
-          StorageDead(_42);
-          StorageLive(_49);
-          _49 = &raw const (*_39);
-          _45 = std::intrinsics::size_of_val::<[u8]>(move _49) -> [return: bb26, unwind unreachable];
-      }
-  
-      bb25: {
+      bb20: {
+          StorageDead(_50);
           StorageDead(_48);
-          StorageDead(_47);
-          _7 = Eq(move _46, const 0_i32);
-          StorageDead(_46);
-          goto -> bb22;
-      }
-  
-      bb26: {
-          StorageDead(_49);
-          StorageLive(_46);
-          StorageLive(_47);
-          _50 = &raw const (*_39);
-          _47 = copy _50 as *const u8 (PtrToPtr);
-          StorageLive(_48);
-          _51 = &raw const (*_41);
-          _48 = copy _51 as *const u8 (PtrToPtr);
-          _46 = compare_bytes(move _47, move _48, move _45) -> [return: bb25, unwind unreachable];
-      }
-  
-      bb27: {
-          StorageLive(_61);
-          _61 = copy _59 as *mut () (Transmute);
-          _60 = std::slice::from_raw_parts::precondition_check(move _61, const <u8 as std::mem::SizedTypeProperties>::SIZE, const <u8 as std::mem::SizedTypeProperties>::ALIGN, copy _58) -> [return: bb28, unwind unreachable];
-      }
-  
-      bb28: {
-          StorageDead(_61);
-          goto -> bb29;
-      }
-  
-      bb29: {
-          StorageLive(_62);
-          _62 = *const [u8] from (copy _57, copy _58);
-          _55 = &(*_62);
-          StorageDead(_62);
-          StorageDead(_58);
-          StorageDead(_57);
-          StorageDead(_59);
-          _54 = copy _55 as &str (Transmute);
-          StorageDead(_55);
-          StorageLive(_64);
-          StorageLive(_66);
-          _64 = copy _54 as &[u8] (Transmute);
-          _66 = copy _53 as &[u8] (Transmute);
-          StorageLive(_70);
-          StorageLive(_75);
-          StorageLive(_76);
-          StorageLive(_67);
-          StorageLive(_68);
-          _68 = PtrMetadata(copy _64);
-          StorageLive(_69);
-          _69 = PtrMetadata(copy _66);
-          _67 = Ne(move _68, move _69);
-          switchInt(move _67) -> [0: bb32, otherwise: bb31];
-      }
-  
-      bb30: {
-          StorageDead(_76);
-          StorageDead(_75);
-          StorageDead(_70);
-          StorageDead(_66);
-          StorageDead(_64);
-          StorageDead(_60);
-          StorageDead(_54);
-          StorageDead(_53);
-          StorageDead(_52);
+          StorageDead(_41);
+          StorageDead(_40);
+          StorageDead(_39);
           switchInt(move _14) -> [0: bb9, otherwise: bb8];
-      }
-  
-      bb31: {
-          StorageDead(_69);
-          StorageDead(_68);
-          _14 = const false;
-          StorageDead(_67);
--         goto -> bb30;
-+         goto -> bb36;
-      }
-  
-      bb32: {
-          StorageDead(_69);
-          StorageDead(_68);
-          StorageDead(_67);
-          StorageLive(_74);
-          _74 = &raw const (*_64);
-          _70 = std::intrinsics::size_of_val::<[u8]>(move _74) -> [return: bb34, unwind unreachable];
-      }
-  
-      bb33: {
-          StorageDead(_73);
-          StorageDead(_72);
-          _14 = Eq(move _71, const 0_i32);
-          StorageDead(_71);
-          goto -> bb30;
-      }
-  
-      bb34: {
-          StorageDead(_74);
-          StorageLive(_71);
-          StorageLive(_72);
-          _75 = &raw const (*_64);
-          _72 = copy _75 as *const u8 (PtrToPtr);
-          StorageLive(_73);
-          _76 = &raw const (*_66);
-          _73 = copy _76 as *const u8 (PtrToPtr);
-          _71 = compare_bytes(move _72, move _73, move _70) -> [return: bb33, unwind unreachable];
 +     }
 + 
-+     bb35: {
-+         StorageDead(_51);
-+         StorageDead(_50);
-+         StorageDead(_45);
-+         StorageDead(_41);
-+         StorageDead(_39);
-+         StorageDead(_35);
-+         StorageDead(_29);
-+         StorageDead(_28);
-+         StorageDead(_27);
-+         goto -> bb6;
-+     }
-+ 
-+     bb36: {
-+         StorageDead(_76);
-+         StorageDead(_75);
-+         StorageDead(_70);
-+         StorageDead(_66);
-+         StorageDead(_64);
-+         StorageDead(_60);
-+         StorageDead(_54);
-+         StorageDead(_53);
-+         StorageDead(_52);
-+         goto -> bb9;
-+     }
-+ 
-+     bb37: {
++     bb21: {
 +         _24 = discriminant(_2);
-+         switchInt(move _24) -> [1: bb38, otherwise: bb15];
++         switchInt(move _24) -> [1: bb22, otherwise: bb15];
 +     }
 + 
-+     bb38: {
-+         goto -> bb17;
-+     }
-+ 
-+     bb39: {
-+         _24 = discriminant(_2);
-+         switchInt(move _24) -> [1: bb40, otherwise: bb15];
-+     }
-+ 
-+     bb40: {
++     bb22: {
 +         goto -> bb15;
++     }
++ 
++     bb23: {
++         _24 = discriminant(_2);
++         switchInt(move _24) -> [1: bb24, otherwise: bb15];
++     }
++ 
++     bb24: {
++         goto -> bb17;
       }
   }
   
diff --git a/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-unwind.diff
index 822d33c89391..2f0d83f92792 100644
--- a/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-unwind.diff
@@ -48,8 +48,8 @@
                   let _29: &str;
                   scope 7 (inlined String::as_str) {
                       let _30: &[u8];
-                      let mut _31: &std::vec::Vec<u8>;
                       scope 8 (inlined Vec::<u8>::as_slice) {
+                          let _31: *const [u8];
                           let mut _32: *const u8;
                           let mut _33: usize;
                           scope 9 (inlined Vec::<u8>::as_ptr) {
@@ -71,160 +71,86 @@
                                   }
                               }
                           }
-                          scope 18 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                              let _35: ();
-                              let mut _36: *mut ();
-                              let _37: *const [u8];
-                              scope 19 (inlined ub_checks::check_language_ub) {
-                                  scope 20 (inlined ub_checks::check_language_ub::runtime) {
-                                  }
-                              }
-                              scope 21 (inlined std::mem::size_of::<u8>) {
-                              }
-                              scope 22 (inlined std::mem::align_of::<u8>) {
-                              }
-                              scope 23 (inlined slice_from_raw_parts::<u8>) {
-                                  scope 24 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                                  }
-                              }
-                          }
                       }
-                      scope 25 (inlined from_utf8_unchecked) {
+                      scope 18 (inlined from_utf8_unchecked) {
                       }
                   }
-                  scope 26 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+                  scope 19 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 27 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
-                  scope 28 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+              scope 20 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
+                  scope 21 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 29 (inlined core::str::traits::<impl PartialEq for str>::eq) {
-                  let mut _38: &&[u8];
-                  let _39: &[u8];
-                  let mut _40: &&[u8];
-                  let _41: &[u8];
-                  scope 30 (inlined core::str::<impl str>::as_bytes) {
+              scope 22 (inlined core::str::traits::<impl PartialEq for str>::eq) {
+                  let mut _35: &&[u8];
+                  let _36: &[u8];
+                  let mut _37: &&[u8];
+                  let _38: &[u8];
+                  scope 23 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 31 (inlined core::str::<impl str>::as_bytes) {
+                  scope 24 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 32 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
-                      scope 33 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
-                          scope 34 (inlined <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal) {
-                              let mut _42: bool;
-                              let mut _43: usize;
-                              let mut _44: usize;
-                              let _45: usize;
-                              let mut _46: i32;
-                              let mut _47: *const u8;
-                              let mut _48: *const u8;
-                              scope 35 {
-                                  scope 37 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _50: *const [u8];
-                                  }
-                                  scope 38 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _51: *const [u8];
-                                  }
-                              }
-                              scope 36 (inlined std::mem::size_of_val::<[u8]>) {
-                                  let mut _49: *const [u8];
-                              }
-                          }
+                  scope 25 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
+                      scope 26 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
                       }
                   }
               }
           }
       }
-      scope 39 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) {
-          let mut _52: &std::string::String;
-          let mut _53: &str;
-          scope 40 (inlined <String as PartialEq<str>>::eq) {
-              scope 41 (inlined #[track_caller] <String as Index<RangeFull>>::index) {
-                  let _54: &str;
-                  scope 42 (inlined String::as_str) {
-                      let _55: &[u8];
-                      let mut _56: &std::vec::Vec<u8>;
-                      scope 43 (inlined Vec::<u8>::as_slice) {
-                          let mut _57: *const u8;
-                          let mut _58: usize;
-                          scope 44 (inlined Vec::<u8>::as_ptr) {
-                              scope 45 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
-                                  scope 46 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
-                                      scope 47 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
-                                          let mut _59: std::ptr::NonNull<u8>;
-                                          scope 48 (inlined Unique::<u8>::cast::<u8>) {
-                                              scope 49 (inlined NonNull::<u8>::cast::<u8>) {
-                                                  scope 50 (inlined NonNull::<u8>::as_ptr) {
+      scope 27 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) {
+          let mut _39: &std::string::String;
+          let mut _40: &str;
+          scope 28 (inlined <String as PartialEq<str>>::eq) {
+              scope 29 (inlined #[track_caller] <String as Index<RangeFull>>::index) {
+                  let _41: &str;
+                  scope 30 (inlined String::as_str) {
+                      let _42: &[u8];
+                      scope 31 (inlined Vec::<u8>::as_slice) {
+                          let _43: *const [u8];
+                          let mut _44: *const u8;
+                          let mut _45: usize;
+                          scope 32 (inlined Vec::<u8>::as_ptr) {
+                              scope 33 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
+                                  scope 34 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
+                                      scope 35 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
+                                          let mut _46: std::ptr::NonNull<u8>;
+                                          scope 36 (inlined Unique::<u8>::cast::<u8>) {
+                                              scope 37 (inlined NonNull::<u8>::cast::<u8>) {
+                                                  scope 38 (inlined NonNull::<u8>::as_ptr) {
                                                   }
                                               }
                                           }
-                                          scope 51 (inlined Unique::<u8>::as_non_null_ptr) {
+                                          scope 39 (inlined Unique::<u8>::as_non_null_ptr) {
                                           }
                                       }
-                                      scope 52 (inlined NonNull::<u8>::as_ptr) {
+                                      scope 40 (inlined NonNull::<u8>::as_ptr) {
                                       }
                                   }
                               }
                           }
-                          scope 53 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                              let _60: ();
-                              let mut _61: *mut ();
-                              let _62: *const [u8];
-                              scope 54 (inlined ub_checks::check_language_ub) {
-                                  scope 55 (inlined ub_checks::check_language_ub::runtime) {
-                                  }
-                              }
-                              scope 56 (inlined std::mem::size_of::<u8>) {
-                              }
-                              scope 57 (inlined std::mem::align_of::<u8>) {
-                              }
-                              scope 58 (inlined slice_from_raw_parts::<u8>) {
-                                  scope 59 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                                  }
-                              }
-                          }
                       }
-                      scope 60 (inlined from_utf8_unchecked) {
+                      scope 41 (inlined from_utf8_unchecked) {
                       }
                   }
-                  scope 61 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+                  scope 42 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 62 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
-                  scope 63 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
+              scope 43 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) {
+                  scope 44 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) {
                   }
               }
-              scope 64 (inlined core::str::traits::<impl PartialEq for str>::eq) {
-                  let mut _63: &&[u8];
-                  let _64: &[u8];
-                  let mut _65: &&[u8];
-                  let _66: &[u8];
-                  scope 65 (inlined core::str::<impl str>::as_bytes) {
+              scope 45 (inlined core::str::traits::<impl PartialEq for str>::eq) {
+                  let mut _47: &&[u8];
+                  let _48: &[u8];
+                  let mut _49: &&[u8];
+                  let _50: &[u8];
+                  scope 46 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 66 (inlined core::str::<impl str>::as_bytes) {
+                  scope 47 (inlined core::str::<impl str>::as_bytes) {
                   }
-                  scope 67 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
-                      scope 68 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
-                          scope 69 (inlined <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal) {
-                              let mut _67: bool;
-                              let mut _68: usize;
-                              let mut _69: usize;
-                              let _70: usize;
-                              let mut _71: i32;
-                              let mut _72: *const u8;
-                              let mut _73: *const u8;
-                              scope 70 {
-                                  scope 72 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _75: *const [u8];
-                                  }
-                                  scope 73 (inlined core::slice::<impl [u8]>::as_ptr) {
-                                      let mut _76: *const [u8];
-                                  }
-                              }
-                              scope 71 (inlined std::mem::size_of_val::<[u8]>) {
-                                  let mut _74: *const [u8];
-                              }
-                          }
+                  scope 48 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) {
+                      scope 49 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) {
                       }
                   }
               }
@@ -253,7 +179,7 @@
       bb3: {
           _1 = chained_conditions::BacktraceStyle::Off;
 -         goto -> bb19;
-+         goto -> bb41;
++         goto -> bb27;
       }
   
       bb4: {
@@ -272,15 +198,27 @@
           _27 = copy (*_8);
           _28 = copy (*_10);
           StorageLive(_29);
-          StorageLive(_35);
           StorageLive(_30);
-          StorageLive(_34);
+          StorageLive(_31);
           StorageLive(_32);
+          StorageLive(_34);
           _34 = copy ((((((*_27).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
           _32 = copy _34 as *const u8 (Transmute);
+          StorageDead(_34);
           StorageLive(_33);
           _33 = copy (((*_27).0: std::vec::Vec<u8>).1: usize);
-          switchInt(UbChecks) -> [0: bb25, otherwise: bb23];
+          _31 = *const [u8] from (copy _32, move _33);
+          StorageDead(_33);
+          StorageDead(_32);
+          _30 = &(*_31);
+          StorageDead(_31);
+          _29 = copy _30 as &str (Transmute);
+          StorageDead(_30);
+          StorageLive(_36);
+          StorageLive(_38);
+          _36 = copy _29 as &[u8] (Transmute);
+          _38 = copy _28 as &[u8] (Transmute);
+          _7 = <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal(move _36, move _38) -> [return: bb23, unwind: bb22];
       }
   
       bb5: {
@@ -311,27 +249,39 @@
           StorageLive(_17);
           _20 = const chained_conditions::promoted[0];
           _17 = &(*_20);
-          StorageLive(_52);
-          StorageLive(_53);
-          _52 = copy (*_15);
-          _53 = copy (*_17);
-          StorageLive(_54);
-          StorageLive(_60);
-          StorageLive(_55);
-          StorageLive(_59);
-          StorageLive(_57);
-          _59 = copy ((((((*_52).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-          _57 = copy _59 as *const u8 (Transmute);
-          StorageLive(_58);
-          _58 = copy (((*_52).0: std::vec::Vec<u8>).1: usize);
-          switchInt(UbChecks) -> [0: bb33, otherwise: bb31];
+          StorageLive(_39);
+          StorageLive(_40);
+          _39 = copy (*_15);
+          _40 = copy (*_17);
+          StorageLive(_41);
+          StorageLive(_42);
+          StorageLive(_43);
+          StorageLive(_44);
+          StorageLive(_46);
+          _46 = copy ((((((*_39).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+          _44 = copy _46 as *const u8 (Transmute);
+          StorageDead(_46);
+          StorageLive(_45);
+          _45 = copy (((*_39).0: std::vec::Vec<u8>).1: usize);
+          _43 = *const [u8] from (copy _44, move _45);
+          StorageDead(_45);
+          StorageDead(_44);
+          _42 = &(*_43);
+          StorageDead(_43);
+          _41 = copy _42 as &str (Transmute);
+          StorageDead(_42);
+          StorageLive(_48);
+          StorageLive(_50);
+          _48 = copy _41 as &[u8] (Transmute);
+          _50 = copy _40 as &[u8] (Transmute);
+          _14 = <[u8] as core::slice::cmp::SlicePartialEq<u8>>::equal(move _48, move _50) -> [return: bb24, unwind: bb22];
       }
   
       bb7: {
           StorageDead(_5);
           StorageDead(_6);
 -         goto -> bb19;
-+         goto -> bb43;
++         goto -> bb25;
       }
   
       bb8: {
@@ -354,14 +304,14 @@
           StorageDead(_13);
           _1 = chained_conditions::BacktraceStyle::Short;
 -         goto -> bb19;
-+         goto -> bb41;
++         goto -> bb27;
       }
   
       bb10: {
           StorageDead(_12);
           StorageDead(_13);
 -         goto -> bb19;
-+         goto -> bb43;
++         goto -> bb25;
       }
   
       bb11: {
@@ -423,223 +373,39 @@
       }
   
       bb23: {
-          StorageLive(_36);
-          _36 = copy _34 as *mut () (Transmute);
-          _35 = std::slice::from_raw_parts::precondition_check(move _36, const <u8 as std::mem::SizedTypeProperties>::SIZE, const <u8 as std::mem::SizedTypeProperties>::ALIGN, copy _33) -> [return: bb24, unwind unreachable];
-      }
-  
-      bb24: {
+          StorageDead(_38);
           StorageDead(_36);
-          goto -> bb25;
-      }
-  
-      bb25: {
-          StorageLive(_37);
-          _37 = *const [u8] from (copy _32, copy _33);
-          _30 = &(*_37);
-          StorageDead(_37);
-          StorageDead(_33);
-          StorageDead(_32);
-          StorageDead(_34);
-          _29 = copy _30 as &str (Transmute);
-          StorageDead(_30);
-          StorageLive(_39);
-          StorageLive(_41);
-          _39 = copy _29 as &[u8] (Transmute);
-          _41 = copy _28 as &[u8] (Transmute);
-          StorageLive(_45);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_42);
-          StorageLive(_43);
-          _43 = PtrMetadata(copy _39);
-          StorageLive(_44);
-          _44 = PtrMetadata(copy _41);
-          _42 = Ne(move _43, move _44);
-          switchInt(move _42) -> [0: bb28, otherwise: bb27];
-      }
-  
-      bb26: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageDead(_45);
-          StorageDead(_41);
-          StorageDead(_39);
-          StorageDead(_35);
           StorageDead(_29);
           StorageDead(_28);
           StorageDead(_27);
           switchInt(move _7) -> [0: bb6, otherwise: bb5];
       }
   
-      bb27: {
-          StorageDead(_44);
-          StorageDead(_43);
-          _7 = const false;
-          StorageDead(_42);
--         goto -> bb26;
-+         goto -> bb39;
-      }
-  
-      bb28: {
-          StorageDead(_44);
-          StorageDead(_43);
-          StorageDead(_42);
-          StorageLive(_49);
-          _49 = &raw const (*_39);
-          _45 = std::intrinsics::size_of_val::<[u8]>(move _49) -> [return: bb30, unwind unreachable];
-      }
-  
-      bb29: {
+      bb24: {
+          StorageDead(_50);
           StorageDead(_48);
-          StorageDead(_47);
-          _7 = Eq(move _46, const 0_i32);
-          StorageDead(_46);
-          goto -> bb26;
-      }
-  
-      bb30: {
-          StorageDead(_49);
-          StorageLive(_46);
-          StorageLive(_47);
-          _50 = &raw const (*_39);
-          _47 = copy _50 as *const u8 (PtrToPtr);
-          StorageLive(_48);
-          _51 = &raw const (*_41);
-          _48 = copy _51 as *const u8 (PtrToPtr);
-          _46 = compare_bytes(move _47, move _48, move _45) -> [return: bb29, unwind unreachable];
-      }
-  
-      bb31: {
-          StorageLive(_61);
-          _61 = copy _59 as *mut () (Transmute);
-          _60 = std::slice::from_raw_parts::precondition_check(move _61, const <u8 as std::mem::SizedTypeProperties>::SIZE, const <u8 as std::mem::SizedTypeProperties>::ALIGN, copy _58) -> [return: bb32, unwind unreachable];
-      }
-  
-      bb32: {
-          StorageDead(_61);
-          goto -> bb33;
-      }
-  
-      bb33: {
-          StorageLive(_62);
-          _62 = *const [u8] from (copy _57, copy _58);
-          _55 = &(*_62);
-          StorageDead(_62);
-          StorageDead(_58);
-          StorageDead(_57);
-          StorageDead(_59);
-          _54 = copy _55 as &str (Transmute);
-          StorageDead(_55);
-          StorageLive(_64);
-          StorageLive(_66);
-          _64 = copy _54 as &[u8] (Transmute);
-          _66 = copy _53 as &[u8] (Transmute);
-          StorageLive(_70);
-          StorageLive(_75);
-          StorageLive(_76);
-          StorageLive(_67);
-          StorageLive(_68);
-          _68 = PtrMetadata(copy _64);
-          StorageLive(_69);
-          _69 = PtrMetadata(copy _66);
-          _67 = Ne(move _68, move _69);
-          switchInt(move _67) -> [0: bb36, otherwise: bb35];
-      }
-  
-      bb34: {
-          StorageDead(_76);
-          StorageDead(_75);
-          StorageDead(_70);
-          StorageDead(_66);
-          StorageDead(_64);
-          StorageDead(_60);
-          StorageDead(_54);
-          StorageDead(_53);
-          StorageDead(_52);
+          StorageDead(_41);
+          StorageDead(_40);
+          StorageDead(_39);
           switchInt(move _14) -> [0: bb9, otherwise: bb8];
-      }
-  
-      bb35: {
-          StorageDead(_69);
-          StorageDead(_68);
-          _14 = const false;
-          StorageDead(_67);
--         goto -> bb34;
-+         goto -> bb40;
-      }
-  
-      bb36: {
-          StorageDead(_69);
-          StorageDead(_68);
-          StorageDead(_67);
-          StorageLive(_74);
-          _74 = &raw const (*_64);
-          _70 = std::intrinsics::size_of_val::<[u8]>(move _74) -> [return: bb38, unwind unreachable];
-      }
-  
-      bb37: {
-          StorageDead(_73);
-          StorageDead(_72);
-          _14 = Eq(move _71, const 0_i32);
-          StorageDead(_71);
-          goto -> bb34;
-      }
-  
-      bb38: {
-          StorageDead(_74);
-          StorageLive(_71);
-          StorageLive(_72);
-          _75 = &raw const (*_64);
-          _72 = copy _75 as *const u8 (PtrToPtr);
-          StorageLive(_73);
-          _76 = &raw const (*_66);
-          _73 = copy _76 as *const u8 (PtrToPtr);
-          _71 = compare_bytes(move _72, move _73, move _70) -> [return: bb37, unwind unreachable];
 +     }
 + 
-+     bb39: {
-+         StorageDead(_51);
-+         StorageDead(_50);
-+         StorageDead(_45);
-+         StorageDead(_41);
-+         StorageDead(_39);
-+         StorageDead(_35);
-+         StorageDead(_29);
-+         StorageDead(_28);
-+         StorageDead(_27);
-+         goto -> bb6;
-+     }
-+ 
-+     bb40: {
-+         StorageDead(_76);
-+         StorageDead(_75);
-+         StorageDead(_70);
-+         StorageDead(_66);
-+         StorageDead(_64);
-+         StorageDead(_60);
-+         StorageDead(_54);
-+         StorageDead(_53);
-+         StorageDead(_52);
-+         goto -> bb9;
-+     }
-+ 
-+     bb41: {
++     bb25: {
 +         _24 = discriminant(_2);
-+         switchInt(move _24) -> [1: bb42, otherwise: bb16];
++         switchInt(move _24) -> [1: bb26, otherwise: bb16];
 +     }
 + 
-+     bb42: {
-+         goto -> bb18;
-+     }
-+ 
-+     bb43: {
-+         _24 = discriminant(_2);
-+         switchInt(move _24) -> [1: bb44, otherwise: bb16];
-+     }
-+ 
-+     bb44: {
++     bb26: {
 +         goto -> bb16;
++     }
++ 
++     bb27: {
++         _24 = discriminant(_2);
++         switchInt(move _24) -> [1: bb28, otherwise: bb16];
++     }
++ 
++     bb28: {
++         goto -> bb18;
       }
   }
   
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
index 791d6b71a6f7..013361d1d2fb 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
@@ -25,17 +25,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
-                        scope 19 (inlined Layout::size) {
-                        }
-                        scope 20 (inlined NonNull::<u8>::as_ptr) {
-                        }
-                        scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
-                            scope 22 (inlined Layout::size) {
-                            }
-                            scope 23 (inlined Layout::align) {
-                                scope 24 (inlined std::ptr::Alignment::as_usize) {
+                        scope 19 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 20 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _9: *mut u8;
+                                scope 21 (inlined Layout::size) {
+                                }
+                                scope 22 (inlined NonNull::<u8>::as_ptr) {
+                                }
+                                scope 23 (inlined std::alloc::dealloc) {
+                                    let mut _10: usize;
+                                    scope 24 (inlined Layout::size) {
+                                    }
+                                    scope 25 (inlined Layout::align) {
+                                        scope 26 (inlined std::ptr::Alignment::as_usize) {
+                                        }
+                                    }
                                 }
                             }
                         }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
index 791d6b71a6f7..013361d1d2fb 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
@@ -25,17 +25,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
-                        scope 19 (inlined Layout::size) {
-                        }
-                        scope 20 (inlined NonNull::<u8>::as_ptr) {
-                        }
-                        scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
-                            scope 22 (inlined Layout::size) {
-                            }
-                            scope 23 (inlined Layout::align) {
-                                scope 24 (inlined std::ptr::Alignment::as_usize) {
+                        scope 19 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 20 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _9: *mut u8;
+                                scope 21 (inlined Layout::size) {
+                                }
+                                scope 22 (inlined NonNull::<u8>::as_ptr) {
+                                }
+                                scope 23 (inlined std::alloc::dealloc) {
+                                    let mut _10: usize;
+                                    scope 24 (inlined Layout::size) {
+                                    }
+                                    scope 25 (inlined Layout::align) {
+                                        scope 26 (inlined std::ptr::Alignment::as_usize) {
+                                        }
+                                    }
                                 }
                             }
                         }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
index 791d6b71a6f7..013361d1d2fb 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
@@ -25,17 +25,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
-                        scope 19 (inlined Layout::size) {
-                        }
-                        scope 20 (inlined NonNull::<u8>::as_ptr) {
-                        }
-                        scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
-                            scope 22 (inlined Layout::size) {
-                            }
-                            scope 23 (inlined Layout::align) {
-                                scope 24 (inlined std::ptr::Alignment::as_usize) {
+                        scope 19 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 20 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _9: *mut u8;
+                                scope 21 (inlined Layout::size) {
+                                }
+                                scope 22 (inlined NonNull::<u8>::as_ptr) {
+                                }
+                                scope 23 (inlined std::alloc::dealloc) {
+                                    let mut _10: usize;
+                                    scope 24 (inlined Layout::size) {
+                                    }
+                                    scope 25 (inlined Layout::align) {
+                                        scope 26 (inlined std::ptr::Alignment::as_usize) {
+                                        }
+                                    }
                                 }
                             }
                         }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
index 791d6b71a6f7..013361d1d2fb 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
@@ -25,17 +25,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
-                        scope 19 (inlined Layout::size) {
-                        }
-                        scope 20 (inlined NonNull::<u8>::as_ptr) {
-                        }
-                        scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
-                            scope 22 (inlined Layout::size) {
-                            }
-                            scope 23 (inlined Layout::align) {
-                                scope 24 (inlined std::ptr::Alignment::as_usize) {
+                        scope 19 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 20 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _9: *mut u8;
+                                scope 21 (inlined Layout::size) {
+                                }
+                                scope 22 (inlined NonNull::<u8>::as_ptr) {
+                                }
+                                scope 23 (inlined std::alloc::dealloc) {
+                                    let mut _10: usize;
+                                    scope 24 (inlined Layout::size) {
+                                    }
+                                    scope 25 (inlined Layout::align) {
+                                        scope 26 (inlined std::ptr::Alignment::as_usize) {
+                                        }
+                                    }
                                 }
                             }
                         }
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
index 3f854b6cbcfb..d0fda06c115c 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
@@ -9,33 +9,33 @@
       let mut _4: *mut [u8];
       let mut _5: std::ptr::NonNull<[u8]>;
       let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-      let mut _7: &std::alloc::Global;
-      let mut _8: std::alloc::Layout;
+      let mut _7: std::alloc::Layout;
       scope 1 {
           debug layout => _1;
-          let mut _9: &std::alloc::Global;
           scope 2 {
               debug ptr => _3;
           }
           scope 5 (inlined <std::alloc::Global as Allocator>::allocate) {
-          }
-          scope 6 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) {
-              let mut _12: isize;
-              let _13: std::alloc::AllocError;
-              let mut _14: !;
-              let mut _15: &dyn std::fmt::Debug;
-              let _16: &std::alloc::AllocError;
-              scope 7 {
+              scope 6 (inlined std::alloc::Global::alloc_impl) {
               }
+          }
+          scope 7 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) {
+              let mut _10: isize;
+              let _11: std::alloc::AllocError;
+              let mut _12: !;
+              let mut _13: &dyn std::fmt::Debug;
+              let _14: &std::alloc::AllocError;
               scope 8 {
               }
+              scope 9 {
+              }
           }
-          scope 9 (inlined NonNull::<[u8]>::as_ptr) {
+          scope 10 (inlined NonNull::<[u8]>::as_ptr) {
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
-          let mut _10: isize;
-          let mut _11: !;
+          let mut _8: isize;
+          let mut _9: !;
           scope 4 {
           }
       }
@@ -46,10 +46,10 @@
           StorageLive(_2);
 -         _2 = Option::<Layout>::None;
 +         _2 = const Option::<Layout>::None;
-          StorageLive(_10);
--         _10 = discriminant(_2);
--         switchInt(move _10) -> [0: bb2, 1: bb3, otherwise: bb1];
-+         _10 = const 0_isize;
+          StorageLive(_8);
+-         _8 = discriminant(_2);
+-         switchInt(move _8) -> [0: bb2, 1: bb3, otherwise: bb1];
++         _8 = const 0_isize;
 +         switchInt(const 0_isize) -> [0: bb2, 1: bb3, otherwise: bb1];
       }
   
@@ -58,48 +58,44 @@
       }
   
       bb2: {
-          _11 = option::unwrap_failed() -> unwind unreachable;
+          _9 = option::unwrap_failed() -> unwind unreachable;
       }
   
       bb3: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
 +         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-          StorageDead(_10);
+          StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _9 = const main::promoted[0];
-          _7 = copy _9;
-          StorageLive(_8);
--         _8 = copy _1;
--         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable];
-+         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
+-         _7 = copy _1;
+-         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
-          StorageDead(_8);
           StorageDead(_7);
-          StorageLive(_12);
-          StorageLive(_16);
-          _12 = discriminant(_6);
-          switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
+          StorageLive(_10);
+          StorageLive(_14);
+          _10 = discriminant(_6);
+          switchInt(move _10) -> [0: bb6, 1: bb5, otherwise: bb1];
       }
   
       bb5: {
-          StorageLive(_15);
-          _16 = &_13;
-          _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit));
-          _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
+          StorageLive(_13);
+          _14 = &_11;
+          _13 = copy _14 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit));
+          _12 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _13) -> unwind unreachable;
       }
   
       bb6: {
           _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageDead(_16);
-          StorageDead(_12);
+          StorageDead(_14);
+          StorageDead(_10);
           StorageDead(_6);
           _4 = copy _5 as *mut [u8] (Transmute);
           StorageDead(_5);
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
index 15a9d9e39c49..485ff902a7b9 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
@@ -9,22 +9,22 @@
       let mut _4: *mut [u8];
       let mut _5: std::ptr::NonNull<[u8]>;
       let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-      let mut _7: &std::alloc::Global;
-      let mut _8: std::alloc::Layout;
+      let mut _7: std::alloc::Layout;
       scope 1 {
           debug layout => _1;
-          let mut _9: &std::alloc::Global;
           scope 2 {
               debug ptr => _3;
           }
           scope 5 (inlined <std::alloc::Global as Allocator>::allocate) {
+              scope 6 (inlined std::alloc::Global::alloc_impl) {
+              }
           }
-          scope 6 (inlined NonNull::<[u8]>::as_ptr) {
+          scope 7 (inlined NonNull::<[u8]>::as_ptr) {
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
-          let mut _10: isize;
-          let mut _11: !;
+          let mut _8: isize;
+          let mut _9: !;
           scope 4 {
           }
       }
@@ -35,10 +35,10 @@
           StorageLive(_2);
 -         _2 = Option::<Layout>::None;
 +         _2 = const Option::<Layout>::None;
-          StorageLive(_10);
--         _10 = discriminant(_2);
--         switchInt(move _10) -> [0: bb3, 1: bb4, otherwise: bb2];
-+         _10 = const 0_isize;
+          StorageLive(_8);
+-         _8 = discriminant(_2);
+-         switchInt(move _8) -> [0: bb3, 1: bb4, otherwise: bb2];
++         _8 = const 0_isize;
 +         switchInt(const 0_isize) -> [0: bb3, 1: bb4, otherwise: bb2];
       }
   
@@ -59,30 +59,26 @@
       }
   
       bb3: {
-          _11 = option::unwrap_failed() -> unwind continue;
+          _9 = option::unwrap_failed() -> unwind continue;
       }
   
       bb4: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
 +         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-          StorageDead(_10);
+          StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _9 = const main::promoted[0];
-          _7 = copy _9;
-          StorageLive(_8);
--         _8 = copy _1;
--         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue];
-+         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
+-         _7 = copy _1;
+-         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb5, unwind continue];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
-          StorageDead(_8);
           StorageDead(_7);
           _5 = Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap(move _6) -> [return: bb1, unwind continue];
       }
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index 1dbe9394e709..b45a0f4a9bdd 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
@@ -9,33 +9,33 @@
       let mut _4: *mut [u8];
       let mut _5: std::ptr::NonNull<[u8]>;
       let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-      let mut _7: &std::alloc::Global;
-      let mut _8: std::alloc::Layout;
+      let mut _7: std::alloc::Layout;
       scope 1 {
           debug layout => _1;
-          let mut _9: &std::alloc::Global;
           scope 2 {
               debug ptr => _3;
           }
           scope 5 (inlined <std::alloc::Global as Allocator>::allocate) {
-          }
-          scope 6 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) {
-              let mut _12: isize;
-              let _13: std::alloc::AllocError;
-              let mut _14: !;
-              let mut _15: &dyn std::fmt::Debug;
-              let _16: &std::alloc::AllocError;
-              scope 7 {
+              scope 6 (inlined std::alloc::Global::alloc_impl) {
               }
+          }
+          scope 7 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) {
+              let mut _10: isize;
+              let _11: std::alloc::AllocError;
+              let mut _12: !;
+              let mut _13: &dyn std::fmt::Debug;
+              let _14: &std::alloc::AllocError;
               scope 8 {
               }
+              scope 9 {
+              }
           }
-          scope 9 (inlined NonNull::<[u8]>::as_ptr) {
+          scope 10 (inlined NonNull::<[u8]>::as_ptr) {
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
-          let mut _10: isize;
-          let mut _11: !;
+          let mut _8: isize;
+          let mut _9: !;
           scope 4 {
           }
       }
@@ -46,10 +46,10 @@
           StorageLive(_2);
 -         _2 = Option::<Layout>::None;
 +         _2 = const Option::<Layout>::None;
-          StorageLive(_10);
--         _10 = discriminant(_2);
--         switchInt(move _10) -> [0: bb2, 1: bb3, otherwise: bb1];
-+         _10 = const 0_isize;
+          StorageLive(_8);
+-         _8 = discriminant(_2);
+-         switchInt(move _8) -> [0: bb2, 1: bb3, otherwise: bb1];
++         _8 = const 0_isize;
 +         switchInt(const 0_isize) -> [0: bb2, 1: bb3, otherwise: bb1];
       }
   
@@ -58,48 +58,44 @@
       }
   
       bb2: {
-          _11 = option::unwrap_failed() -> unwind unreachable;
+          _9 = option::unwrap_failed() -> unwind unreachable;
       }
   
       bb3: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
 +         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-          StorageDead(_10);
+          StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _9 = const main::promoted[0];
-          _7 = copy _9;
-          StorageLive(_8);
--         _8 = copy _1;
--         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable];
-+         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
+-         _7 = copy _1;
+-         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
-          StorageDead(_8);
           StorageDead(_7);
-          StorageLive(_12);
-          StorageLive(_16);
-          _12 = discriminant(_6);
-          switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
+          StorageLive(_10);
+          StorageLive(_14);
+          _10 = discriminant(_6);
+          switchInt(move _10) -> [0: bb6, 1: bb5, otherwise: bb1];
       }
   
       bb5: {
-          StorageLive(_15);
-          _16 = &_13;
-          _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit));
-          _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
+          StorageLive(_13);
+          _14 = &_11;
+          _13 = copy _14 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit));
+          _12 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _13) -> unwind unreachable;
       }
   
       bb6: {
           _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageDead(_16);
-          StorageDead(_12);
+          StorageDead(_14);
+          StorageDead(_10);
           StorageDead(_6);
           _4 = copy _5 as *mut [u8] (Transmute);
           StorageDead(_5);
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
index df008ececae3..beee899dafe6 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
@@ -9,22 +9,22 @@
       let mut _4: *mut [u8];
       let mut _5: std::ptr::NonNull<[u8]>;
       let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-      let mut _7: &std::alloc::Global;
-      let mut _8: std::alloc::Layout;
+      let mut _7: std::alloc::Layout;
       scope 1 {
           debug layout => _1;
-          let mut _9: &std::alloc::Global;
           scope 2 {
               debug ptr => _3;
           }
           scope 5 (inlined <std::alloc::Global as Allocator>::allocate) {
+              scope 6 (inlined std::alloc::Global::alloc_impl) {
+              }
           }
-          scope 6 (inlined NonNull::<[u8]>::as_ptr) {
+          scope 7 (inlined NonNull::<[u8]>::as_ptr) {
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
-          let mut _10: isize;
-          let mut _11: !;
+          let mut _8: isize;
+          let mut _9: !;
           scope 4 {
           }
       }
@@ -35,10 +35,10 @@
           StorageLive(_2);
 -         _2 = Option::<Layout>::None;
 +         _2 = const Option::<Layout>::None;
-          StorageLive(_10);
--         _10 = discriminant(_2);
--         switchInt(move _10) -> [0: bb3, 1: bb4, otherwise: bb2];
-+         _10 = const 0_isize;
+          StorageLive(_8);
+-         _8 = discriminant(_2);
+-         switchInt(move _8) -> [0: bb3, 1: bb4, otherwise: bb2];
++         _8 = const 0_isize;
 +         switchInt(const 0_isize) -> [0: bb3, 1: bb4, otherwise: bb2];
       }
   
@@ -59,30 +59,26 @@
       }
   
       bb3: {
-          _11 = option::unwrap_failed() -> unwind continue;
+          _9 = option::unwrap_failed() -> unwind continue;
       }
   
       bb4: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
 +         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-          StorageDead(_10);
+          StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _9 = const main::promoted[0];
-          _7 = copy _9;
-          StorageLive(_8);
--         _8 = copy _1;
--         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue];
-+         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
+-         _7 = copy _1;
+-         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb5, unwind continue];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
-          StorageDead(_8);
           StorageDead(_7);
           _5 = Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap(move _6) -> [return: bb1, unwind continue];
       }
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
index 2eee8a97db0d..8308ecbad716 100644
--- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
@@ -9,6 +9,7 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             debug self => _1;
             let mut _3: *const u8;
             let mut _4: usize;
+            let _5: *const [u8];
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
@@ -29,43 +30,23 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
                     }
                 }
             }
-            scope 12 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                debug data => _3;
-                debug len => _4;
-                let _5: *const [u8];
-                scope 13 (inlined core::ub_checks::check_language_ub) {
-                    scope 14 (inlined core::ub_checks::check_language_ub::runtime) {
-                    }
-                }
-                scope 15 (inlined std::mem::size_of::<u8>) {
-                }
-                scope 16 (inlined std::mem::align_of::<u8>) {
-                }
-                scope 17 (inlined slice_from_raw_parts::<u8>) {
-                    debug data => _3;
-                    debug len => _4;
-                    scope 18 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                        debug data_pointer => _3;
-                    }
-                }
-            }
         }
     }
 
     bb0: {
-        StorageLive(_2);
+        StorageLive(_5);
         StorageLive(_3);
+        StorageLive(_2);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
         _3 = copy _2 as *const u8 (Transmute);
+        StorageDead(_2);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
-        StorageLive(_5);
-        _5 = *const [u8] from (copy _3, copy _4);
-        _0 = &(*_5);
-        StorageDead(_5);
+        _5 = *const [u8] from (copy _3, move _4);
         StorageDead(_4);
         StorageDead(_3);
-        StorageDead(_2);
+        _0 = &(*_5);
+        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
index 2eee8a97db0d..8308ecbad716 100644
--- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
@@ -9,6 +9,7 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             debug self => _1;
             let mut _3: *const u8;
             let mut _4: usize;
+            let _5: *const [u8];
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
@@ -29,43 +30,23 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
                     }
                 }
             }
-            scope 12 (inlined #[track_caller] std::slice::from_raw_parts::<'_, u8>) {
-                debug data => _3;
-                debug len => _4;
-                let _5: *const [u8];
-                scope 13 (inlined core::ub_checks::check_language_ub) {
-                    scope 14 (inlined core::ub_checks::check_language_ub::runtime) {
-                    }
-                }
-                scope 15 (inlined std::mem::size_of::<u8>) {
-                }
-                scope 16 (inlined std::mem::align_of::<u8>) {
-                }
-                scope 17 (inlined slice_from_raw_parts::<u8>) {
-                    debug data => _3;
-                    debug len => _4;
-                    scope 18 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
-                        debug data_pointer => _3;
-                    }
-                }
-            }
         }
     }
 
     bb0: {
-        StorageLive(_2);
+        StorageLive(_5);
         StorageLive(_3);
+        StorageLive(_2);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
         _3 = copy _2 as *const u8 (Transmute);
+        StorageDead(_2);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
-        StorageLive(_5);
-        _5 = *const [u8] from (copy _3, copy _4);
-        _0 = &(*_5);
-        StorageDead(_5);
+        _5 = *const [u8] from (copy _3, move _4);
         StorageDead(_4);
         StorageDead(_3);
-        StorageDead(_2);
+        _0 = &(*_5);
+        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/run-make/compiletest-self-test/jobs/rmake.rs b/tests/run-make/compiletest-self-test/jobs/rmake.rs
new file mode 100644
index 000000000000..d21b44ada1c3
--- /dev/null
+++ b/tests/run-make/compiletest-self-test/jobs/rmake.rs
@@ -0,0 +1,5 @@
+//! Very basic smoke test to make sure `run_make_support::env::jobs` at least does not panic.
+
+fn main() {
+    println!("{}", run_make_support::env::jobs());
+}
diff --git a/tests/run-make/crate-loading/dep-2-reexport.rs b/tests/run-make/crate-loading/dep-2-reexport.rs
index 07444511472f..8b6ee6749dcc 100644
--- a/tests/run-make/crate-loading/dep-2-reexport.rs
+++ b/tests/run-make/crate-loading/dep-2-reexport.rs
@@ -2,9 +2,23 @@
 #![crate_type = "rlib"]
 
 extern crate dependency;
-pub use dependency::{Trait2, Type, do_something_trait, do_something_type};
+pub use dependency::{Error, OtherError, Trait2, Type, do_something_trait, do_something_type};
 pub struct OtherType;
 impl dependency::Trait for OtherType {
     fn foo(&self) {}
     fn bar() {}
 }
+#[derive(Debug)]
+pub struct Error2;
+
+impl From<Error> for Error2 {
+    fn from(_: Error) -> Error2 {
+        Error2
+    }
+}
+
+impl From<OtherError> for Error2 {
+    fn from(_: OtherError) -> Error2 {
+        Error2
+    }
+}
diff --git a/tests/run-make/crate-loading/dependency-1.rs b/tests/run-make/crate-loading/dependency-1.rs
index bfeabccf5c14..0eea7a7fae8b 100644
--- a/tests/run-make/crate-loading/dependency-1.rs
+++ b/tests/run-make/crate-loading/dependency-1.rs
@@ -13,3 +13,27 @@ impl Trait for Type {
 pub fn do_something<X: Trait>(_: X) {}
 pub fn do_something_type(_: Type) {}
 pub fn do_something_trait(_: Box<dyn Trait2>) {}
+
+#[derive(Debug)]
+pub struct Error;
+
+impl From<()> for Error {
+    fn from(t: ()) -> Error {
+        Error
+    }
+}
+
+#[derive(Debug)]
+pub struct OtherError;
+
+impl From<()> for OtherError {
+    fn from(t: ()) -> OtherError {
+        OtherError
+    }
+}
+
+impl From<i32> for OtherError {
+    fn from(t: i32) -> OtherError {
+        OtherError
+    }
+}
diff --git a/tests/run-make/crate-loading/dependency-2.rs b/tests/run-make/crate-loading/dependency-2.rs
index 682d1ff64b82..a07873297c54 100644
--- a/tests/run-make/crate-loading/dependency-2.rs
+++ b/tests/run-make/crate-loading/dependency-2.rs
@@ -14,3 +14,27 @@ impl Trait for Type {
 pub fn do_something<X: Trait>(_: X) {}
 pub fn do_something_type(_: Type) {}
 pub fn do_something_trait(_: Box<dyn Trait2>) {}
+
+#[derive(Debug)]
+pub struct Error;
+
+impl From<()> for Error {
+    fn from(t: ()) -> Error {
+        Error
+    }
+}
+
+#[derive(Debug)]
+pub struct OtherError;
+
+impl From<()> for OtherError {
+    fn from(_: ()) -> OtherError {
+        OtherError
+    }
+}
+
+impl From<i32> for OtherError {
+    fn from(_: i32) -> OtherError {
+        OtherError
+    }
+}
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.rs b/tests/run-make/crate-loading/multiple-dep-versions.rs
index 3a4a20d38fc8..69b8360a8c92 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions.rs
@@ -1,13 +1,20 @@
 extern crate dep_2_reexport;
 extern crate dependency;
-use dep_2_reexport::{OtherType, Trait2, Type};
-use dependency::{Trait, do_something, do_something_trait, do_something_type};
+use dep_2_reexport::{Error2, OtherType, Trait2, Type};
+use dependency::{Error, OtherError, Trait, do_something, do_something_trait, do_something_type};
 
-fn main() {
+fn main() -> Result<(), Error> {
     do_something(Type);
     Type.foo();
     Type::bar();
     do_something(OtherType);
     do_something_type(Type);
     do_something_trait(Box::new(Type) as Box<dyn Trait2>);
+    Err(Error2)?;
+    Ok(())
+}
+
+fn foo() -> Result<(), OtherError> {
+    Err(Error2)?;
+    Ok(())
 }
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.stderr b/tests/run-make/crate-loading/multiple-dep-versions.stderr
index 235a44a8ce89..f8f8bfaaff6f 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.stderr
+++ b/tests/run-make/crate-loading/multiple-dep-versions.stderr
@@ -144,7 +144,51 @@ note: function defined here
 LL | pub fn do_something_trait(_: Box<dyn Trait2>) {}
    |        ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error[E0277]: `?` couldn't convert the error to `dependency::Error`
+  --> replaced
+   |
+LL | fn main() -> Result<(), Error> {
+   |              ----------------- expected `dependency::Error` because of this
+...
+LL |     Err(Error2)?;
+   |     -----------^ the trait `From<Error2>` is not implemented for `dependency::Error`
+   |     |
+   |     this can't be annotated with `?` because it has type `Result<_, Error2>`
+   |
+   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
+help: the trait `From<Error2>` is not implemented for `dependency::Error`
+      but trait `From<()>` is implemented for it
+  --> replaced
+   |
+LL | impl From<()> for Error {
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   = help: for that trait implementation, expected `()`, found `Error2`
+   = note: there are multiple different versions of crate `dependency` in the dependency graph
+   = help: you can use `cargo tree` to explore your dependency tree
+
+error[E0277]: `?` couldn't convert the error to `dependency::OtherError`
+  --> replaced
+   |
+LL | fn foo() -> Result<(), OtherError> {
+   |             ---------------------- expected `dependency::OtherError` because of this
+LL |     Err(Error2)?;
+   |     -----------^ the trait `From<Error2>` is not implemented for `dependency::OtherError`
+   |     |
+   |     this can't be annotated with `?` because it has type `Result<_, Error2>`
+   |
+   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
+help: the following other types implement trait `From<T>`
+  --> replaced
+   |
+LL | impl From<()> for OtherError {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dependency::OtherError` implements `From<()>`
+...
+LL | impl From<i32> for OtherError {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dependency::OtherError` implements `From<i32>`
+   = note: there are multiple different versions of crate `dependency` in the dependency graph
+   = help: you can use `cargo tree` to explore your dependency tree
+
+error: aborting due to 8 previous errors
 
 Some errors have detailed explanations: E0277, E0308, E0599.
 For more information about an error, try `rustc --explain E0277`.
\ No newline at end of file
diff --git a/tests/rustdoc-gui/anchor-navigable.goml b/tests/rustdoc-gui/anchor-navigable.goml
index 61d7c89d434f..db7fc3bbf182 100644
--- a/tests/rustdoc-gui/anchor-navigable.goml
+++ b/tests/rustdoc-gui/anchor-navigable.goml
@@ -7,5 +7,5 @@
 go-to: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html"
 // We check that ".item-info" is bigger than its content.
 move-cursor-to: ".impl"
-assert-property: (".impl > a.anchor", {"offsetWidth": "8"})
+assert-property: (".impl > a.anchor", {"offsetWidth": "16"})
 assert-css: (".impl > a.anchor", {"left": "-8px"})
diff --git a/tests/rustdoc-gui/anchors.goml b/tests/rustdoc-gui/anchors.goml
index 3168c8e17c52..eaec73f50e97 100644
--- a/tests/rustdoc-gui/anchors.goml
+++ b/tests/rustdoc-gui/anchors.goml
@@ -14,9 +14,9 @@ define-function: (
         assert-css: ("#toggle-all-docs", {"color": |main_color|})
         assert-css: (".main-heading h1 span", {"color": |main_heading_type_color|})
         assert-css: (
-             ".rightside a.src",
-             {"color": |src_link_color|, "text-decoration": "none solid " + |src_link_color|},
-             ALL,
+            ".rightside a.src",
+            {"color": |src_link_color|, "text-decoration": "none"},
+            ALL,
         )
         compare-elements-css: (
             ".rightside a.src",
@@ -31,25 +31,39 @@ define-function: (
 
         move-cursor-to: ".main-heading a.src"
         assert-css: (
-             ".main-heading a.src",
-             {"color": |src_link_color|, "text-decoration": "underline solid " + |src_link_color|},
+            ".main-heading a.src",
+            {"color": |src_link_color|, "text-decoration": "underline"},
         )
         move-cursor-to: ".impl-items .rightside a.src"
         assert-css: (
-             ".impl-items .rightside a.src",
-             {"color": |src_link_color|, "text-decoration": "none solid " + |src_link_color|},
+            ".impl-items .rightside a.src",
+            {"color": |src_link_color|, "text-decoration": "none"},
         )
         move-cursor-to: ".impl-items a.rightside.src"
         assert-css: (
-             ".impl-items a.rightside.src",
-             {"color": |src_link_color|, "text-decoration": "none solid " + |src_link_color|},
+            ".impl-items a.rightside.src",
+            {"color": |src_link_color|, "text-decoration": "none"},
         )
 
+        // Now we ensure that the `§` anchor is "reachable" for users on trait methods.
+        // To ensure the anchor is not hovered, we move the cursor to another item.
+        move-cursor-to: "#search-button"
+        // By default, the anchor is not displayed.
+        wait-for-css: ("#method\.vroum .anchor", {"display": "none"})
+        // Once we move the cursor to the method, the anchor should appear.
+        move-cursor-to: "#method\.vroum .code-header"
+        assert-css-false: ("#method\.vroum .anchor", {"display": "none"})
+        // Now we move the cursor to the anchor to check there is no gap between the method and the
+        // anchor, making the anchor disappear and preventing users to click on it.
+        // To make it work, we need to first move it between the method and the anchor.
+        store-position: ("#method\.vroum .code-header", {"x": method_x, "y": method_y})
+        move-cursor-to: (|method_x| - 2, |method_y|)
+        // Anchor should still be displayed.
+        assert-css-false: ("#method\.vroum .anchor", {"display": "none"})
+
         go-to: "file://" + |DOC_PATH| + "/test_docs/struct.HeavilyDocumentedStruct.html"
         // Since we changed page, we need to set the theme again.
-        set-local-storage: {"rustdoc-theme": |theme|, "rustdoc-use-system-theme": "false"}
-        // We reload the page so the local storage settings are being used.
-        reload:
+        call-function: ("switch-theme", {"theme": |theme|})
 
         assert-css: ("#top-doc-prose-title", {"color": |title_color|})
 
diff --git a/tests/rustdoc-gui/copy-code.goml b/tests/rustdoc-gui/copy-code.goml
index 14421ab746f5..eb003ef5e1ca 100644
--- a/tests/rustdoc-gui/copy-code.goml
+++ b/tests/rustdoc-gui/copy-code.goml
@@ -1,5 +1,6 @@
 // Checks that the "copy code" button is not triggering JS error and its display
 // isn't broken.
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/fn.foo.html"
 
 define-function: (
@@ -47,15 +48,15 @@ assert: |copy_height| > 0 && |copy_width| > 0
 
 // First we ensure that the clipboard is empty.
 assert-clipboard: ""
+
 // We make the line numbers appear.
-click: "rustdoc-toolbar .settings-menu"
-wait-for-css: ("#settings", {"display": "block"})
-// We make the line numbers appear.
+call-function: ("open-settings-menu", {})
 click: "#line-numbers"
 wait-for-local-storage: {"rustdoc-line-numbers": "true" }
+
 // We close the settings menu.
-click: "rustdoc-toolbar .settings-menu"
-wait-for-css-false: ("#settings", {"display": "block"})
+call-function: ("close-settings-menu", {})
+
 // We ensure that there are actually line numbers generated in the DOM.
 assert-text: (".example-wrap pre.rust code span[data-nosnippet]", "1")
 // We make the copy button appear.
diff --git a/tests/rustdoc-gui/font-serif-change.goml b/tests/rustdoc-gui/font-serif-change.goml
index 1e9f21c35416..32e95cdc6ee1 100644
--- a/tests/rustdoc-gui/font-serif-change.goml
+++ b/tests/rustdoc-gui/font-serif-change.goml
@@ -1,4 +1,5 @@
 // Ensures that the font serif change is working as expected.
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
 
 // By default, it should be the serif fonts.
@@ -8,8 +9,7 @@ assert-css: ("body", {"font-family": |serif_font|})
 assert-css: ("p code", {"font-family": |serif_code_font|})
 
 // We now switch to the sans serif font
-click: "main .settings-menu"
-wait-for: "#sans-serif-fonts"
+call-function: ("open-settings-menu", {})
 click: "#sans-serif-fonts"
 
 store-value: (font, '"Fira Sans", sans-serif')
@@ -23,8 +23,7 @@ assert-css: ("body", {"font-family": |font|})
 assert-css: ("p code", {"font-family": |code_font|})
 
 // We switch back to the serif font
-click: "main .settings-menu"
-wait-for: "#sans-serif-fonts"
+call-function: ("open-settings-menu", {})
 click: "#sans-serif-fonts"
 
 assert-css: ("body", {"font-family": |serif_font|})
diff --git a/tests/rustdoc-gui/links-color.goml b/tests/rustdoc-gui/links-color.goml
index a363175c1ddb..ae1509c6fa4f 100644
--- a/tests/rustdoc-gui/links-color.goml
+++ b/tests/rustdoc-gui/links-color.goml
@@ -41,7 +41,7 @@ define-function: (
         move-cursor-to: "dd a[href='long_code_block_link/index.html']"
         assert-css: (
             "dd a[href='long_code_block_link/index.html']",
-            {"text-decoration": "underline solid " + |mod|},
+            {"text-decoration": "underline"},
         )
     },
 )
diff --git a/tests/rustdoc-gui/notable-trait.goml b/tests/rustdoc-gui/notable-trait.goml
index 6bd4661ac8f4..839988021fce 100644
--- a/tests/rustdoc-gui/notable-trait.goml
+++ b/tests/rustdoc-gui/notable-trait.goml
@@ -82,15 +82,15 @@ call-function: ("check-notable-tooltip-position", {
     "i_x": 528,
 })
 
+go-to: "file://" + |DOC_PATH| + "/test_docs/struct.NotableStructWithLongName.html"
+// This is needed to ensure that the text color is computed.
+show-text: true
+
 // Now check the colors.
 define-function: (
     "check-colors",
     [theme, header_color, content_color, type_color, trait_color, link_color],
     block {
-        go-to: "file://" + |DOC_PATH| + "/test_docs/struct.NotableStructWithLongName.html"
-        // This is needed to ensure that the text color is computed.
-        show-text: true
-
         call-function: ("switch-theme", {"theme": |theme|})
 
         assert-css: (
@@ -251,7 +251,6 @@ reload:
 assert-count: ("//*[@class='tooltip popover']", 0)
 click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']"
 assert-count: ("//*[@class='tooltip popover']", 1)
-click: "rustdoc-toolbar .settings-menu a"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 assert-count: ("//*[@class='tooltip popover']", 0)
 assert-false: "#method\.create_an_iterator_from_read .tooltip:focus"
diff --git a/tests/rustdoc-gui/search-filter.goml b/tests/rustdoc-gui/search-filter.goml
index d92d522c119d..6bd7eaa92063 100644
--- a/tests/rustdoc-gui/search-filter.goml
+++ b/tests/rustdoc-gui/search-filter.goml
@@ -70,9 +70,7 @@ assert-css: ("#crate-search", {
 })
 
 // We now check the dark theme.
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
-click: "#theme-dark"
+call-function: ("switch-theme", {"theme": "dark"})
 wait-for-css: ("#crate-search", {
     "border": "1px solid #e0e0e0",
     "color": "#ddd",
@@ -80,7 +78,7 @@ wait-for-css: ("#crate-search", {
 })
 
 // And finally we check the ayu theme.
-click: "#theme-ayu"
+call-function: ("switch-theme", {"theme": "ayu"})
 wait-for-css: ("#crate-search", {
     "border": "1px solid #5c6773",
     "color": "#c5c5c5",
diff --git a/tests/rustdoc-gui/setting-auto-hide-content-large-items.goml b/tests/rustdoc-gui/setting-auto-hide-content-large-items.goml
index 342bd726694e..dbf80ae34912 100644
--- a/tests/rustdoc-gui/setting-auto-hide-content-large-items.goml
+++ b/tests/rustdoc-gui/setting-auto-hide-content-large-items.goml
@@ -1,6 +1,8 @@
 // This test ensures that the "Auto-hide item contents for large items" setting is working as
 // expected.
 
+include: "utils.goml"
+
 // We need to disable this check because `trait.impl/test_docs/trait.Iterator.js` doesn't exist.
 fail-on-request-error: false
 
@@ -9,8 +11,7 @@ define-function: (
     [storage_value, setting_attribute_value, toggle_attribute_value],
     block {
         assert-local-storage: {"rustdoc-auto-hide-large-items": |storage_value|}
-        click: "rustdoc-toolbar .settings-menu"
-        wait-for: "#settings"
+        call-function: ("open-settings-menu", {})
         assert-property: ("#auto-hide-large-items", {"checked": |setting_attribute_value|})
         assert-attribute: (".item-decl .type-contents-toggle", {"open": |toggle_attribute_value|})
     }
diff --git a/tests/rustdoc-gui/setting-auto-hide-item-methods-docs.goml b/tests/rustdoc-gui/setting-auto-hide-item-methods-docs.goml
index 02d4ce8855fd..89c1a8b0e98e 100644
--- a/tests/rustdoc-gui/setting-auto-hide-item-methods-docs.goml
+++ b/tests/rustdoc-gui/setting-auto-hide-item-methods-docs.goml
@@ -1,13 +1,14 @@
 // This test ensures that the "Auto-hide item methods' documentation" setting is working as
 // expected.
 
+include: "utils.goml"
+
 define-function: (
     "check-setting",
     [storage_value, setting_attribute_value, toggle_attribute_value],
     block {
         assert-local-storage: {"rustdoc-auto-hide-method-docs": |storage_value|}
-        click: "rustdoc-toolbar .settings-menu"
-        wait-for: "#settings"
+        call-function: ("open-settings-menu", {})
         assert-property: ("#auto-hide-method-docs", {"checked": |setting_attribute_value|})
         assert-attribute: (".toggle.method-toggle", {"open": |toggle_attribute_value|})
     }
diff --git a/tests/rustdoc-gui/setting-auto-hide-trait-implementations.goml b/tests/rustdoc-gui/setting-auto-hide-trait-implementations.goml
index 4af1e829b31c..81c26bfb7f3a 100644
--- a/tests/rustdoc-gui/setting-auto-hide-trait-implementations.goml
+++ b/tests/rustdoc-gui/setting-auto-hide-trait-implementations.goml
@@ -1,12 +1,13 @@
 // Checks that the setting "auto hide trait implementations" is working as expected.
 
+include: "utils.goml"
+
 define-function: (
     "check-setting",
     [storage_value, setting_attribute_value, toggle_attribute_value],
     block {
         assert-local-storage: {"rustdoc-auto-hide-trait-implementations": |storage_value|}
-        click: "rustdoc-toolbar .settings-menu"
-        wait-for: "#settings"
+        call-function: ("open-settings-menu", {})
         assert-property: ("#auto-hide-trait-implementations", {"checked": |setting_attribute_value|})
         assert-attribute: ("#trait-implementations-list > details", {"open": |toggle_attribute_value|}, ALL)
     }
diff --git a/tests/rustdoc-gui/setting-go-to-only-result.goml b/tests/rustdoc-gui/setting-go-to-only-result.goml
index 5a9c81e0b836..72c1e2bf59ca 100644
--- a/tests/rustdoc-gui/setting-go-to-only-result.goml
+++ b/tests/rustdoc-gui/setting-go-to-only-result.goml
@@ -1,12 +1,14 @@
-// Checks that the setting "Directly go to item in search if there is only one result " is working as expected.
+// Checks that the setting "Directly go to item in search if there is only one result " is working
+// as expected.
+
+include: "utils.goml"
 
 define-function: (
     "check-setting",
     [storage_value, setting_attribute_value],
     block {
         assert-local-storage: {"rustdoc-go-to-only-result": |storage_value|}
-        click: "rustdoc-toolbar .settings-menu"
-        wait-for: "#settings"
+        call-function: ("open-settings-menu", {})
         assert-property: ("#go-to-only-result", {"checked": |setting_attribute_value|})
     }
 )
@@ -25,8 +27,7 @@ wait-for: "#search"
 assert-document-property: ({"URL": "/lib2/index.html"}, CONTAINS)
 
 // Now we change its value.
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 click: "#go-to-only-result"
 assert-local-storage: {"rustdoc-go-to-only-result": "true"}
 
diff --git a/tests/rustdoc-gui/settings.goml b/tests/rustdoc-gui/settings.goml
index 7a163103b5ab..85994be468d3 100644
--- a/tests/rustdoc-gui/settings.goml
+++ b/tests/rustdoc-gui/settings.goml
@@ -1,20 +1,18 @@
 // This test ensures that the settings menu display is working as expected and that
 // the settings page is also rendered as expected.
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
 show-text: true // needed when we check for colors below.
 // First, we check that the settings page doesn't exist.
 assert-false: "#settings"
-// We now click on the settings button.
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 assert-css: ("#settings", {"display": "block"})
 
 // Store the line margin to compare with the settings.html later.
 store-css: (".setting-line", {"margin": setting_line_margin})
 
 // Let's close it by clicking on the same button.
-click: "rustdoc-toolbar .settings-menu"
-wait-for-css: ("#settings", {"display": "none"})
+call-function: ("close-settings-menu", {})
 
 // Let's check that pressing "ESCAPE" is closing it.
 click: "rustdoc-toolbar .settings-menu"
@@ -28,8 +26,7 @@ write: "test"
 // To be SURE that the search will be run.
 press-key: 'Enter'
 wait-for: "#alternative-display #search"
-click: "rustdoc-toolbar .settings-menu"
-wait-for-css: ("#settings", {"display": "block"})
+call-function: ("open-settings-menu", {})
 // Ensure that the search is still displayed.
 wait-for: "#alternative-display #search"
 assert: "#main-content.hidden"
@@ -41,8 +38,7 @@ set-local-storage: {"rustdoc-theme": "dark", "rustdoc-use-system-theme": "false"
 // We reload the page so the local storage settings are being used.
 reload:
 
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 
 // We check that the "Use system theme" is disabled.
 assert-property: ("#theme-system-preference", {"checked": "false"})
diff --git a/tests/rustdoc-gui/sidebar-mobile.goml b/tests/rustdoc-gui/sidebar-mobile.goml
index f828516d7624..3183650b555a 100644
--- a/tests/rustdoc-gui/sidebar-mobile.goml
+++ b/tests/rustdoc-gui/sidebar-mobile.goml
@@ -49,7 +49,7 @@ assert-property: ("rustdoc-topbar", {"clientHeight": "45"})
 // so the target is not obscured by the topbar.
 click: ".sidebar-menu-toggle"
 click: ".sidebar-elems section .block li > a"
-assert-position: ("#method\.must_use", {"y": 46})
+assert-position: ("#method\.must_use", {"y": 45})
 
 // Check that the bottom-most item on the sidebar menu can be scrolled fully into view.
 click: ".sidebar-menu-toggle"
@@ -65,8 +65,7 @@ define-function: (
     "check-colors",
     [theme, color, background],
     block {
-        call-function: ("switch-theme-mobile", {"theme": |theme|})
-        reload:
+        call-function: ("switch-theme", {"theme": |theme|})
 
         // Open the sidebar menu.
         click: ".sidebar-menu-toggle"
@@ -86,13 +85,3 @@ call-function: ("check-colors", {
     "color": "#c5c5c5",
     "background": "#14191f",
 })
-call-function: ("check-colors", {
-    "theme": "dark",
-    "color": "#ddd",
-    "background": "#505050",
-})
-call-function: ("check-colors", {
-    "theme": "light",
-    "color": "black",
-    "background": "#F5F5F5",
-})
diff --git a/tests/rustdoc-gui/sidebar-resize-close-popover.goml b/tests/rustdoc-gui/sidebar-resize-close-popover.goml
index d3fea9b0f400..ac8f7e9c65fa 100644
--- a/tests/rustdoc-gui/sidebar-resize-close-popover.goml
+++ b/tests/rustdoc-gui/sidebar-resize-close-popover.goml
@@ -1,9 +1,9 @@
 // Checks sidebar resizing close the Settings popover
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
 assert-property: (".sidebar", {"clientWidth": "199"})
 show-text: true
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 assert-css: ("#settings", {"display": "block"})
 // normal resizing
 drag-and-drop: ((205, 100), (185, 100))
@@ -12,8 +12,7 @@ assert-css: ("#settings", {"display": "none"})
 
 // Now same thing, but for source code
 go-to: "file://" + |DOC_PATH| + "/src/test_docs/lib.rs.html"
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 assert-css: ("#settings", {"display": "block"})
 assert-property: (".sidebar", {"clientWidth": "49"})
 drag-and-drop: ((52, 100), (185, 100))
diff --git a/tests/rustdoc-gui/sidebar-resize-setting.goml b/tests/rustdoc-gui/sidebar-resize-setting.goml
index a4572c670f81..132f5f387b29 100644
--- a/tests/rustdoc-gui/sidebar-resize-setting.goml
+++ b/tests/rustdoc-gui/sidebar-resize-setting.goml
@@ -1,11 +1,11 @@
 // Checks sidebar resizing stays synced with the setting
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
 assert-property: (".sidebar", {"clientWidth": "199"})
 show-text: true
 
 // Verify that the "hide" option is unchecked
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 assert-css: ("#settings", {"display": "block"})
 assert-property: ("#hide-sidebar", {"checked": "false"})
 press-key: "Escape"
diff --git a/tests/rustdoc-gui/sidebar-source-code-display.goml b/tests/rustdoc-gui/sidebar-source-code-display.goml
index 99810cd78633..d2b667b498bc 100644
--- a/tests/rustdoc-gui/sidebar-source-code-display.goml
+++ b/tests/rustdoc-gui/sidebar-source-code-display.goml
@@ -141,7 +141,7 @@ click: "#sidebar-button"
 wait-for-css: (".src .sidebar > *", {"visibility": "hidden"})
 // We scroll to line 117 to change the scroll position.
 scroll-to: '//*[@id="117"]'
-store-value: (y_offset, "2567")
+store-value: (y_offset, "2568")
 assert-window-property: {"pageYOffset": |y_offset|}
 // Expanding the sidebar...
 click: "#sidebar-button"
diff --git a/tests/rustdoc-gui/source-code-wrapping.goml b/tests/rustdoc-gui/source-code-wrapping.goml
index c1fc2835c89a..6dc56672da80 100644
--- a/tests/rustdoc-gui/source-code-wrapping.goml
+++ b/tests/rustdoc-gui/source-code-wrapping.goml
@@ -1,4 +1,5 @@
 // Checks that the interactions with the source code pages are working as expected.
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/src/test_docs/lib.rs.html"
 show-text: true
 set-window-size: (1000, 1000)
@@ -13,8 +14,7 @@ define-function: (
 )
 
 store-size: (".rust code", {"width": width, "height": height})
-click: "main .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 call-function: ("click-code-wrapping", {"expected": "true"})
 wait-for-size-false: (".rust code", {"width": |width|, "height": |height|})
 store-size: (".rust code", {"width": new_width, "height": new_height})
@@ -28,8 +28,7 @@ assert-size: (".rust code", {"width": |width|, "height": |height|})
 
 // Now let's check in docs code examples.
 go-to: "file://" + |DOC_PATH| + "/test_docs/trait_bounds/index.html"
-click: "main .settings-menu"
-wait-for: "#settings"
+call-function: ("open-settings-menu", {})
 
 store-property: (".example-wrap .rust code", {"scrollWidth": rust_width, "scrollHeight": rust_height})
 store-property: (".example-wrap .language-text code", {"scrollWidth": txt_width, "scrollHeight": txt_height})
diff --git a/tests/rustdoc-gui/src/staged_api/lib.rs b/tests/rustdoc-gui/src/staged_api/lib.rs
index 9b5ad1c5ff32..7304d2f02ab1 100644
--- a/tests/rustdoc-gui/src/staged_api/lib.rs
+++ b/tests/rustdoc-gui/src/staged_api/lib.rs
@@ -4,6 +4,10 @@
 #![stable(feature = "some_feature", since = "1.3.5")]
 #![doc(rust_logo)]
 
+pub trait X {
+    fn vroum();
+}
+
 #[stable(feature = "some_feature", since = "1.3.5")]
 pub struct Foo {}
 
@@ -13,3 +17,7 @@ impl Foo {
     #[stable(feature = "some_other_feature", since = "1.3.6")]
     pub fn yo() {}
 }
+
+impl X for Foo {
+    fn vroum() {}
+}
diff --git a/tests/rustdoc-gui/theme-change.goml b/tests/rustdoc-gui/theme-change.goml
index 3860596e3433..14b32baac57e 100644
--- a/tests/rustdoc-gui/theme-change.goml
+++ b/tests/rustdoc-gui/theme-change.goml
@@ -7,8 +7,7 @@ store-value: (background_light, "white")
 store-value: (background_dark, "#353535")
 store-value: (background_ayu, "#0f1419")
 
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#theme-ayu"
+call-function: ("open-settings-menu", {})
 click: "#theme-ayu"
 // should be the ayu theme so let's check the color.
 wait-for-css: ("body", { "background-color": |background_ayu| })
@@ -22,10 +21,6 @@ click: "#theme-dark"
 wait-for-css: ("body", { "background-color": |background_dark| })
 assert-local-storage: { "rustdoc-theme": "dark" }
 
-set-local-storage: {
-    "rustdoc-preferred-light-theme": "light",
-    "rustdoc-preferred-dark-theme": "light",
-}
 go-to: "file://" + |DOC_PATH| + "/settings.html"
 
 wait-for: "#settings"
@@ -75,8 +70,7 @@ store-value: (background_dark, "#353535")
 store-value: (background_ayu, "#0f1419")
 store-value: (background_custom_theme, "red")
 
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#theme-ayu"
+call-function: ("open-settings-menu", {})
 click: "#theme-ayu"
 // should be the ayu theme so let's check the color.
 wait-for-css: ("body", { "background-color": |background_ayu| })
diff --git a/tests/rustdoc-gui/theme-defaults.goml b/tests/rustdoc-gui/theme-defaults.goml
index 12c17166e874..b7ba64a4adaa 100644
--- a/tests/rustdoc-gui/theme-defaults.goml
+++ b/tests/rustdoc-gui/theme-defaults.goml
@@ -1,7 +1,7 @@
 // Ensure that the theme picker always starts with the actual defaults.
+include: "utils.goml"
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#theme-system-preference"
+call-function: ("open-settings-menu", {})
 assert: "#theme-system-preference:checked"
 assert: "#preferred-light-theme-light:checked"
 assert: "#preferred-dark-theme-dark:checked"
@@ -16,8 +16,7 @@ set-local-storage: {
     "rustdoc-theme": "ayu"
 }
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
-click: "rustdoc-toolbar .settings-menu"
-wait-for: "#theme-system-preference"
+call-function: ("open-settings-menu", {})
 assert: "#theme-system-preference:checked"
 assert: "#preferred-light-theme-light:checked"
 assert-false: "#preferred-dark-theme-dark:checked"
diff --git a/tests/rustdoc-gui/utils.goml b/tests/rustdoc-gui/utils.goml
index a40f9fc6fdd7..c0625ead2f1a 100644
--- a/tests/rustdoc-gui/utils.goml
+++ b/tests/rustdoc-gui/utils.goml
@@ -1,11 +1,35 @@
 // This file contains code to be re-used by other tests.
 
+define-function: (
+    "click-settings-button",
+    [],
+    block {
+        store-count: ("rustdoc-topbar", __topbar_count)
+        store-value: (__topbar_display, "none")
+        // The `rustdoc-topbar` element is created with JS when the window size is below a given
+        // size, however if the window size gets bigger again, the element isn't deleted, just
+        // hidden, so we need to check for both that it exists and is visible.
+        if: (|__topbar_count| != 0, block {
+            store-css: ("rustdoc-topbar", {"display": __topbar_display})
+        })
+
+        // Open the settings menu.
+        if: (|__topbar_display| != "none", block {
+            // In mobile mode, this is instead the "topbar" the settings button is located into.
+            click: "rustdoc-topbar .settings-menu"
+        })
+        else: block {
+            // We're not in mobile mode so clicking on the "normal" sidebar.
+            click: "rustdoc-toolbar .settings-menu"
+        }
+    }
+)
+
 define-function: (
     "open-settings-menu",
     [],
     block {
-        // Open the settings menu.
-        click: "rustdoc-toolbar .settings-menu"
+        call-function: ("click-settings-button", {})
         // Wait for the popover to appear...
         wait-for-css: ("#settings", {"display": "block"})
     }
@@ -15,7 +39,8 @@ define-function: (
     "close-settings-menu",
     [],
     block {
-        click: "rustdoc-toolbar .settings-menu"
+        call-function: ("click-settings-button", {})
+        // Wait for the popover to disappear...
         wait-for-css-false: ("#settings", {"display": "block"})
     }
 )
@@ -34,24 +59,6 @@ define-function: (
     },
 )
 
-// FIXME: To be removed once `browser-ui-test` has conditions.
-define-function: (
-    "switch-theme-mobile",
-    [theme],
-    block {
-        // Open the settings menu.
-        click: "rustdoc-topbar .settings-menu"
-        // Wait for the popover to appear...
-        wait-for-css: ("#settings", {"display": "block"})
-        // Change the setting.
-        click: "#theme-"+ |theme|
-        click: "rustdoc-topbar .settings-menu"
-        wait-for-css-false: ("#settings", {"display": "block"})
-        // Ensure that the local storage was correctly updated.
-        assert-local-storage: {"rustdoc-theme": |theme|}
-    },
-)
-
 define-function: (
     "perform-search",
     [query],
diff --git a/tests/rustdoc/all.rs b/tests/rustdoc-html/all.rs
similarity index 100%
rename from tests/rustdoc/all.rs
rename to tests/rustdoc-html/all.rs
diff --git a/tests/rustdoc/anchors/anchor-id-duplicate-method-name-25001.rs b/tests/rustdoc-html/anchors/anchor-id-duplicate-method-name-25001.rs
similarity index 100%
rename from tests/rustdoc/anchors/anchor-id-duplicate-method-name-25001.rs
rename to tests/rustdoc-html/anchors/anchor-id-duplicate-method-name-25001.rs
diff --git a/tests/rustdoc/anchors/anchor-id-trait-method-15169.rs b/tests/rustdoc-html/anchors/anchor-id-trait-method-15169.rs
similarity index 100%
rename from tests/rustdoc/anchors/anchor-id-trait-method-15169.rs
rename to tests/rustdoc-html/anchors/anchor-id-trait-method-15169.rs
diff --git a/tests/rustdoc/anchors/anchor-id-trait-tymethod-28478.rs b/tests/rustdoc-html/anchors/anchor-id-trait-tymethod-28478.rs
similarity index 100%
rename from tests/rustdoc/anchors/anchor-id-trait-tymethod-28478.rs
rename to tests/rustdoc-html/anchors/anchor-id-trait-tymethod-28478.rs
diff --git a/tests/rustdoc/anchors/anchors.no_const_anchor.html b/tests/rustdoc-html/anchors/anchors.no_const_anchor.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_const_anchor.html
rename to tests/rustdoc-html/anchors/anchors.no_const_anchor.html
diff --git a/tests/rustdoc/anchors/anchors.no_const_anchor2.html b/tests/rustdoc-html/anchors/anchors.no_const_anchor2.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_const_anchor2.html
rename to tests/rustdoc-html/anchors/anchors.no_const_anchor2.html
diff --git a/tests/rustdoc/anchors/anchors.no_method_anchor.html b/tests/rustdoc-html/anchors/anchors.no_method_anchor.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_method_anchor.html
rename to tests/rustdoc-html/anchors/anchors.no_method_anchor.html
diff --git a/tests/rustdoc/anchors/anchors.no_trait_method_anchor.html b/tests/rustdoc-html/anchors/anchors.no_trait_method_anchor.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_trait_method_anchor.html
rename to tests/rustdoc-html/anchors/anchors.no_trait_method_anchor.html
diff --git a/tests/rustdoc/anchors/anchors.no_tymethod_anchor.html b/tests/rustdoc-html/anchors/anchors.no_tymethod_anchor.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_tymethod_anchor.html
rename to tests/rustdoc-html/anchors/anchors.no_tymethod_anchor.html
diff --git a/tests/rustdoc/anchors/anchors.no_type_anchor.html b/tests/rustdoc-html/anchors/anchors.no_type_anchor.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_type_anchor.html
rename to tests/rustdoc-html/anchors/anchors.no_type_anchor.html
diff --git a/tests/rustdoc/anchors/anchors.no_type_anchor2.html b/tests/rustdoc-html/anchors/anchors.no_type_anchor2.html
similarity index 100%
rename from tests/rustdoc/anchors/anchors.no_type_anchor2.html
rename to tests/rustdoc-html/anchors/anchors.no_type_anchor2.html
diff --git a/tests/rustdoc/anchors/anchors.rs b/tests/rustdoc-html/anchors/anchors.rs
similarity index 100%
rename from tests/rustdoc/anchors/anchors.rs
rename to tests/rustdoc-html/anchors/anchors.rs
diff --git a/tests/rustdoc/anchors/auxiliary/issue-86620-1.rs b/tests/rustdoc-html/anchors/auxiliary/issue-86620-1.rs
similarity index 100%
rename from tests/rustdoc/anchors/auxiliary/issue-86620-1.rs
rename to tests/rustdoc-html/anchors/auxiliary/issue-86620-1.rs
diff --git a/tests/rustdoc/anchors/disambiguate-anchors-32890.rs b/tests/rustdoc-html/anchors/disambiguate-anchors-32890.rs
similarity index 100%
rename from tests/rustdoc/anchors/disambiguate-anchors-32890.rs
rename to tests/rustdoc-html/anchors/disambiguate-anchors-32890.rs
diff --git a/tests/rustdoc/anchors/disambiguate-anchors-header-29449.rs b/tests/rustdoc-html/anchors/disambiguate-anchors-header-29449.rs
similarity index 100%
rename from tests/rustdoc/anchors/disambiguate-anchors-header-29449.rs
rename to tests/rustdoc-html/anchors/disambiguate-anchors-header-29449.rs
diff --git a/tests/rustdoc/anchors/method-anchor-in-blanket-impl-86620.rs b/tests/rustdoc-html/anchors/method-anchor-in-blanket-impl-86620.rs
similarity index 100%
rename from tests/rustdoc/anchors/method-anchor-in-blanket-impl-86620.rs
rename to tests/rustdoc-html/anchors/method-anchor-in-blanket-impl-86620.rs
diff --git a/tests/rustdoc/anchors/trait-impl-items-links-and-anchors.rs b/tests/rustdoc-html/anchors/trait-impl-items-links-and-anchors.rs
similarity index 100%
rename from tests/rustdoc/anchors/trait-impl-items-links-and-anchors.rs
rename to tests/rustdoc-html/anchors/trait-impl-items-links-and-anchors.rs
diff --git a/tests/rustdoc/anon-fn-params.rs b/tests/rustdoc-html/anon-fn-params.rs
similarity index 100%
rename from tests/rustdoc/anon-fn-params.rs
rename to tests/rustdoc-html/anon-fn-params.rs
diff --git a/tests/rustdoc/anonymous-lifetime.rs b/tests/rustdoc-html/anonymous-lifetime.rs
similarity index 100%
rename from tests/rustdoc/anonymous-lifetime.rs
rename to tests/rustdoc-html/anonymous-lifetime.rs
diff --git a/tests/rustdoc/array-links.link_box_generic.html b/tests/rustdoc-html/array-links.link_box_generic.html
similarity index 100%
rename from tests/rustdoc/array-links.link_box_generic.html
rename to tests/rustdoc-html/array-links.link_box_generic.html
diff --git a/tests/rustdoc/array-links.link_box_u32.html b/tests/rustdoc-html/array-links.link_box_u32.html
similarity index 100%
rename from tests/rustdoc/array-links.link_box_u32.html
rename to tests/rustdoc-html/array-links.link_box_u32.html
diff --git a/tests/rustdoc/array-links.link_slice_generic.html b/tests/rustdoc-html/array-links.link_slice_generic.html
similarity index 100%
rename from tests/rustdoc/array-links.link_slice_generic.html
rename to tests/rustdoc-html/array-links.link_slice_generic.html
diff --git a/tests/rustdoc/array-links.link_slice_u32.html b/tests/rustdoc-html/array-links.link_slice_u32.html
similarity index 100%
rename from tests/rustdoc/array-links.link_slice_u32.html
rename to tests/rustdoc-html/array-links.link_slice_u32.html
diff --git a/tests/rustdoc/array-links.rs b/tests/rustdoc-html/array-links.rs
similarity index 100%
rename from tests/rustdoc/array-links.rs
rename to tests/rustdoc-html/array-links.rs
diff --git a/tests/rustdoc/asm-foreign.rs b/tests/rustdoc-html/asm-foreign.rs
similarity index 100%
rename from tests/rustdoc/asm-foreign.rs
rename to tests/rustdoc-html/asm-foreign.rs
diff --git a/tests/rustdoc/asm-foreign2.rs b/tests/rustdoc-html/asm-foreign2.rs
similarity index 100%
rename from tests/rustdoc/asm-foreign2.rs
rename to tests/rustdoc-html/asm-foreign2.rs
diff --git a/tests/rustdoc/asref-for-and-of-local-82465.rs b/tests/rustdoc-html/asref-for-and-of-local-82465.rs
similarity index 100%
rename from tests/rustdoc/asref-for-and-of-local-82465.rs
rename to tests/rustdoc-html/asref-for-and-of-local-82465.rs
diff --git a/tests/rustdoc/assoc/assoc-fns.rs b/tests/rustdoc-html/assoc/assoc-fns.rs
similarity index 100%
rename from tests/rustdoc/assoc/assoc-fns.rs
rename to tests/rustdoc-html/assoc/assoc-fns.rs
diff --git a/tests/rustdoc/assoc/assoc-item-cast.rs b/tests/rustdoc-html/assoc/assoc-item-cast.rs
similarity index 100%
rename from tests/rustdoc/assoc/assoc-item-cast.rs
rename to tests/rustdoc-html/assoc/assoc-item-cast.rs
diff --git a/tests/rustdoc/assoc/assoc-type-bindings-20646.rs b/tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs
similarity index 100%
rename from tests/rustdoc/assoc/assoc-type-bindings-20646.rs
rename to tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs
diff --git a/tests/rustdoc/assoc/assoc-types.rs b/tests/rustdoc-html/assoc/assoc-types.rs
similarity index 100%
rename from tests/rustdoc/assoc/assoc-types.rs
rename to tests/rustdoc-html/assoc/assoc-types.rs
diff --git a/tests/rustdoc/assoc/auxiliary/cross-crate-hidden-assoc-trait-items.rs b/tests/rustdoc-html/assoc/auxiliary/cross-crate-hidden-assoc-trait-items.rs
similarity index 100%
rename from tests/rustdoc/assoc/auxiliary/cross-crate-hidden-assoc-trait-items.rs
rename to tests/rustdoc-html/assoc/auxiliary/cross-crate-hidden-assoc-trait-items.rs
diff --git a/tests/rustdoc/assoc/auxiliary/issue-20646.rs b/tests/rustdoc-html/assoc/auxiliary/issue-20646.rs
similarity index 100%
rename from tests/rustdoc/assoc/auxiliary/issue-20646.rs
rename to tests/rustdoc-html/assoc/auxiliary/issue-20646.rs
diff --git a/tests/rustdoc/assoc/auxiliary/issue-20727.rs b/tests/rustdoc-html/assoc/auxiliary/issue-20727.rs
similarity index 100%
rename from tests/rustdoc/assoc/auxiliary/issue-20727.rs
rename to tests/rustdoc-html/assoc/auxiliary/issue-20727.rs
diff --git a/tests/rustdoc/assoc/auxiliary/normalize-assoc-item.rs b/tests/rustdoc-html/assoc/auxiliary/normalize-assoc-item.rs
similarity index 100%
rename from tests/rustdoc/assoc/auxiliary/normalize-assoc-item.rs
rename to tests/rustdoc-html/assoc/auxiliary/normalize-assoc-item.rs
diff --git a/tests/rustdoc/assoc/cross-crate-hidden-assoc-trait-items.rs b/tests/rustdoc-html/assoc/cross-crate-hidden-assoc-trait-items.rs
similarity index 100%
rename from tests/rustdoc/assoc/cross-crate-hidden-assoc-trait-items.rs
rename to tests/rustdoc-html/assoc/cross-crate-hidden-assoc-trait-items.rs
diff --git a/tests/rustdoc/assoc/doc-assoc-item.rs b/tests/rustdoc-html/assoc/doc-assoc-item.rs
similarity index 100%
rename from tests/rustdoc/assoc/doc-assoc-item.rs
rename to tests/rustdoc-html/assoc/doc-assoc-item.rs
diff --git a/tests/rustdoc/assoc/inline-assoc-type-20727-bindings.rs b/tests/rustdoc-html/assoc/inline-assoc-type-20727-bindings.rs
similarity index 100%
rename from tests/rustdoc/assoc/inline-assoc-type-20727-bindings.rs
rename to tests/rustdoc-html/assoc/inline-assoc-type-20727-bindings.rs
diff --git a/tests/rustdoc/assoc/inline-assoc-type-20727-bounds-deref.rs b/tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds-deref.rs
similarity index 100%
rename from tests/rustdoc/assoc/inline-assoc-type-20727-bounds-deref.rs
rename to tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds-deref.rs
diff --git a/tests/rustdoc/assoc/inline-assoc-type-20727-bounds-index.rs b/tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds-index.rs
similarity index 100%
rename from tests/rustdoc/assoc/inline-assoc-type-20727-bounds-index.rs
rename to tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds-index.rs
diff --git a/tests/rustdoc/assoc/inline-assoc-type-20727-bounds.rs b/tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds.rs
similarity index 100%
rename from tests/rustdoc/assoc/inline-assoc-type-20727-bounds.rs
rename to tests/rustdoc-html/assoc/inline-assoc-type-20727-bounds.rs
diff --git a/tests/rustdoc/assoc/normalize-assoc-item.rs b/tests/rustdoc-html/assoc/normalize-assoc-item.rs
similarity index 100%
rename from tests/rustdoc/assoc/normalize-assoc-item.rs
rename to tests/rustdoc-html/assoc/normalize-assoc-item.rs
diff --git a/tests/rustdoc/async/async-fn-opaque-item.rs b/tests/rustdoc-html/async/async-fn-opaque-item.rs
similarity index 100%
rename from tests/rustdoc/async/async-fn-opaque-item.rs
rename to tests/rustdoc-html/async/async-fn-opaque-item.rs
diff --git a/tests/rustdoc/async/async-fn.rs b/tests/rustdoc-html/async/async-fn.rs
similarity index 100%
rename from tests/rustdoc/async/async-fn.rs
rename to tests/rustdoc-html/async/async-fn.rs
diff --git a/tests/rustdoc/async/async-move-doctest.rs b/tests/rustdoc-html/async/async-move-doctest.rs
similarity index 100%
rename from tests/rustdoc/async/async-move-doctest.rs
rename to tests/rustdoc-html/async/async-move-doctest.rs
diff --git a/tests/rustdoc/async/async-trait-sig.rs b/tests/rustdoc-html/async/async-trait-sig.rs
similarity index 100%
rename from tests/rustdoc/async/async-trait-sig.rs
rename to tests/rustdoc-html/async/async-trait-sig.rs
diff --git a/tests/rustdoc/async/async-trait.rs b/tests/rustdoc-html/async/async-trait.rs
similarity index 100%
rename from tests/rustdoc/async/async-trait.rs
rename to tests/rustdoc-html/async/async-trait.rs
diff --git a/tests/rustdoc/async/auxiliary/async-trait-dep.rs b/tests/rustdoc-html/async/auxiliary/async-trait-dep.rs
similarity index 100%
rename from tests/rustdoc/async/auxiliary/async-trait-dep.rs
rename to tests/rustdoc-html/async/auxiliary/async-trait-dep.rs
diff --git a/tests/rustdoc/attributes-2021-edition.rs b/tests/rustdoc-html/attributes-2021-edition.rs
similarity index 100%
rename from tests/rustdoc/attributes-2021-edition.rs
rename to tests/rustdoc-html/attributes-2021-edition.rs
diff --git a/tests/rustdoc/attributes-inlining-108281.rs b/tests/rustdoc-html/attributes-inlining-108281.rs
similarity index 100%
rename from tests/rustdoc/attributes-inlining-108281.rs
rename to tests/rustdoc-html/attributes-inlining-108281.rs
diff --git a/tests/rustdoc/attributes-re-export-2021-edition.rs b/tests/rustdoc-html/attributes-re-export-2021-edition.rs
similarity index 100%
rename from tests/rustdoc/attributes-re-export-2021-edition.rs
rename to tests/rustdoc-html/attributes-re-export-2021-edition.rs
diff --git a/tests/rustdoc/attributes-re-export.rs b/tests/rustdoc-html/attributes-re-export.rs
similarity index 100%
rename from tests/rustdoc/attributes-re-export.rs
rename to tests/rustdoc-html/attributes-re-export.rs
diff --git a/tests/rustdoc/attributes.rs b/tests/rustdoc-html/attributes.rs
similarity index 100%
rename from tests/rustdoc/attributes.rs
rename to tests/rustdoc-html/attributes.rs
diff --git a/tests/rustdoc/auto/auto-impl-for-trait.rs b/tests/rustdoc-html/auto/auto-impl-for-trait.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-impl-for-trait.rs
rename to tests/rustdoc-html/auto/auto-impl-for-trait.rs
diff --git a/tests/rustdoc/auto/auto-impl-primitive.rs b/tests/rustdoc-html/auto/auto-impl-primitive.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-impl-primitive.rs
rename to tests/rustdoc-html/auto/auto-impl-primitive.rs
diff --git a/tests/rustdoc/auto/auto-trait-bounds-by-associated-type-50159.rs b/tests/rustdoc-html/auto/auto-trait-bounds-by-associated-type-50159.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-trait-bounds-by-associated-type-50159.rs
rename to tests/rustdoc-html/auto/auto-trait-bounds-by-associated-type-50159.rs
diff --git a/tests/rustdoc/auto/auto-trait-bounds-inference-variables-54705.rs b/tests/rustdoc-html/auto/auto-trait-bounds-inference-variables-54705.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-trait-bounds-inference-variables-54705.rs
rename to tests/rustdoc-html/auto/auto-trait-bounds-inference-variables-54705.rs
diff --git a/tests/rustdoc/auto/auto-trait-bounds-where-51236.rs b/tests/rustdoc-html/auto/auto-trait-bounds-where-51236.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-trait-bounds-where-51236.rs
rename to tests/rustdoc-html/auto/auto-trait-bounds-where-51236.rs
diff --git a/tests/rustdoc/auto/auto-trait-negative-impl-55321.rs b/tests/rustdoc-html/auto/auto-trait-negative-impl-55321.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-trait-negative-impl-55321.rs
rename to tests/rustdoc-html/auto/auto-trait-negative-impl-55321.rs
diff --git a/tests/rustdoc/auto/auto-trait-not-send.rs b/tests/rustdoc-html/auto/auto-trait-not-send.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-trait-not-send.rs
rename to tests/rustdoc-html/auto/auto-trait-not-send.rs
diff --git a/tests/rustdoc/auto/auto-traits.rs b/tests/rustdoc-html/auto/auto-traits.rs
similarity index 100%
rename from tests/rustdoc/auto/auto-traits.rs
rename to tests/rustdoc-html/auto/auto-traits.rs
diff --git a/tests/rustdoc/auto/auto_aliases.rs b/tests/rustdoc-html/auto/auto_aliases.rs
similarity index 100%
rename from tests/rustdoc/auto/auto_aliases.rs
rename to tests/rustdoc-html/auto/auto_aliases.rs
diff --git a/tests/rustdoc/auto/auxiliary/auto-traits.rs b/tests/rustdoc-html/auto/auxiliary/auto-traits.rs
similarity index 100%
rename from tests/rustdoc/auto/auxiliary/auto-traits.rs
rename to tests/rustdoc-html/auto/auxiliary/auto-traits.rs
diff --git a/tests/rustdoc/auxiliary/all-item-types.rs b/tests/rustdoc-html/auxiliary/all-item-types.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/all-item-types.rs
rename to tests/rustdoc-html/auxiliary/all-item-types.rs
diff --git a/tests/rustdoc/auxiliary/cross_crate_generic_typedef.rs b/tests/rustdoc-html/auxiliary/cross_crate_generic_typedef.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/cross_crate_generic_typedef.rs
rename to tests/rustdoc-html/auxiliary/cross_crate_generic_typedef.rs
diff --git a/tests/rustdoc/auxiliary/elided-lifetime.rs b/tests/rustdoc-html/auxiliary/elided-lifetime.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/elided-lifetime.rs
rename to tests/rustdoc-html/auxiliary/elided-lifetime.rs
diff --git a/tests/rustdoc/auxiliary/empty.rs b/tests/rustdoc-html/auxiliary/empty.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/empty.rs
rename to tests/rustdoc-html/auxiliary/empty.rs
diff --git a/tests/rustdoc/auxiliary/enum-primitive.rs b/tests/rustdoc-html/auxiliary/enum-primitive.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/enum-primitive.rs
rename to tests/rustdoc-html/auxiliary/enum-primitive.rs
diff --git a/tests/rustdoc/auxiliary/ext-anon-fn-params.rs b/tests/rustdoc-html/auxiliary/ext-anon-fn-params.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/ext-anon-fn-params.rs
rename to tests/rustdoc-html/auxiliary/ext-anon-fn-params.rs
diff --git a/tests/rustdoc/auxiliary/ext-repr.rs b/tests/rustdoc-html/auxiliary/ext-repr.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/ext-repr.rs
rename to tests/rustdoc-html/auxiliary/ext-repr.rs
diff --git a/tests/rustdoc/auxiliary/ext-trait-aliases.rs b/tests/rustdoc-html/auxiliary/ext-trait-aliases.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/ext-trait-aliases.rs
rename to tests/rustdoc-html/auxiliary/ext-trait-aliases.rs
diff --git a/tests/rustdoc/auxiliary/inline-default-methods.rs b/tests/rustdoc-html/auxiliary/inline-default-methods.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/inline-default-methods.rs
rename to tests/rustdoc-html/auxiliary/inline-default-methods.rs
diff --git a/tests/rustdoc/auxiliary/issue-106421-force-unstable.rs b/tests/rustdoc-html/auxiliary/issue-106421-force-unstable.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-106421-force-unstable.rs
rename to tests/rustdoc-html/auxiliary/issue-106421-force-unstable.rs
diff --git a/tests/rustdoc/auxiliary/issue-13698.rs b/tests/rustdoc-html/auxiliary/issue-13698.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-13698.rs
rename to tests/rustdoc-html/auxiliary/issue-13698.rs
diff --git a/tests/rustdoc/auxiliary/issue-19190-3.rs b/tests/rustdoc-html/auxiliary/issue-19190-3.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-19190-3.rs
rename to tests/rustdoc-html/auxiliary/issue-19190-3.rs
diff --git a/tests/rustdoc/auxiliary/issue-61592.rs b/tests/rustdoc-html/auxiliary/issue-61592.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-61592.rs
rename to tests/rustdoc-html/auxiliary/issue-61592.rs
diff --git a/tests/rustdoc/auxiliary/issue-99221-aux.rs b/tests/rustdoc-html/auxiliary/issue-99221-aux.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-99221-aux.rs
rename to tests/rustdoc-html/auxiliary/issue-99221-aux.rs
diff --git a/tests/rustdoc/auxiliary/issue-99734-aux.rs b/tests/rustdoc-html/auxiliary/issue-99734-aux.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-99734-aux.rs
rename to tests/rustdoc-html/auxiliary/issue-99734-aux.rs
diff --git a/tests/rustdoc/auxiliary/jump-to-def-res-err-handling-aux.rs b/tests/rustdoc-html/auxiliary/jump-to-def-res-err-handling-aux.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/jump-to-def-res-err-handling-aux.rs
rename to tests/rustdoc-html/auxiliary/jump-to-def-res-err-handling-aux.rs
diff --git a/tests/rustdoc/auxiliary/masked.rs b/tests/rustdoc-html/auxiliary/masked.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/masked.rs
rename to tests/rustdoc-html/auxiliary/masked.rs
diff --git a/tests/rustdoc/auxiliary/mod-stackoverflow.rs b/tests/rustdoc-html/auxiliary/mod-stackoverflow.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/mod-stackoverflow.rs
rename to tests/rustdoc-html/auxiliary/mod-stackoverflow.rs
diff --git a/tests/rustdoc/auxiliary/reexp-stripped.rs b/tests/rustdoc-html/auxiliary/reexp-stripped.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/reexp-stripped.rs
rename to tests/rustdoc-html/auxiliary/reexp-stripped.rs
diff --git a/tests/rustdoc/auxiliary/remapped-paths.rs b/tests/rustdoc-html/auxiliary/remapped-paths.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/remapped-paths.rs
rename to tests/rustdoc-html/auxiliary/remapped-paths.rs
diff --git a/tests/rustdoc/auxiliary/rustdoc-ffi.rs b/tests/rustdoc-html/auxiliary/rustdoc-ffi.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/rustdoc-ffi.rs
rename to tests/rustdoc-html/auxiliary/rustdoc-ffi.rs
diff --git a/tests/rustdoc/auxiliary/trait-visibility.rs b/tests/rustdoc-html/auxiliary/trait-visibility.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/trait-visibility.rs
rename to tests/rustdoc-html/auxiliary/trait-visibility.rs
diff --git a/tests/rustdoc/auxiliary/unit-return.rs b/tests/rustdoc-html/auxiliary/unit-return.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/unit-return.rs
rename to tests/rustdoc-html/auxiliary/unit-return.rs
diff --git a/tests/rustdoc/auxiliary/unsafe-binder-dep.rs b/tests/rustdoc-html/auxiliary/unsafe-binder-dep.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/unsafe-binder-dep.rs
rename to tests/rustdoc-html/auxiliary/unsafe-binder-dep.rs
diff --git a/tests/rustdoc/auxiliary/unstable-trait.rs b/tests/rustdoc-html/auxiliary/unstable-trait.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/unstable-trait.rs
rename to tests/rustdoc-html/auxiliary/unstable-trait.rs
diff --git a/tests/rustdoc/bad-codeblock-syntax.rs b/tests/rustdoc-html/bad-codeblock-syntax.rs
similarity index 100%
rename from tests/rustdoc/bad-codeblock-syntax.rs
rename to tests/rustdoc-html/bad-codeblock-syntax.rs
diff --git a/tests/rustdoc/blank-line-in-doc-block-47197.rs b/tests/rustdoc-html/blank-line-in-doc-block-47197.rs
similarity index 100%
rename from tests/rustdoc/blank-line-in-doc-block-47197.rs
rename to tests/rustdoc-html/blank-line-in-doc-block-47197.rs
diff --git a/tests/rustdoc/bold-tag-101743.rs b/tests/rustdoc-html/bold-tag-101743.rs
similarity index 100%
rename from tests/rustdoc/bold-tag-101743.rs
rename to tests/rustdoc-html/bold-tag-101743.rs
diff --git a/tests/rustdoc/bounds.rs b/tests/rustdoc-html/bounds.rs
similarity index 100%
rename from tests/rustdoc/bounds.rs
rename to tests/rustdoc-html/bounds.rs
diff --git a/tests/rustdoc/cap-lints.rs b/tests/rustdoc-html/cap-lints.rs
similarity index 100%
rename from tests/rustdoc/cap-lints.rs
rename to tests/rustdoc-html/cap-lints.rs
diff --git a/tests/rustdoc/cfg-bool.rs b/tests/rustdoc-html/cfg-bool.rs
similarity index 100%
rename from tests/rustdoc/cfg-bool.rs
rename to tests/rustdoc-html/cfg-bool.rs
diff --git a/tests/rustdoc/cfg-doctest.rs b/tests/rustdoc-html/cfg-doctest.rs
similarity index 100%
rename from tests/rustdoc/cfg-doctest.rs
rename to tests/rustdoc-html/cfg-doctest.rs
diff --git a/tests/rustdoc/check-styled-link.rs b/tests/rustdoc-html/check-styled-link.rs
similarity index 100%
rename from tests/rustdoc/check-styled-link.rs
rename to tests/rustdoc-html/check-styled-link.rs
diff --git a/tests/rustdoc/check.rs b/tests/rustdoc-html/check.rs
similarity index 100%
rename from tests/rustdoc/check.rs
rename to tests/rustdoc-html/check.rs
diff --git a/tests/rustdoc/codeblock-title.rs b/tests/rustdoc-html/codeblock-title.rs
similarity index 100%
rename from tests/rustdoc/codeblock-title.rs
rename to tests/rustdoc-html/codeblock-title.rs
diff --git a/tests/rustdoc/comment-in-doctest.rs b/tests/rustdoc-html/comment-in-doctest.rs
similarity index 100%
rename from tests/rustdoc/comment-in-doctest.rs
rename to tests/rustdoc-html/comment-in-doctest.rs
diff --git a/tests/rustdoc/const-fn-76501.rs b/tests/rustdoc-html/const-fn-76501.rs
similarity index 100%
rename from tests/rustdoc/const-fn-76501.rs
rename to tests/rustdoc-html/const-fn-76501.rs
diff --git a/tests/rustdoc/const-fn-effects.rs b/tests/rustdoc-html/const-fn-effects.rs
similarity index 100%
rename from tests/rustdoc/const-fn-effects.rs
rename to tests/rustdoc-html/const-fn-effects.rs
diff --git a/tests/rustdoc/const-fn.rs b/tests/rustdoc-html/const-fn.rs
similarity index 100%
rename from tests/rustdoc/const-fn.rs
rename to tests/rustdoc-html/const-fn.rs
diff --git a/tests/rustdoc/const-generics/add-impl.rs b/tests/rustdoc-html/const-generics/add-impl.rs
similarity index 100%
rename from tests/rustdoc/const-generics/add-impl.rs
rename to tests/rustdoc-html/const-generics/add-impl.rs
diff --git a/tests/rustdoc/const-generics/auxiliary/extern_crate.rs b/tests/rustdoc-html/const-generics/auxiliary/extern_crate.rs
similarity index 100%
rename from tests/rustdoc/const-generics/auxiliary/extern_crate.rs
rename to tests/rustdoc-html/const-generics/auxiliary/extern_crate.rs
diff --git a/tests/rustdoc/const-generics/const-generic-defaults.rs b/tests/rustdoc-html/const-generics/const-generic-defaults.rs
similarity index 100%
rename from tests/rustdoc/const-generics/const-generic-defaults.rs
rename to tests/rustdoc-html/const-generics/const-generic-defaults.rs
diff --git a/tests/rustdoc/const-generics/const-generic-slice.rs b/tests/rustdoc-html/const-generics/const-generic-slice.rs
similarity index 100%
rename from tests/rustdoc/const-generics/const-generic-slice.rs
rename to tests/rustdoc-html/const-generics/const-generic-slice.rs
diff --git a/tests/rustdoc/const-generics/const-generics-docs.rs b/tests/rustdoc-html/const-generics/const-generics-docs.rs
similarity index 100%
rename from tests/rustdoc/const-generics/const-generics-docs.rs
rename to tests/rustdoc-html/const-generics/const-generics-docs.rs
diff --git a/tests/rustdoc/const-generics/const-impl.rs b/tests/rustdoc-html/const-generics/const-impl.rs
similarity index 100%
rename from tests/rustdoc/const-generics/const-impl.rs
rename to tests/rustdoc-html/const-generics/const-impl.rs
diff --git a/tests/rustdoc/const-generics/const-param-type-references-generics.rs b/tests/rustdoc-html/const-generics/const-param-type-references-generics.rs
similarity index 100%
rename from tests/rustdoc/const-generics/const-param-type-references-generics.rs
rename to tests/rustdoc-html/const-generics/const-param-type-references-generics.rs
diff --git a/tests/rustdoc/const-generics/generic_const_exprs.rs b/tests/rustdoc-html/const-generics/generic_const_exprs.rs
similarity index 100%
rename from tests/rustdoc/const-generics/generic_const_exprs.rs
rename to tests/rustdoc-html/const-generics/generic_const_exprs.rs
diff --git a/tests/rustdoc/const-generics/lazy_normalization_consts/const-equate-pred.rs b/tests/rustdoc-html/const-generics/lazy_normalization_consts/const-equate-pred.rs
similarity index 100%
rename from tests/rustdoc/const-generics/lazy_normalization_consts/const-equate-pred.rs
rename to tests/rustdoc-html/const-generics/lazy_normalization_consts/const-equate-pred.rs
diff --git a/tests/rustdoc/const-generics/type-alias.rs b/tests/rustdoc-html/const-generics/type-alias.rs
similarity index 100%
rename from tests/rustdoc/const-generics/type-alias.rs
rename to tests/rustdoc-html/const-generics/type-alias.rs
diff --git a/tests/rustdoc/const-intrinsic.rs b/tests/rustdoc-html/const-intrinsic.rs
similarity index 100%
rename from tests/rustdoc/const-intrinsic.rs
rename to tests/rustdoc-html/const-intrinsic.rs
diff --git a/tests/rustdoc/constant/assoc-consts-underscore.rs b/tests/rustdoc-html/constant/assoc-consts-underscore.rs
similarity index 100%
rename from tests/rustdoc/constant/assoc-consts-underscore.rs
rename to tests/rustdoc-html/constant/assoc-consts-underscore.rs
diff --git a/tests/rustdoc/constant/assoc-consts-version.rs b/tests/rustdoc-html/constant/assoc-consts-version.rs
similarity index 100%
rename from tests/rustdoc/constant/assoc-consts-version.rs
rename to tests/rustdoc-html/constant/assoc-consts-version.rs
diff --git a/tests/rustdoc/constant/assoc-consts.rs b/tests/rustdoc-html/constant/assoc-consts.rs
similarity index 100%
rename from tests/rustdoc/constant/assoc-consts.rs
rename to tests/rustdoc-html/constant/assoc-consts.rs
diff --git a/tests/rustdoc/constant/associated-consts.rs b/tests/rustdoc-html/constant/associated-consts.rs
similarity index 100%
rename from tests/rustdoc/constant/associated-consts.rs
rename to tests/rustdoc-html/constant/associated-consts.rs
diff --git a/tests/rustdoc/constant/const-display.rs b/tests/rustdoc-html/constant/const-display.rs
similarity index 100%
rename from tests/rustdoc/constant/const-display.rs
rename to tests/rustdoc-html/constant/const-display.rs
diff --git a/tests/rustdoc/constant/const-doc.rs b/tests/rustdoc-html/constant/const-doc.rs
similarity index 100%
rename from tests/rustdoc/constant/const-doc.rs
rename to tests/rustdoc-html/constant/const-doc.rs
diff --git a/tests/rustdoc/constant/const-effect-param.rs b/tests/rustdoc-html/constant/const-effect-param.rs
similarity index 100%
rename from tests/rustdoc/constant/const-effect-param.rs
rename to tests/rustdoc-html/constant/const-effect-param.rs
diff --git a/tests/rustdoc/constant/const-trait-and-impl-methods.rs b/tests/rustdoc-html/constant/const-trait-and-impl-methods.rs
similarity index 100%
rename from tests/rustdoc/constant/const-trait-and-impl-methods.rs
rename to tests/rustdoc-html/constant/const-trait-and-impl-methods.rs
diff --git a/tests/rustdoc/constant/const-underscore.rs b/tests/rustdoc-html/constant/const-underscore.rs
similarity index 100%
rename from tests/rustdoc/constant/const-underscore.rs
rename to tests/rustdoc-html/constant/const-underscore.rs
diff --git a/tests/rustdoc/constant/const-value-display.rs b/tests/rustdoc-html/constant/const-value-display.rs
similarity index 100%
rename from tests/rustdoc/constant/const-value-display.rs
rename to tests/rustdoc-html/constant/const-value-display.rs
diff --git a/tests/rustdoc/constant/const.rs b/tests/rustdoc-html/constant/const.rs
similarity index 100%
rename from tests/rustdoc/constant/const.rs
rename to tests/rustdoc-html/constant/const.rs
diff --git a/tests/rustdoc/constant/document-item-with-associated-const-in-where-clause.rs b/tests/rustdoc-html/constant/document-item-with-associated-const-in-where-clause.rs
similarity index 100%
rename from tests/rustdoc/constant/document-item-with-associated-const-in-where-clause.rs
rename to tests/rustdoc-html/constant/document-item-with-associated-const-in-where-clause.rs
diff --git a/tests/rustdoc/constant/generic-const-items.rs b/tests/rustdoc-html/constant/generic-const-items.rs
similarity index 100%
rename from tests/rustdoc/constant/generic-const-items.rs
rename to tests/rustdoc-html/constant/generic-const-items.rs
diff --git a/tests/rustdoc/constant/generic_const_exprs.rs b/tests/rustdoc-html/constant/generic_const_exprs.rs
similarity index 100%
rename from tests/rustdoc/constant/generic_const_exprs.rs
rename to tests/rustdoc-html/constant/generic_const_exprs.rs
diff --git a/tests/rustdoc/constant/glob-shadowing-const.rs b/tests/rustdoc-html/constant/glob-shadowing-const.rs
similarity index 100%
rename from tests/rustdoc/constant/glob-shadowing-const.rs
rename to tests/rustdoc-html/constant/glob-shadowing-const.rs
diff --git a/tests/rustdoc/constant/hide-complex-unevaluated-const-arguments.rs b/tests/rustdoc-html/constant/hide-complex-unevaluated-const-arguments.rs
similarity index 100%
rename from tests/rustdoc/constant/hide-complex-unevaluated-const-arguments.rs
rename to tests/rustdoc-html/constant/hide-complex-unevaluated-const-arguments.rs
diff --git a/tests/rustdoc/constant/hide-complex-unevaluated-consts.rs b/tests/rustdoc-html/constant/hide-complex-unevaluated-consts.rs
similarity index 100%
rename from tests/rustdoc/constant/hide-complex-unevaluated-consts.rs
rename to tests/rustdoc-html/constant/hide-complex-unevaluated-consts.rs
diff --git a/tests/rustdoc-html/constant/ice-associated-const-equality-105952.rs b/tests/rustdoc-html/constant/ice-associated-const-equality-105952.rs
new file mode 100644
index 000000000000..310e56b917fc
--- /dev/null
+++ b/tests/rustdoc-html/constant/ice-associated-const-equality-105952.rs
@@ -0,0 +1,20 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/105952>
+
+#![crate_name = "foo"]
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+use std::marker::ConstParamTy;
+
+#[derive(PartialEq, Eq, ConstParamTy)]
+pub enum ParseMode {
+    Raw,
+}
+pub trait Parse {
+    #[type_const]
+    const PARSE_MODE: ParseMode;
+}
+pub trait RenderRaw {}
+
+//@ hasraw foo/trait.RenderRaw.html 'impl'
+//@ hasraw foo/trait.RenderRaw.html 'ParseMode::Raw'
+impl<T: Parse<PARSE_MODE = { ParseMode::Raw }>> RenderRaw for T {}
diff --git a/tests/rustdoc/constant/legacy-const-generic.rs b/tests/rustdoc-html/constant/legacy-const-generic.rs
similarity index 100%
rename from tests/rustdoc/constant/legacy-const-generic.rs
rename to tests/rustdoc-html/constant/legacy-const-generic.rs
diff --git a/tests/rustdoc/constant/link-assoc-const.rs b/tests/rustdoc-html/constant/link-assoc-const.rs
similarity index 100%
rename from tests/rustdoc/constant/link-assoc-const.rs
rename to tests/rustdoc-html/constant/link-assoc-const.rs
diff --git a/tests/rustdoc/constant/redirect-const.rs b/tests/rustdoc-html/constant/redirect-const.rs
similarity index 100%
rename from tests/rustdoc/constant/redirect-const.rs
rename to tests/rustdoc-html/constant/redirect-const.rs
diff --git a/tests/rustdoc/constant/rfc-2632-const-trait-impl.rs b/tests/rustdoc-html/constant/rfc-2632-const-trait-impl.rs
similarity index 100%
rename from tests/rustdoc/constant/rfc-2632-const-trait-impl.rs
rename to tests/rustdoc-html/constant/rfc-2632-const-trait-impl.rs
diff --git a/tests/rustdoc/constant/show-const-contents.rs b/tests/rustdoc-html/constant/show-const-contents.rs
similarity index 100%
rename from tests/rustdoc/constant/show-const-contents.rs
rename to tests/rustdoc-html/constant/show-const-contents.rs
diff --git a/tests/rustdoc/constructor-imports.rs b/tests/rustdoc-html/constructor-imports.rs
similarity index 100%
rename from tests/rustdoc/constructor-imports.rs
rename to tests/rustdoc-html/constructor-imports.rs
diff --git a/tests/rustdoc/crate-doc-hidden-109695.rs b/tests/rustdoc-html/crate-doc-hidden-109695.rs
similarity index 100%
rename from tests/rustdoc/crate-doc-hidden-109695.rs
rename to tests/rustdoc-html/crate-doc-hidden-109695.rs
diff --git a/tests/rustdoc/crate-version-escape.rs b/tests/rustdoc-html/crate-version-escape.rs
similarity index 100%
rename from tests/rustdoc/crate-version-escape.rs
rename to tests/rustdoc-html/crate-version-escape.rs
diff --git a/tests/rustdoc/crate-version-extra.rs b/tests/rustdoc-html/crate-version-extra.rs
similarity index 100%
rename from tests/rustdoc/crate-version-extra.rs
rename to tests/rustdoc-html/crate-version-extra.rs
diff --git a/tests/rustdoc/crate-version.rs b/tests/rustdoc-html/crate-version.rs
similarity index 100%
rename from tests/rustdoc/crate-version.rs
rename to tests/rustdoc-html/crate-version.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/s.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/s.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive-no-index/s.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive-no-index/s.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/q.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive/auxiliary/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/q.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive/auxiliary/q.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/t.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive/auxiliary/t.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/t.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive/auxiliary/t.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/s.rs b/tests/rustdoc-html/cross-crate-info/cargo-transitive/s.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-transitive/s.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-transitive/s.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-two-no-index/auxiliary/f.rs b/tests/rustdoc-html/cross-crate-info/cargo-two-no-index/auxiliary/f.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-two-no-index/auxiliary/f.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-two-no-index/auxiliary/f.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-two-no-index/e.rs b/tests/rustdoc-html/cross-crate-info/cargo-two-no-index/e.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-two-no-index/e.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-two-no-index/e.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-two/auxiliary/f.rs b/tests/rustdoc-html/cross-crate-info/cargo-two/auxiliary/f.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-two/auxiliary/f.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-two/auxiliary/f.rs
diff --git a/tests/rustdoc/cross-crate-info/cargo-two/e.rs b/tests/rustdoc-html/cross-crate-info/cargo-two/e.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/cargo-two/e.rs
rename to tests/rustdoc-html/cross-crate-info/cargo-two/e.rs
diff --git a/tests/rustdoc/cross-crate-info/index-on-last/auxiliary/f.rs b/tests/rustdoc-html/cross-crate-info/index-on-last/auxiliary/f.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/index-on-last/auxiliary/f.rs
rename to tests/rustdoc-html/cross-crate-info/index-on-last/auxiliary/f.rs
diff --git a/tests/rustdoc/cross-crate-info/index-on-last/e.rs b/tests/rustdoc-html/cross-crate-info/index-on-last/e.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/index-on-last/e.rs
rename to tests/rustdoc-html/cross-crate-info/index-on-last/e.rs
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/q.rs b/tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/q.rs
rename to tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/q.rs
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/r.rs b/tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/r.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/r.rs
rename to tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/r.rs
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/s.rs b/tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/s.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/s.rs
rename to tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/s.rs
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/t.rs b/tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/t.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/t.rs
rename to tests/rustdoc-html/cross-crate-info/kitchen-sink/auxiliary/t.rs
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/i.rs b/tests/rustdoc-html/cross-crate-info/kitchen-sink/i.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/kitchen-sink/i.rs
rename to tests/rustdoc-html/cross-crate-info/kitchen-sink/i.rs
diff --git a/tests/rustdoc/cross-crate-info/single-crate-baseline/q.rs b/tests/rustdoc-html/cross-crate-info/single-crate-baseline/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/single-crate-baseline/q.rs
rename to tests/rustdoc-html/cross-crate-info/single-crate-baseline/q.rs
diff --git a/tests/rustdoc/cross-crate-info/single-crate-no-index/q.rs b/tests/rustdoc-html/cross-crate-info/single-crate-no-index/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/single-crate-no-index/q.rs
rename to tests/rustdoc-html/cross-crate-info/single-crate-no-index/q.rs
diff --git a/tests/rustdoc/cross-crate-info/transitive/auxiliary/q.rs b/tests/rustdoc-html/cross-crate-info/transitive/auxiliary/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/transitive/auxiliary/q.rs
rename to tests/rustdoc-html/cross-crate-info/transitive/auxiliary/q.rs
diff --git a/tests/rustdoc/cross-crate-info/transitive/auxiliary/t.rs b/tests/rustdoc-html/cross-crate-info/transitive/auxiliary/t.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/transitive/auxiliary/t.rs
rename to tests/rustdoc-html/cross-crate-info/transitive/auxiliary/t.rs
diff --git a/tests/rustdoc/cross-crate-info/transitive/s.rs b/tests/rustdoc-html/cross-crate-info/transitive/s.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/transitive/s.rs
rename to tests/rustdoc-html/cross-crate-info/transitive/s.rs
diff --git a/tests/rustdoc/cross-crate-info/two/auxiliary/f.rs b/tests/rustdoc-html/cross-crate-info/two/auxiliary/f.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/two/auxiliary/f.rs
rename to tests/rustdoc-html/cross-crate-info/two/auxiliary/f.rs
diff --git a/tests/rustdoc/cross-crate-info/two/e.rs b/tests/rustdoc-html/cross-crate-info/two/e.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/two/e.rs
rename to tests/rustdoc-html/cross-crate-info/two/e.rs
diff --git a/tests/rustdoc/cross-crate-info/working-dir-examples/q.rs b/tests/rustdoc-html/cross-crate-info/working-dir-examples/q.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/working-dir-examples/q.rs
rename to tests/rustdoc-html/cross-crate-info/working-dir-examples/q.rs
diff --git a/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs b/tests/rustdoc-html/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs
rename to tests/rustdoc-html/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs
diff --git a/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/e.rs b/tests/rustdoc-html/cross-crate-info/write-docs-somewhere-else/e.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-info/write-docs-somewhere-else/e.rs
rename to tests/rustdoc-html/cross-crate-info/write-docs-somewhere-else/e.rs
diff --git a/tests/rustdoc/cross-crate-links.rs b/tests/rustdoc-html/cross-crate-links.rs
similarity index 100%
rename from tests/rustdoc/cross-crate-links.rs
rename to tests/rustdoc-html/cross-crate-links.rs
diff --git a/tests/rustdoc/custom_code_classes.rs b/tests/rustdoc-html/custom_code_classes.rs
similarity index 100%
rename from tests/rustdoc/custom_code_classes.rs
rename to tests/rustdoc-html/custom_code_classes.rs
diff --git a/tests/rustdoc/decl-line-wrapping-empty-arg-list.decl.html b/tests/rustdoc-html/decl-line-wrapping-empty-arg-list.decl.html
similarity index 100%
rename from tests/rustdoc/decl-line-wrapping-empty-arg-list.decl.html
rename to tests/rustdoc-html/decl-line-wrapping-empty-arg-list.decl.html
diff --git a/tests/rustdoc/decl-line-wrapping-empty-arg-list.rs b/tests/rustdoc-html/decl-line-wrapping-empty-arg-list.rs
similarity index 100%
rename from tests/rustdoc/decl-line-wrapping-empty-arg-list.rs
rename to tests/rustdoc-html/decl-line-wrapping-empty-arg-list.rs
diff --git a/tests/rustdoc/decl-trailing-whitespace.declaration.html b/tests/rustdoc-html/decl-trailing-whitespace.declaration.html
similarity index 100%
rename from tests/rustdoc/decl-trailing-whitespace.declaration.html
rename to tests/rustdoc-html/decl-trailing-whitespace.declaration.html
diff --git a/tests/rustdoc/decl-trailing-whitespace.rs b/tests/rustdoc-html/decl-trailing-whitespace.rs
similarity index 100%
rename from tests/rustdoc/decl-trailing-whitespace.rs
rename to tests/rustdoc-html/decl-trailing-whitespace.rs
diff --git a/tests/rustdoc/deep-structures.rs b/tests/rustdoc-html/deep-structures.rs
similarity index 100%
rename from tests/rustdoc/deep-structures.rs
rename to tests/rustdoc-html/deep-structures.rs
diff --git a/tests/rustdoc/default-theme.rs b/tests/rustdoc-html/default-theme.rs
similarity index 100%
rename from tests/rustdoc/default-theme.rs
rename to tests/rustdoc-html/default-theme.rs
diff --git a/tests/rustdoc/default-trait-method-link.rs b/tests/rustdoc-html/default-trait-method-link.rs
similarity index 100%
rename from tests/rustdoc/default-trait-method-link.rs
rename to tests/rustdoc-html/default-trait-method-link.rs
diff --git a/tests/rustdoc/default-trait-method.rs b/tests/rustdoc-html/default-trait-method.rs
similarity index 100%
rename from tests/rustdoc/default-trait-method.rs
rename to tests/rustdoc-html/default-trait-method.rs
diff --git a/tests/rustdoc/demo-allocator-54478.rs b/tests/rustdoc-html/demo-allocator-54478.rs
similarity index 100%
rename from tests/rustdoc/demo-allocator-54478.rs
rename to tests/rustdoc-html/demo-allocator-54478.rs
diff --git a/tests/rustdoc/deprecated-future-staged-api.rs b/tests/rustdoc-html/deprecated-future-staged-api.rs
similarity index 100%
rename from tests/rustdoc/deprecated-future-staged-api.rs
rename to tests/rustdoc-html/deprecated-future-staged-api.rs
diff --git a/tests/rustdoc/deprecated-future.rs b/tests/rustdoc-html/deprecated-future.rs
similarity index 100%
rename from tests/rustdoc/deprecated-future.rs
rename to tests/rustdoc-html/deprecated-future.rs
diff --git a/tests/rustdoc/deprecated.rs b/tests/rustdoc-html/deprecated.rs
similarity index 100%
rename from tests/rustdoc/deprecated.rs
rename to tests/rustdoc-html/deprecated.rs
diff --git a/tests/rustdoc/deref-methods-19190-foreign-type.rs b/tests/rustdoc-html/deref-methods-19190-foreign-type.rs
similarity index 100%
rename from tests/rustdoc/deref-methods-19190-foreign-type.rs
rename to tests/rustdoc-html/deref-methods-19190-foreign-type.rs
diff --git a/tests/rustdoc/deref-methods-19190-inline.rs b/tests/rustdoc-html/deref-methods-19190-inline.rs
similarity index 100%
rename from tests/rustdoc/deref-methods-19190-inline.rs
rename to tests/rustdoc-html/deref-methods-19190-inline.rs
diff --git a/tests/rustdoc/deref-methods-19190.rs b/tests/rustdoc-html/deref-methods-19190.rs
similarity index 100%
rename from tests/rustdoc/deref-methods-19190.rs
rename to tests/rustdoc-html/deref-methods-19190.rs
diff --git a/tests/rustdoc/deref-mut-35169-2.rs b/tests/rustdoc-html/deref-mut-35169-2.rs
similarity index 100%
rename from tests/rustdoc/deref-mut-35169-2.rs
rename to tests/rustdoc-html/deref-mut-35169-2.rs
diff --git a/tests/rustdoc/deref-mut-35169.rs b/tests/rustdoc-html/deref-mut-35169.rs
similarity index 100%
rename from tests/rustdoc/deref-mut-35169.rs
rename to tests/rustdoc-html/deref-mut-35169.rs
diff --git a/tests/rustdoc/deref/deref-const-fn.rs b/tests/rustdoc-html/deref/deref-const-fn.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-const-fn.rs
rename to tests/rustdoc-html/deref/deref-const-fn.rs
diff --git a/tests/rustdoc/deref/deref-methods-24686-target.rs b/tests/rustdoc-html/deref/deref-methods-24686-target.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-methods-24686-target.rs
rename to tests/rustdoc-html/deref/deref-methods-24686-target.rs
diff --git a/tests/rustdoc/deref/deref-multiple-impl-blocks.rs b/tests/rustdoc-html/deref/deref-multiple-impl-blocks.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-multiple-impl-blocks.rs
rename to tests/rustdoc-html/deref/deref-multiple-impl-blocks.rs
diff --git a/tests/rustdoc/deref/deref-mut-methods.rs b/tests/rustdoc-html/deref/deref-mut-methods.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-mut-methods.rs
rename to tests/rustdoc-html/deref/deref-mut-methods.rs
diff --git a/tests/rustdoc/deref/deref-recursive-pathbuf.rs b/tests/rustdoc-html/deref/deref-recursive-pathbuf.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-recursive-pathbuf.rs
rename to tests/rustdoc-html/deref/deref-recursive-pathbuf.rs
diff --git a/tests/rustdoc/deref/deref-recursive.rs b/tests/rustdoc-html/deref/deref-recursive.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-recursive.rs
rename to tests/rustdoc-html/deref/deref-recursive.rs
diff --git a/tests/rustdoc/deref/deref-slice-core.rs b/tests/rustdoc-html/deref/deref-slice-core.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-slice-core.rs
rename to tests/rustdoc-html/deref/deref-slice-core.rs
diff --git a/tests/rustdoc/deref/deref-to-primitive.rs b/tests/rustdoc-html/deref/deref-to-primitive.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-to-primitive.rs
rename to tests/rustdoc-html/deref/deref-to-primitive.rs
diff --git a/tests/rustdoc/deref/deref-typedef.rs b/tests/rustdoc-html/deref/deref-typedef.rs
similarity index 100%
rename from tests/rustdoc/deref/deref-typedef.rs
rename to tests/rustdoc-html/deref/deref-typedef.rs
diff --git a/tests/rustdoc/deref/escape-deref-methods.rs b/tests/rustdoc-html/deref/escape-deref-methods.rs
similarity index 100%
rename from tests/rustdoc/deref/escape-deref-methods.rs
rename to tests/rustdoc-html/deref/escape-deref-methods.rs
diff --git a/tests/rustdoc/deref/recursive-deref-sidebar.rs b/tests/rustdoc-html/deref/recursive-deref-sidebar.rs
similarity index 100%
rename from tests/rustdoc/deref/recursive-deref-sidebar.rs
rename to tests/rustdoc-html/deref/recursive-deref-sidebar.rs
diff --git a/tests/rustdoc/deref/recursive-deref.rs b/tests/rustdoc-html/deref/recursive-deref.rs
similarity index 100%
rename from tests/rustdoc/deref/recursive-deref.rs
rename to tests/rustdoc-html/deref/recursive-deref.rs
diff --git a/tests/rustdoc/deref/sidebar-links-deref-100679.rs b/tests/rustdoc-html/deref/sidebar-links-deref-100679.rs
similarity index 100%
rename from tests/rustdoc/deref/sidebar-links-deref-100679.rs
rename to tests/rustdoc-html/deref/sidebar-links-deref-100679.rs
diff --git a/tests/rustdoc/description.rs b/tests/rustdoc-html/description.rs
similarity index 100%
rename from tests/rustdoc/description.rs
rename to tests/rustdoc-html/description.rs
diff --git a/tests/rustdoc/description_default.rs b/tests/rustdoc-html/description_default.rs
similarity index 100%
rename from tests/rustdoc/description_default.rs
rename to tests/rustdoc-html/description_default.rs
diff --git a/tests/rustdoc/display-hidden-items.rs b/tests/rustdoc-html/display-hidden-items.rs
similarity index 100%
rename from tests/rustdoc/display-hidden-items.rs
rename to tests/rustdoc-html/display-hidden-items.rs
diff --git a/tests/rustdoc/doc-attr-comment-mix-42760.rs b/tests/rustdoc-html/doc-attr-comment-mix-42760.rs
similarity index 100%
rename from tests/rustdoc/doc-attr-comment-mix-42760.rs
rename to tests/rustdoc-html/doc-attr-comment-mix-42760.rs
diff --git a/tests/rustdoc/doc-attribute.rs b/tests/rustdoc-html/doc-attribute.rs
similarity index 100%
rename from tests/rustdoc/doc-attribute.rs
rename to tests/rustdoc-html/doc-attribute.rs
diff --git a/tests/rustdoc/doc-auto-cfg-public-in-private.rs b/tests/rustdoc-html/doc-auto-cfg-public-in-private.rs
similarity index 100%
rename from tests/rustdoc/doc-auto-cfg-public-in-private.rs
rename to tests/rustdoc-html/doc-auto-cfg-public-in-private.rs
diff --git a/tests/rustdoc/doc-auto-cfg.rs b/tests/rustdoc-html/doc-auto-cfg.rs
similarity index 100%
rename from tests/rustdoc/doc-auto-cfg.rs
rename to tests/rustdoc-html/doc-auto-cfg.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-hide.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-hide.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-hide.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-hide.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-implicit-gate.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-implicit-gate.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-implicit.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-implicit.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-implicit.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-implicit.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-inherit-from-module-79201.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-inherit-from-module-79201.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-inherit-from-module-79201.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-inherit-from-module-79201.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-simplification.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-simplification.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-simplification.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-simplification.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-target-feature.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-target-feature.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-target-feature.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-target-feature.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-traits.rs b/tests/rustdoc-html/doc-cfg/doc-cfg-traits.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg-traits.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg-traits.rs
diff --git a/tests/rustdoc/doc-cfg/doc-cfg.rs b/tests/rustdoc-html/doc-cfg/doc-cfg.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/doc-cfg.rs
rename to tests/rustdoc-html/doc-cfg/doc-cfg.rs
diff --git a/tests/rustdoc/doc-cfg/duplicate-cfg.rs b/tests/rustdoc-html/doc-cfg/duplicate-cfg.rs
similarity index 100%
rename from tests/rustdoc/doc-cfg/duplicate-cfg.rs
rename to tests/rustdoc-html/doc-cfg/duplicate-cfg.rs
diff --git a/tests/rustdoc/doc-hidden-crate.rs b/tests/rustdoc-html/doc-hidden-crate.rs
similarity index 100%
rename from tests/rustdoc/doc-hidden-crate.rs
rename to tests/rustdoc-html/doc-hidden-crate.rs
diff --git a/tests/rustdoc/doc-hidden-method-13698.rs b/tests/rustdoc-html/doc-hidden-method-13698.rs
similarity index 100%
rename from tests/rustdoc/doc-hidden-method-13698.rs
rename to tests/rustdoc-html/doc-hidden-method-13698.rs
diff --git a/tests/rustdoc/doc-on-keyword.rs b/tests/rustdoc-html/doc-on-keyword.rs
similarity index 100%
rename from tests/rustdoc/doc-on-keyword.rs
rename to tests/rustdoc-html/doc-on-keyword.rs
diff --git a/tests/rustdoc/doc-test-attr-18199.rs b/tests/rustdoc-html/doc-test-attr-18199.rs
similarity index 100%
rename from tests/rustdoc/doc-test-attr-18199.rs
rename to tests/rustdoc-html/doc-test-attr-18199.rs
diff --git a/tests/rustdoc/doc_auto_cfg.rs b/tests/rustdoc-html/doc_auto_cfg.rs
similarity index 100%
rename from tests/rustdoc/doc_auto_cfg.rs
rename to tests/rustdoc-html/doc_auto_cfg.rs
diff --git a/tests/rustdoc/doc_auto_cfg_reexports.rs b/tests/rustdoc-html/doc_auto_cfg_reexports.rs
similarity index 100%
rename from tests/rustdoc/doc_auto_cfg_reexports.rs
rename to tests/rustdoc-html/doc_auto_cfg_reexports.rs
diff --git a/tests/rustdoc/doctest/auxiliary/doctest-runtool.rs b/tests/rustdoc-html/doctest/auxiliary/doctest-runtool.rs
similarity index 100%
rename from tests/rustdoc/doctest/auxiliary/doctest-runtool.rs
rename to tests/rustdoc-html/doctest/auxiliary/doctest-runtool.rs
diff --git a/tests/rustdoc/doctest/auxiliary/empty.rs b/tests/rustdoc-html/doctest/auxiliary/empty.rs
similarity index 100%
rename from tests/rustdoc/doctest/auxiliary/empty.rs
rename to tests/rustdoc-html/doctest/auxiliary/empty.rs
diff --git a/tests/rustdoc/doctest/doctest-cfg-feature-30252.rs b/tests/rustdoc-html/doctest/doctest-cfg-feature-30252.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-cfg-feature-30252.rs
rename to tests/rustdoc-html/doctest/doctest-cfg-feature-30252.rs
diff --git a/tests/rustdoc/doctest/doctest-crate-attributes-38129.rs b/tests/rustdoc-html/doctest/doctest-crate-attributes-38129.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-crate-attributes-38129.rs
rename to tests/rustdoc-html/doctest/doctest-crate-attributes-38129.rs
diff --git a/tests/rustdoc/doctest/doctest-escape-boring-41783.codeblock.html b/tests/rustdoc-html/doctest/doctest-escape-boring-41783.codeblock.html
similarity index 100%
rename from tests/rustdoc/doctest/doctest-escape-boring-41783.codeblock.html
rename to tests/rustdoc-html/doctest/doctest-escape-boring-41783.codeblock.html
diff --git a/tests/rustdoc/doctest/doctest-escape-boring-41783.rs b/tests/rustdoc-html/doctest/doctest-escape-boring-41783.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-escape-boring-41783.rs
rename to tests/rustdoc-html/doctest/doctest-escape-boring-41783.rs
diff --git a/tests/rustdoc/doctest/doctest-hide-empty-line-23106.rs b/tests/rustdoc-html/doctest/doctest-hide-empty-line-23106.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-hide-empty-line-23106.rs
rename to tests/rustdoc-html/doctest/doctest-hide-empty-line-23106.rs
diff --git a/tests/rustdoc/doctest/doctest-ignore-32556.rs b/tests/rustdoc-html/doctest/doctest-ignore-32556.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-ignore-32556.rs
rename to tests/rustdoc-html/doctest/doctest-ignore-32556.rs
diff --git a/tests/rustdoc/doctest/doctest-include-43153.rs b/tests/rustdoc-html/doctest/doctest-include-43153.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-include-43153.rs
rename to tests/rustdoc-html/doctest/doctest-include-43153.rs
diff --git a/tests/rustdoc/doctest/doctest-macro-38219.rs b/tests/rustdoc-html/doctest/doctest-macro-38219.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-macro-38219.rs
rename to tests/rustdoc-html/doctest/doctest-macro-38219.rs
diff --git a/tests/rustdoc/doctest/doctest-manual-crate-name.rs b/tests/rustdoc-html/doctest/doctest-manual-crate-name.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-manual-crate-name.rs
rename to tests/rustdoc-html/doctest/doctest-manual-crate-name.rs
diff --git a/tests/rustdoc/doctest/doctest-markdown-inline-parse-23744.rs b/tests/rustdoc-html/doctest/doctest-markdown-inline-parse-23744.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-markdown-inline-parse-23744.rs
rename to tests/rustdoc-html/doctest/doctest-markdown-inline-parse-23744.rs
diff --git a/tests/rustdoc/doctest/doctest-markdown-trailing-docblock-48377.rs b/tests/rustdoc-html/doctest/doctest-markdown-trailing-docblock-48377.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-markdown-trailing-docblock-48377.rs
rename to tests/rustdoc-html/doctest/doctest-markdown-trailing-docblock-48377.rs
diff --git a/tests/rustdoc/doctest/doctest-multi-line-string-literal-25944.rs b/tests/rustdoc-html/doctest/doctest-multi-line-string-literal-25944.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-multi-line-string-literal-25944.rs
rename to tests/rustdoc-html/doctest/doctest-multi-line-string-literal-25944.rs
diff --git a/tests/rustdoc/doctest/doctest-runtool.rs b/tests/rustdoc-html/doctest/doctest-runtool.rs
similarity index 100%
rename from tests/rustdoc/doctest/doctest-runtool.rs
rename to tests/rustdoc-html/doctest/doctest-runtool.rs
diff --git a/tests/rustdoc/doctest/ignore-sometimes.rs b/tests/rustdoc-html/doctest/ignore-sometimes.rs
similarity index 100%
rename from tests/rustdoc/doctest/ignore-sometimes.rs
rename to tests/rustdoc-html/doctest/ignore-sometimes.rs
diff --git a/tests/rustdoc/document-hidden-items-15347.rs b/tests/rustdoc-html/document-hidden-items-15347.rs
similarity index 100%
rename from tests/rustdoc/document-hidden-items-15347.rs
rename to tests/rustdoc-html/document-hidden-items-15347.rs
diff --git a/tests/rustdoc/double-hyphen-to-dash.rs b/tests/rustdoc-html/double-hyphen-to-dash.rs
similarity index 100%
rename from tests/rustdoc/double-hyphen-to-dash.rs
rename to tests/rustdoc-html/double-hyphen-to-dash.rs
diff --git a/tests/rustdoc/double-quote-escape.rs b/tests/rustdoc-html/double-quote-escape.rs
similarity index 100%
rename from tests/rustdoc/double-quote-escape.rs
rename to tests/rustdoc-html/double-quote-escape.rs
diff --git a/tests/rustdoc/duplicate-flags.rs b/tests/rustdoc-html/duplicate-flags.rs
similarity index 100%
rename from tests/rustdoc/duplicate-flags.rs
rename to tests/rustdoc-html/duplicate-flags.rs
diff --git a/tests/rustdoc/duplicate_impls/impls.rs b/tests/rustdoc-html/duplicate_impls/impls.rs
similarity index 100%
rename from tests/rustdoc/duplicate_impls/impls.rs
rename to tests/rustdoc-html/duplicate_impls/impls.rs
diff --git a/tests/rustdoc/duplicate_impls/sidebar-links-duplicate-impls-33054.rs b/tests/rustdoc-html/duplicate_impls/sidebar-links-duplicate-impls-33054.rs
similarity index 100%
rename from tests/rustdoc/duplicate_impls/sidebar-links-duplicate-impls-33054.rs
rename to tests/rustdoc-html/duplicate_impls/sidebar-links-duplicate-impls-33054.rs
diff --git a/tests/rustdoc/dyn-compatibility.rs b/tests/rustdoc-html/dyn-compatibility.rs
similarity index 100%
rename from tests/rustdoc/dyn-compatibility.rs
rename to tests/rustdoc-html/dyn-compatibility.rs
diff --git a/tests/rustdoc/early-unindent.rs b/tests/rustdoc-html/early-unindent.rs
similarity index 100%
rename from tests/rustdoc/early-unindent.rs
rename to tests/rustdoc-html/early-unindent.rs
diff --git a/tests/rustdoc/edition-doctest.rs b/tests/rustdoc-html/edition-doctest.rs
similarity index 100%
rename from tests/rustdoc/edition-doctest.rs
rename to tests/rustdoc-html/edition-doctest.rs
diff --git a/tests/rustdoc/edition-flag.rs b/tests/rustdoc-html/edition-flag.rs
similarity index 100%
rename from tests/rustdoc/edition-flag.rs
rename to tests/rustdoc-html/edition-flag.rs
diff --git a/tests/rustdoc/elided-lifetime.rs b/tests/rustdoc-html/elided-lifetime.rs
similarity index 100%
rename from tests/rustdoc/elided-lifetime.rs
rename to tests/rustdoc-html/elided-lifetime.rs
diff --git a/tests/rustdoc/empty-doc-comment.rs b/tests/rustdoc-html/empty-doc-comment.rs
similarity index 100%
rename from tests/rustdoc/empty-doc-comment.rs
rename to tests/rustdoc-html/empty-doc-comment.rs
diff --git a/tests/rustdoc/empty-mod-public.rs b/tests/rustdoc-html/empty-mod-public.rs
similarity index 100%
rename from tests/rustdoc/empty-mod-public.rs
rename to tests/rustdoc-html/empty-mod-public.rs
diff --git a/tests/rustdoc/empty-section.rs b/tests/rustdoc-html/empty-section.rs
similarity index 100%
rename from tests/rustdoc/empty-section.rs
rename to tests/rustdoc-html/empty-section.rs
diff --git a/tests/rustdoc/empty-tuple-struct-118180.rs b/tests/rustdoc-html/empty-tuple-struct-118180.rs
similarity index 100%
rename from tests/rustdoc/empty-tuple-struct-118180.rs
rename to tests/rustdoc-html/empty-tuple-struct-118180.rs
diff --git a/tests/rustdoc/ensure-src-link.rs b/tests/rustdoc-html/ensure-src-link.rs
similarity index 100%
rename from tests/rustdoc/ensure-src-link.rs
rename to tests/rustdoc-html/ensure-src-link.rs
diff --git a/tests/rustdoc/enum/auxiliary/enum-variant.rs b/tests/rustdoc-html/enum/auxiliary/enum-variant.rs
similarity index 100%
rename from tests/rustdoc/enum/auxiliary/enum-variant.rs
rename to tests/rustdoc-html/enum/auxiliary/enum-variant.rs
diff --git a/tests/rustdoc/enum/auxiliary/variant-struct.rs b/tests/rustdoc-html/enum/auxiliary/variant-struct.rs
similarity index 100%
rename from tests/rustdoc/enum/auxiliary/variant-struct.rs
rename to tests/rustdoc-html/enum/auxiliary/variant-struct.rs
diff --git a/tests/rustdoc/enum/enum-headings.rs b/tests/rustdoc-html/enum/enum-headings.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-headings.rs
rename to tests/rustdoc-html/enum/enum-headings.rs
diff --git a/tests/rustdoc/enum/enum-non-exhaustive-108925.rs b/tests/rustdoc-html/enum/enum-non-exhaustive-108925.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-non-exhaustive-108925.rs
rename to tests/rustdoc-html/enum/enum-non-exhaustive-108925.rs
diff --git a/tests/rustdoc/enum/enum-variant-doc-hidden-field-88600.rs b/tests/rustdoc-html/enum/enum-variant-doc-hidden-field-88600.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-doc-hidden-field-88600.rs
rename to tests/rustdoc-html/enum/enum-variant-doc-hidden-field-88600.rs
diff --git a/tests/rustdoc/enum/enum-variant-fields-heading.rs b/tests/rustdoc-html/enum/enum-variant-fields-heading.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-fields-heading.rs
rename to tests/rustdoc-html/enum/enum-variant-fields-heading.rs
diff --git a/tests/rustdoc/enum/enum-variant-fields-heading.variants.html b/tests/rustdoc-html/enum/enum-variant-fields-heading.variants.html
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-fields-heading.variants.html
rename to tests/rustdoc-html/enum/enum-variant-fields-heading.variants.html
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.rs b/tests/rustdoc-html/enum/enum-variant-non_exhaustive.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-non_exhaustive.rs
rename to tests/rustdoc-html/enum/enum-variant-non_exhaustive.rs
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.type-alias-code.html b/tests/rustdoc-html/enum/enum-variant-non_exhaustive.type-alias-code.html
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-non_exhaustive.type-alias-code.html
rename to tests/rustdoc-html/enum/enum-variant-non_exhaustive.type-alias-code.html
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.type-code.html b/tests/rustdoc-html/enum/enum-variant-non_exhaustive.type-code.html
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-non_exhaustive.type-code.html
rename to tests/rustdoc-html/enum/enum-variant-non_exhaustive.type-code.html
diff --git a/tests/rustdoc/enum/enum-variant-value.rs b/tests/rustdoc-html/enum/enum-variant-value.rs
similarity index 100%
rename from tests/rustdoc/enum/enum-variant-value.rs
rename to tests/rustdoc-html/enum/enum-variant-value.rs
diff --git a/tests/rustdoc/enum/render-enum-variant-structlike-32395.rs b/tests/rustdoc-html/enum/render-enum-variant-structlike-32395.rs
similarity index 100%
rename from tests/rustdoc/enum/render-enum-variant-structlike-32395.rs
rename to tests/rustdoc-html/enum/render-enum-variant-structlike-32395.rs
diff --git a/tests/rustdoc/enum/strip-enum-variant.no-not-shown.html b/tests/rustdoc-html/enum/strip-enum-variant.no-not-shown.html
similarity index 100%
rename from tests/rustdoc/enum/strip-enum-variant.no-not-shown.html
rename to tests/rustdoc-html/enum/strip-enum-variant.no-not-shown.html
diff --git a/tests/rustdoc/enum/strip-enum-variant.rs b/tests/rustdoc-html/enum/strip-enum-variant.rs
similarity index 100%
rename from tests/rustdoc/enum/strip-enum-variant.rs
rename to tests/rustdoc-html/enum/strip-enum-variant.rs
diff --git a/tests/rustdoc/extern/auxiliary/empty.rs b/tests/rustdoc-html/extern/auxiliary/empty.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/empty.rs
rename to tests/rustdoc-html/extern/auxiliary/empty.rs
diff --git a/tests/rustdoc/extern/auxiliary/extern-links.rs b/tests/rustdoc-html/extern/auxiliary/extern-links.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/extern-links.rs
rename to tests/rustdoc-html/extern/auxiliary/extern-links.rs
diff --git a/tests/rustdoc/extern/auxiliary/external-cross-doc.md b/tests/rustdoc-html/extern/auxiliary/external-cross-doc.md
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/external-cross-doc.md
rename to tests/rustdoc-html/extern/auxiliary/external-cross-doc.md
diff --git a/tests/rustdoc/extern/auxiliary/external-cross.rs b/tests/rustdoc-html/extern/auxiliary/external-cross.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/external-cross.rs
rename to tests/rustdoc-html/extern/auxiliary/external-cross.rs
diff --git a/tests/rustdoc/extern/auxiliary/external-doc.md b/tests/rustdoc-html/extern/auxiliary/external-doc.md
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/external-doc.md
rename to tests/rustdoc-html/extern/auxiliary/external-doc.md
diff --git a/tests/rustdoc/extern/auxiliary/html_root.rs b/tests/rustdoc-html/extern/auxiliary/html_root.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/html_root.rs
rename to tests/rustdoc-html/extern/auxiliary/html_root.rs
diff --git a/tests/rustdoc/extern/auxiliary/issue-30109-1.rs b/tests/rustdoc-html/extern/auxiliary/issue-30109-1.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/issue-30109-1.rs
rename to tests/rustdoc-html/extern/auxiliary/issue-30109-1.rs
diff --git a/tests/rustdoc/extern/auxiliary/no_html_root.rs b/tests/rustdoc-html/extern/auxiliary/no_html_root.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/no_html_root.rs
rename to tests/rustdoc-html/extern/auxiliary/no_html_root.rs
diff --git a/tests/rustdoc/extern/auxiliary/panic-item.rs b/tests/rustdoc-html/extern/auxiliary/panic-item.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/panic-item.rs
rename to tests/rustdoc-html/extern/auxiliary/panic-item.rs
diff --git a/tests/rustdoc/extern/auxiliary/pub-extern-crate.rs b/tests/rustdoc-html/extern/auxiliary/pub-extern-crate.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/pub-extern-crate.rs
rename to tests/rustdoc-html/extern/auxiliary/pub-extern-crate.rs
diff --git a/tests/rustdoc/extern/auxiliary/rustdoc-extern-default-method.rs b/tests/rustdoc-html/extern/auxiliary/rustdoc-extern-default-method.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/rustdoc-extern-default-method.rs
rename to tests/rustdoc-html/extern/auxiliary/rustdoc-extern-default-method.rs
diff --git a/tests/rustdoc/extern/auxiliary/rustdoc-extern-method.rs b/tests/rustdoc-html/extern/auxiliary/rustdoc-extern-method.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/rustdoc-extern-method.rs
rename to tests/rustdoc-html/extern/auxiliary/rustdoc-extern-method.rs
diff --git a/tests/rustdoc/extern/auxiliary/variant-struct.rs b/tests/rustdoc-html/extern/auxiliary/variant-struct.rs
similarity index 100%
rename from tests/rustdoc/extern/auxiliary/variant-struct.rs
rename to tests/rustdoc-html/extern/auxiliary/variant-struct.rs
diff --git a/tests/rustdoc/extern/duplicate-reexports-section-150211.rs b/tests/rustdoc-html/extern/duplicate-reexports-section-150211.rs
similarity index 100%
rename from tests/rustdoc/extern/duplicate-reexports-section-150211.rs
rename to tests/rustdoc-html/extern/duplicate-reexports-section-150211.rs
diff --git a/tests/rustdoc/extern/extern-default-method.no_href_on_anchor.html b/tests/rustdoc-html/extern/extern-default-method.no_href_on_anchor.html
similarity index 100%
rename from tests/rustdoc/extern/extern-default-method.no_href_on_anchor.html
rename to tests/rustdoc-html/extern/extern-default-method.no_href_on_anchor.html
diff --git a/tests/rustdoc/extern/extern-default-method.rs b/tests/rustdoc-html/extern/extern-default-method.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-default-method.rs
rename to tests/rustdoc-html/extern/extern-default-method.rs
diff --git a/tests/rustdoc/extern/extern-fn-22038.rs b/tests/rustdoc-html/extern/extern-fn-22038.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-fn-22038.rs
rename to tests/rustdoc-html/extern/extern-fn-22038.rs
diff --git a/tests/rustdoc/extern/extern-html-alias.rs b/tests/rustdoc-html/extern/extern-html-alias.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-html-alias.rs
rename to tests/rustdoc-html/extern/extern-html-alias.rs
diff --git a/tests/rustdoc/extern/extern-html-fallback.rs b/tests/rustdoc-html/extern/extern-html-fallback.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-html-fallback.rs
rename to tests/rustdoc-html/extern/extern-html-fallback.rs
diff --git a/tests/rustdoc/extern/extern-html-root-url-precedence.rs b/tests/rustdoc-html/extern/extern-html-root-url-precedence.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-html-root-url-precedence.rs
rename to tests/rustdoc-html/extern/extern-html-root-url-precedence.rs
diff --git a/tests/rustdoc/extern/extern-html-root-url.rs b/tests/rustdoc-html/extern/extern-html-root-url.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-html-root-url.rs
rename to tests/rustdoc-html/extern/extern-html-root-url.rs
diff --git a/tests/rustdoc/extern/extern-links.rs b/tests/rustdoc-html/extern/extern-links.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-links.rs
rename to tests/rustdoc-html/extern/extern-links.rs
diff --git a/tests/rustdoc/extern/extern-method.rs b/tests/rustdoc-html/extern/extern-method.rs
similarity index 100%
rename from tests/rustdoc/extern/extern-method.rs
rename to tests/rustdoc-html/extern/extern-method.rs
diff --git a/tests/rustdoc/extern/external-cross.rs b/tests/rustdoc-html/extern/external-cross.rs
similarity index 100%
rename from tests/rustdoc/extern/external-cross.rs
rename to tests/rustdoc-html/extern/external-cross.rs
diff --git a/tests/rustdoc/extern/external-doc.rs b/tests/rustdoc-html/extern/external-doc.rs
similarity index 100%
rename from tests/rustdoc/extern/external-doc.rs
rename to tests/rustdoc-html/extern/external-doc.rs
diff --git a/tests/rustdoc/extern/hidden-extern-34025.rs b/tests/rustdoc-html/extern/hidden-extern-34025.rs
similarity index 100%
rename from tests/rustdoc/extern/hidden-extern-34025.rs
rename to tests/rustdoc-html/extern/hidden-extern-34025.rs
diff --git a/tests/rustdoc/extern/link-extern-crate-33178.rs b/tests/rustdoc-html/extern/link-extern-crate-33178.rs
similarity index 100%
rename from tests/rustdoc/extern/link-extern-crate-33178.rs
rename to tests/rustdoc-html/extern/link-extern-crate-33178.rs
diff --git a/tests/rustdoc/extern/link-extern-crate-item-30109.rs b/tests/rustdoc-html/extern/link-extern-crate-item-30109.rs
similarity index 100%
rename from tests/rustdoc/extern/link-extern-crate-item-30109.rs
rename to tests/rustdoc-html/extern/link-extern-crate-item-30109.rs
diff --git a/tests/rustdoc/extern/link-extern-crate-title-33178.rs b/tests/rustdoc-html/extern/link-extern-crate-title-33178.rs
similarity index 100%
rename from tests/rustdoc/extern/link-extern-crate-title-33178.rs
rename to tests/rustdoc-html/extern/link-extern-crate-title-33178.rs
diff --git a/tests/rustdoc/extern/pub-extern-crate-150176.rs b/tests/rustdoc-html/extern/pub-extern-crate-150176.rs
similarity index 100%
rename from tests/rustdoc/extern/pub-extern-crate-150176.rs
rename to tests/rustdoc-html/extern/pub-extern-crate-150176.rs
diff --git a/tests/rustdoc/extern/pub-extern-crate.rs b/tests/rustdoc-html/extern/pub-extern-crate.rs
similarity index 100%
rename from tests/rustdoc/extern/pub-extern-crate.rs
rename to tests/rustdoc-html/extern/pub-extern-crate.rs
diff --git a/tests/rustdoc/extern/unsafe-extern-blocks.rs b/tests/rustdoc-html/extern/unsafe-extern-blocks.rs
similarity index 100%
rename from tests/rustdoc/extern/unsafe-extern-blocks.rs
rename to tests/rustdoc-html/extern/unsafe-extern-blocks.rs
diff --git a/tests/rustdoc/extern/unused-extern-crate.rs b/tests/rustdoc-html/extern/unused-extern-crate.rs
similarity index 100%
rename from tests/rustdoc/extern/unused-extern-crate.rs
rename to tests/rustdoc-html/extern/unused-extern-crate.rs
diff --git a/tests/rustdoc/extremely_long_typename.extremely_long_typename.html b/tests/rustdoc-html/extremely_long_typename.extremely_long_typename.html
similarity index 100%
rename from tests/rustdoc/extremely_long_typename.extremely_long_typename.html
rename to tests/rustdoc-html/extremely_long_typename.extremely_long_typename.html
diff --git a/tests/rustdoc/extremely_long_typename.rs b/tests/rustdoc-html/extremely_long_typename.rs
similarity index 100%
rename from tests/rustdoc/extremely_long_typename.rs
rename to tests/rustdoc-html/extremely_long_typename.rs
diff --git a/tests/rustdoc/feature-gate-doc_auto_cfg.rs b/tests/rustdoc-html/feature-gate-doc_auto_cfg.rs
similarity index 100%
rename from tests/rustdoc/feature-gate-doc_auto_cfg.rs
rename to tests/rustdoc-html/feature-gate-doc_auto_cfg.rs
diff --git a/tests/rustdoc/ffi.rs b/tests/rustdoc-html/ffi.rs
similarity index 100%
rename from tests/rustdoc/ffi.rs
rename to tests/rustdoc-html/ffi.rs
diff --git a/tests/rustdoc/file-creation-111249.rs b/tests/rustdoc-html/file-creation-111249.rs
similarity index 100%
rename from tests/rustdoc/file-creation-111249.rs
rename to tests/rustdoc-html/file-creation-111249.rs
diff --git a/tests/rustdoc/files-creation-hidden.rs b/tests/rustdoc-html/files-creation-hidden.rs
similarity index 100%
rename from tests/rustdoc/files-creation-hidden.rs
rename to tests/rustdoc-html/files-creation-hidden.rs
diff --git a/tests/rustdoc/fn-bound.rs b/tests/rustdoc-html/fn-bound.rs
similarity index 100%
rename from tests/rustdoc/fn-bound.rs
rename to tests/rustdoc-html/fn-bound.rs
diff --git a/tests/rustdoc/fn-pointer-arg-name.rs b/tests/rustdoc-html/fn-pointer-arg-name.rs
similarity index 100%
rename from tests/rustdoc/fn-pointer-arg-name.rs
rename to tests/rustdoc-html/fn-pointer-arg-name.rs
diff --git a/tests/rustdoc/fn-sidebar.rs b/tests/rustdoc-html/fn-sidebar.rs
similarity index 100%
rename from tests/rustdoc/fn-sidebar.rs
rename to tests/rustdoc-html/fn-sidebar.rs
diff --git a/tests/rustdoc/fn-type.rs b/tests/rustdoc-html/fn-type.rs
similarity index 100%
rename from tests/rustdoc/fn-type.rs
rename to tests/rustdoc-html/fn-type.rs
diff --git a/tests/rustdoc/footnote-definition-without-blank-line-100638.rs b/tests/rustdoc-html/footnote-definition-without-blank-line-100638.rs
similarity index 100%
rename from tests/rustdoc/footnote-definition-without-blank-line-100638.rs
rename to tests/rustdoc-html/footnote-definition-without-blank-line-100638.rs
diff --git a/tests/rustdoc/footnote-ids.rs b/tests/rustdoc-html/footnote-ids.rs
similarity index 100%
rename from tests/rustdoc/footnote-ids.rs
rename to tests/rustdoc-html/footnote-ids.rs
diff --git a/tests/rustdoc/footnote-in-summary.rs b/tests/rustdoc-html/footnote-in-summary.rs
similarity index 100%
rename from tests/rustdoc/footnote-in-summary.rs
rename to tests/rustdoc-html/footnote-in-summary.rs
diff --git a/tests/rustdoc/footnote-reference-ids.rs b/tests/rustdoc-html/footnote-reference-ids.rs
similarity index 100%
rename from tests/rustdoc/footnote-reference-ids.rs
rename to tests/rustdoc-html/footnote-reference-ids.rs
diff --git a/tests/rustdoc/footnote-reference-in-footnote-def.rs b/tests/rustdoc-html/footnote-reference-in-footnote-def.rs
similarity index 100%
rename from tests/rustdoc/footnote-reference-in-footnote-def.rs
rename to tests/rustdoc-html/footnote-reference-in-footnote-def.rs
diff --git a/tests/rustdoc/force-target-feature.rs b/tests/rustdoc-html/force-target-feature.rs
similarity index 100%
rename from tests/rustdoc/force-target-feature.rs
rename to tests/rustdoc-html/force-target-feature.rs
diff --git a/tests/rustdoc/force-unstable-if-unmarked-106421-not-internal.rs b/tests/rustdoc-html/force-unstable-if-unmarked-106421-not-internal.rs
similarity index 100%
rename from tests/rustdoc/force-unstable-if-unmarked-106421-not-internal.rs
rename to tests/rustdoc-html/force-unstable-if-unmarked-106421-not-internal.rs
diff --git a/tests/rustdoc/force-unstable-if-unmarked-106421.rs b/tests/rustdoc-html/force-unstable-if-unmarked-106421.rs
similarity index 100%
rename from tests/rustdoc/force-unstable-if-unmarked-106421.rs
rename to tests/rustdoc-html/force-unstable-if-unmarked-106421.rs
diff --git a/tests/rustdoc/foreigntype.rs b/tests/rustdoc-html/foreigntype.rs
similarity index 100%
rename from tests/rustdoc/foreigntype.rs
rename to tests/rustdoc-html/foreigntype.rs
diff --git a/tests/rustdoc/generic-associated-types/gat-elided-lifetime-94683.rs b/tests/rustdoc-html/generic-associated-types/gat-elided-lifetime-94683.rs
similarity index 100%
rename from tests/rustdoc/generic-associated-types/gat-elided-lifetime-94683.rs
rename to tests/rustdoc-html/generic-associated-types/gat-elided-lifetime-94683.rs
diff --git a/tests/rustdoc/generic-associated-types/gat-linkification-109488.rs b/tests/rustdoc-html/generic-associated-types/gat-linkification-109488.rs
similarity index 100%
rename from tests/rustdoc/generic-associated-types/gat-linkification-109488.rs
rename to tests/rustdoc-html/generic-associated-types/gat-linkification-109488.rs
diff --git a/tests/rustdoc/generic-associated-types/gats.rs b/tests/rustdoc-html/generic-associated-types/gats.rs
similarity index 100%
rename from tests/rustdoc/generic-associated-types/gats.rs
rename to tests/rustdoc-html/generic-associated-types/gats.rs
diff --git a/tests/rustdoc/glob-shadowing.rs b/tests/rustdoc-html/glob-shadowing.rs
similarity index 100%
rename from tests/rustdoc/glob-shadowing.rs
rename to tests/rustdoc-html/glob-shadowing.rs
diff --git a/tests/rustdoc/heading-levels-89309.rs b/tests/rustdoc-html/heading-levels-89309.rs
similarity index 100%
rename from tests/rustdoc/heading-levels-89309.rs
rename to tests/rustdoc-html/heading-levels-89309.rs
diff --git a/tests/rustdoc/heterogeneous-concat.rs b/tests/rustdoc-html/heterogeneous-concat.rs
similarity index 100%
rename from tests/rustdoc/heterogeneous-concat.rs
rename to tests/rustdoc-html/heterogeneous-concat.rs
diff --git a/tests/rustdoc/hidden-line.rs b/tests/rustdoc-html/hidden-line.rs
similarity index 100%
rename from tests/rustdoc/hidden-line.rs
rename to tests/rustdoc-html/hidden-line.rs
diff --git a/tests/rustdoc/hidden-methods.rs b/tests/rustdoc-html/hidden-methods.rs
similarity index 100%
rename from tests/rustdoc/hidden-methods.rs
rename to tests/rustdoc-html/hidden-methods.rs
diff --git a/tests/rustdoc/hidden-trait-methods-with-document-hidden-items.rs b/tests/rustdoc-html/hidden-trait-methods-with-document-hidden-items.rs
similarity index 100%
rename from tests/rustdoc/hidden-trait-methods-with-document-hidden-items.rs
rename to tests/rustdoc-html/hidden-trait-methods-with-document-hidden-items.rs
diff --git a/tests/rustdoc/hidden-trait-methods.rs b/tests/rustdoc-html/hidden-trait-methods.rs
similarity index 100%
rename from tests/rustdoc/hidden-trait-methods.rs
rename to tests/rustdoc-html/hidden-trait-methods.rs
diff --git a/tests/rustdoc/hide-unstable-trait.rs b/tests/rustdoc-html/hide-unstable-trait.rs
similarity index 100%
rename from tests/rustdoc/hide-unstable-trait.rs
rename to tests/rustdoc-html/hide-unstable-trait.rs
diff --git a/tests/rustdoc/higher-ranked-trait-bounds.rs b/tests/rustdoc-html/higher-ranked-trait-bounds.rs
similarity index 100%
rename from tests/rustdoc/higher-ranked-trait-bounds.rs
rename to tests/rustdoc-html/higher-ranked-trait-bounds.rs
diff --git a/tests/rustdoc/highlight-invalid-rust-12834.rs b/tests/rustdoc-html/highlight-invalid-rust-12834.rs
similarity index 100%
rename from tests/rustdoc/highlight-invalid-rust-12834.rs
rename to tests/rustdoc-html/highlight-invalid-rust-12834.rs
diff --git a/tests/rustdoc/ice-type-error-19181.rs b/tests/rustdoc-html/ice-type-error-19181.rs
similarity index 100%
rename from tests/rustdoc/ice-type-error-19181.rs
rename to tests/rustdoc-html/ice-type-error-19181.rs
diff --git a/tests/rustdoc/impl/auxiliary/cross-crate-hidden-impl-parameter.rs b/tests/rustdoc-html/impl/auxiliary/cross-crate-hidden-impl-parameter.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/cross-crate-hidden-impl-parameter.rs
rename to tests/rustdoc-html/impl/auxiliary/cross-crate-hidden-impl-parameter.rs
diff --git a/tests/rustdoc/impl/auxiliary/extern-impl-trait.rs b/tests/rustdoc-html/impl/auxiliary/extern-impl-trait.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/extern-impl-trait.rs
rename to tests/rustdoc-html/impl/auxiliary/extern-impl-trait.rs
diff --git a/tests/rustdoc/impl/auxiliary/incoherent-impl-types.rs b/tests/rustdoc-html/impl/auxiliary/incoherent-impl-types.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/incoherent-impl-types.rs
rename to tests/rustdoc-html/impl/auxiliary/incoherent-impl-types.rs
diff --git a/tests/rustdoc/impl/auxiliary/issue-100204-aux.rs b/tests/rustdoc-html/impl/auxiliary/issue-100204-aux.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/issue-100204-aux.rs
rename to tests/rustdoc-html/impl/auxiliary/issue-100204-aux.rs
diff --git a/tests/rustdoc/impl/auxiliary/issue-17476.rs b/tests/rustdoc-html/impl/auxiliary/issue-17476.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/issue-17476.rs
rename to tests/rustdoc-html/impl/auxiliary/issue-17476.rs
diff --git a/tests/rustdoc/impl/auxiliary/issue-21092.rs b/tests/rustdoc-html/impl/auxiliary/issue-21092.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/issue-21092.rs
rename to tests/rustdoc-html/impl/auxiliary/issue-21092.rs
diff --git a/tests/rustdoc/impl/auxiliary/issue-22025.rs b/tests/rustdoc-html/impl/auxiliary/issue-22025.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/issue-22025.rs
rename to tests/rustdoc-html/impl/auxiliary/issue-22025.rs
diff --git a/tests/rustdoc/impl/auxiliary/issue-53689.rs b/tests/rustdoc-html/impl/auxiliary/issue-53689.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/issue-53689.rs
rename to tests/rustdoc-html/impl/auxiliary/issue-53689.rs
diff --git a/tests/rustdoc/impl/auxiliary/precise-capturing.rs b/tests/rustdoc-html/impl/auxiliary/precise-capturing.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/precise-capturing.rs
rename to tests/rustdoc-html/impl/auxiliary/precise-capturing.rs
diff --git a/tests/rustdoc/impl/auxiliary/real_gimli.rs b/tests/rustdoc-html/impl/auxiliary/real_gimli.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/real_gimli.rs
rename to tests/rustdoc-html/impl/auxiliary/real_gimli.rs
diff --git a/tests/rustdoc/impl/auxiliary/realcore.rs b/tests/rustdoc-html/impl/auxiliary/realcore.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/realcore.rs
rename to tests/rustdoc-html/impl/auxiliary/realcore.rs
diff --git a/tests/rustdoc/impl/auxiliary/rustdoc-default-impl.rs b/tests/rustdoc-html/impl/auxiliary/rustdoc-default-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/rustdoc-default-impl.rs
rename to tests/rustdoc-html/impl/auxiliary/rustdoc-default-impl.rs
diff --git a/tests/rustdoc/impl/auxiliary/rustdoc-impl-parts-crosscrate.rs b/tests/rustdoc-html/impl/auxiliary/rustdoc-impl-parts-crosscrate.rs
similarity index 100%
rename from tests/rustdoc/impl/auxiliary/rustdoc-impl-parts-crosscrate.rs
rename to tests/rustdoc-html/impl/auxiliary/rustdoc-impl-parts-crosscrate.rs
diff --git a/tests/rustdoc/impl/blanket-impl-29503.rs b/tests/rustdoc-html/impl/blanket-impl-29503.rs
similarity index 100%
rename from tests/rustdoc/impl/blanket-impl-29503.rs
rename to tests/rustdoc-html/impl/blanket-impl-29503.rs
diff --git a/tests/rustdoc/impl/blanket-impl-78673.rs b/tests/rustdoc-html/impl/blanket-impl-78673.rs
similarity index 100%
rename from tests/rustdoc/impl/blanket-impl-78673.rs
rename to tests/rustdoc-html/impl/blanket-impl-78673.rs
diff --git a/tests/rustdoc/impl/cross-crate-hidden-impl-parameter.rs b/tests/rustdoc-html/impl/cross-crate-hidden-impl-parameter.rs
similarity index 100%
rename from tests/rustdoc/impl/cross-crate-hidden-impl-parameter.rs
rename to tests/rustdoc-html/impl/cross-crate-hidden-impl-parameter.rs
diff --git a/tests/rustdoc/impl/deduplicate-glob-import-impl-21474.rs b/tests/rustdoc-html/impl/deduplicate-glob-import-impl-21474.rs
similarity index 100%
rename from tests/rustdoc/impl/deduplicate-glob-import-impl-21474.rs
rename to tests/rustdoc-html/impl/deduplicate-glob-import-impl-21474.rs
diff --git a/tests/rustdoc/impl/deduplicate-trait-impl-22025.rs b/tests/rustdoc-html/impl/deduplicate-trait-impl-22025.rs
similarity index 100%
rename from tests/rustdoc/impl/deduplicate-trait-impl-22025.rs
rename to tests/rustdoc-html/impl/deduplicate-trait-impl-22025.rs
diff --git a/tests/rustdoc/impl/default-impl.rs b/tests/rustdoc-html/impl/default-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/default-impl.rs
rename to tests/rustdoc-html/impl/default-impl.rs
diff --git a/tests/rustdoc/impl/deprecated-impls.rs b/tests/rustdoc-html/impl/deprecated-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/deprecated-impls.rs
rename to tests/rustdoc-html/impl/deprecated-impls.rs
diff --git a/tests/rustdoc/impl/doc-hidden-trait-implementors-33069.rs b/tests/rustdoc-html/impl/doc-hidden-trait-implementors-33069.rs
similarity index 100%
rename from tests/rustdoc/impl/doc-hidden-trait-implementors-33069.rs
rename to tests/rustdoc-html/impl/doc-hidden-trait-implementors-33069.rs
diff --git a/tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs b/tests/rustdoc-html/impl/doc_auto_cfg_nested_impl.rs
similarity index 100%
rename from tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs
rename to tests/rustdoc-html/impl/doc_auto_cfg_nested_impl.rs
diff --git a/tests/rustdoc/impl/duplicated_impl.rs b/tests/rustdoc-html/impl/duplicated_impl.rs
similarity index 100%
rename from tests/rustdoc/impl/duplicated_impl.rs
rename to tests/rustdoc-html/impl/duplicated_impl.rs
diff --git a/tests/rustdoc/impl/empty-impl-block.rs b/tests/rustdoc-html/impl/empty-impl-block.rs
similarity index 100%
rename from tests/rustdoc/impl/empty-impl-block.rs
rename to tests/rustdoc-html/impl/empty-impl-block.rs
diff --git a/tests/rustdoc/impl/empty-impls.rs b/tests/rustdoc-html/impl/empty-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/empty-impls.rs
rename to tests/rustdoc-html/impl/empty-impls.rs
diff --git a/tests/rustdoc/impl/extern-impl-trait.rs b/tests/rustdoc-html/impl/extern-impl-trait.rs
similarity index 100%
rename from tests/rustdoc/impl/extern-impl-trait.rs
rename to tests/rustdoc-html/impl/extern-impl-trait.rs
diff --git a/tests/rustdoc/impl/extern-impl.rs b/tests/rustdoc-html/impl/extern-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/extern-impl.rs
rename to tests/rustdoc-html/impl/extern-impl.rs
diff --git a/tests/rustdoc/impl/foreign-implementors-js-43701.rs b/tests/rustdoc-html/impl/foreign-implementors-js-43701.rs
similarity index 100%
rename from tests/rustdoc/impl/foreign-implementors-js-43701.rs
rename to tests/rustdoc-html/impl/foreign-implementors-js-43701.rs
diff --git a/tests/rustdoc/impl/generic-impl.rs b/tests/rustdoc-html/impl/generic-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/generic-impl.rs
rename to tests/rustdoc-html/impl/generic-impl.rs
diff --git a/tests/rustdoc/impl/hidden-implementors-90781.rs b/tests/rustdoc-html/impl/hidden-implementors-90781.rs
similarity index 100%
rename from tests/rustdoc/impl/hidden-implementors-90781.rs
rename to tests/rustdoc-html/impl/hidden-implementors-90781.rs
diff --git a/tests/rustdoc/impl/hidden-impls.rs b/tests/rustdoc-html/impl/hidden-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/hidden-impls.rs
rename to tests/rustdoc-html/impl/hidden-impls.rs
diff --git a/tests/rustdoc/impl/hidden-trait-struct-impls.rs b/tests/rustdoc-html/impl/hidden-trait-struct-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/hidden-trait-struct-impls.rs
rename to tests/rustdoc-html/impl/hidden-trait-struct-impls.rs
diff --git a/tests/rustdoc/impl/hide-mut-methods-if-no-derefmut-impl-74083.rs b/tests/rustdoc-html/impl/hide-mut-methods-if-no-derefmut-impl-74083.rs
similarity index 100%
rename from tests/rustdoc/impl/hide-mut-methods-if-no-derefmut-impl-74083.rs
rename to tests/rustdoc-html/impl/hide-mut-methods-if-no-derefmut-impl-74083.rs
diff --git a/tests/rustdoc/impl/impl-alias-substituted.rs b/tests/rustdoc-html/impl/impl-alias-substituted.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-alias-substituted.rs
rename to tests/rustdoc-html/impl/impl-alias-substituted.rs
diff --git a/tests/rustdoc/impl/impl-assoc-type-21092.rs b/tests/rustdoc-html/impl/impl-assoc-type-21092.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-assoc-type-21092.rs
rename to tests/rustdoc-html/impl/impl-assoc-type-21092.rs
diff --git a/tests/rustdoc/impl/impl-associated-items-order.rs b/tests/rustdoc-html/impl/impl-associated-items-order.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-associated-items-order.rs
rename to tests/rustdoc-html/impl/impl-associated-items-order.rs
diff --git a/tests/rustdoc/impl/impl-associated-items-sidebar.rs b/tests/rustdoc-html/impl/impl-associated-items-sidebar.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-associated-items-sidebar.rs
rename to tests/rustdoc-html/impl/impl-associated-items-sidebar.rs
diff --git a/tests/rustdoc/impl/impl-blanket-53689.rs b/tests/rustdoc-html/impl/impl-blanket-53689.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-blanket-53689.rs
rename to tests/rustdoc-html/impl/impl-blanket-53689.rs
diff --git a/tests/rustdoc/impl/impl-box.rs b/tests/rustdoc-html/impl/impl-box.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-box.rs
rename to tests/rustdoc-html/impl/impl-box.rs
diff --git a/tests/rustdoc/impl/impl-disambiguation.rs b/tests/rustdoc-html/impl/impl-disambiguation.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-disambiguation.rs
rename to tests/rustdoc-html/impl/impl-disambiguation.rs
diff --git a/tests/rustdoc/impl/impl-everywhere.rs b/tests/rustdoc-html/impl/impl-everywhere.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-everywhere.rs
rename to tests/rustdoc-html/impl/impl-everywhere.rs
diff --git a/tests/rustdoc/impl/impl-in-const-block.rs b/tests/rustdoc-html/impl/impl-in-const-block.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-in-const-block.rs
rename to tests/rustdoc-html/impl/impl-in-const-block.rs
diff --git a/tests/rustdoc/impl/impl-on-ty-alias-issue-119015.rs b/tests/rustdoc-html/impl/impl-on-ty-alias-issue-119015.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-on-ty-alias-issue-119015.rs
rename to tests/rustdoc-html/impl/impl-on-ty-alias-issue-119015.rs
diff --git a/tests/rustdoc/impl/impl-parts-crosscrate.rs b/tests/rustdoc-html/impl/impl-parts-crosscrate.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-parts-crosscrate.rs
rename to tests/rustdoc-html/impl/impl-parts-crosscrate.rs
diff --git a/tests/rustdoc/impl/impl-parts.rs b/tests/rustdoc-html/impl/impl-parts.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-parts.rs
rename to tests/rustdoc-html/impl/impl-parts.rs
diff --git a/tests/rustdoc/impl/impl-ref-20175.rs b/tests/rustdoc-html/impl/impl-ref-20175.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-ref-20175.rs
rename to tests/rustdoc-html/impl/impl-ref-20175.rs
diff --git a/tests/rustdoc/impl/impl-trait-43869.rs b/tests/rustdoc-html/impl/impl-trait-43869.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-trait-43869.rs
rename to tests/rustdoc-html/impl/impl-trait-43869.rs
diff --git a/tests/rustdoc/impl/impl-trait-alias.rs b/tests/rustdoc-html/impl/impl-trait-alias.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-trait-alias.rs
rename to tests/rustdoc-html/impl/impl-trait-alias.rs
diff --git a/tests/rustdoc/impl/impl-trait-precise-capturing.rs b/tests/rustdoc-html/impl/impl-trait-precise-capturing.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-trait-precise-capturing.rs
rename to tests/rustdoc-html/impl/impl-trait-precise-capturing.rs
diff --git a/tests/rustdoc/impl/impl-type-parameter-33592.rs b/tests/rustdoc-html/impl/impl-type-parameter-33592.rs
similarity index 100%
rename from tests/rustdoc/impl/impl-type-parameter-33592.rs
rename to tests/rustdoc-html/impl/impl-type-parameter-33592.rs
diff --git a/tests/rustdoc/impl/implementor-stable-version.rs b/tests/rustdoc-html/impl/implementor-stable-version.rs
similarity index 100%
rename from tests/rustdoc/impl/implementor-stable-version.rs
rename to tests/rustdoc-html/impl/implementor-stable-version.rs
diff --git a/tests/rustdoc/impl/implementors-unstable-75588.rs b/tests/rustdoc-html/impl/implementors-unstable-75588.rs
similarity index 100%
rename from tests/rustdoc/impl/implementors-unstable-75588.rs
rename to tests/rustdoc-html/impl/implementors-unstable-75588.rs
diff --git a/tests/rustdoc/impl/inline-impl-through-glob-import-100204.rs b/tests/rustdoc-html/impl/inline-impl-through-glob-import-100204.rs
similarity index 100%
rename from tests/rustdoc/impl/inline-impl-through-glob-import-100204.rs
rename to tests/rustdoc-html/impl/inline-impl-through-glob-import-100204.rs
diff --git a/tests/rustdoc/impl/manual_impl.rs b/tests/rustdoc-html/impl/manual_impl.rs
similarity index 100%
rename from tests/rustdoc/impl/manual_impl.rs
rename to tests/rustdoc-html/impl/manual_impl.rs
diff --git a/tests/rustdoc/impl/method-link-foreign-trait-impl-17476.rs b/tests/rustdoc-html/impl/method-link-foreign-trait-impl-17476.rs
similarity index 100%
rename from tests/rustdoc/impl/method-link-foreign-trait-impl-17476.rs
rename to tests/rustdoc-html/impl/method-link-foreign-trait-impl-17476.rs
diff --git a/tests/rustdoc/impl/module-impls.rs b/tests/rustdoc-html/impl/module-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/module-impls.rs
rename to tests/rustdoc-html/impl/module-impls.rs
diff --git a/tests/rustdoc/impl/must_implement_one_of.rs b/tests/rustdoc-html/impl/must_implement_one_of.rs
similarity index 100%
rename from tests/rustdoc/impl/must_implement_one_of.rs
rename to tests/rustdoc-html/impl/must_implement_one_of.rs
diff --git a/tests/rustdoc/impl/negative-impl-no-items.rs b/tests/rustdoc-html/impl/negative-impl-no-items.rs
similarity index 100%
rename from tests/rustdoc/impl/negative-impl-no-items.rs
rename to tests/rustdoc-html/impl/negative-impl-no-items.rs
diff --git a/tests/rustdoc/impl/negative-impl-sidebar.rs b/tests/rustdoc-html/impl/negative-impl-sidebar.rs
similarity index 100%
rename from tests/rustdoc/impl/negative-impl-sidebar.rs
rename to tests/rustdoc-html/impl/negative-impl-sidebar.rs
diff --git a/tests/rustdoc/impl/negative-impl.rs b/tests/rustdoc-html/impl/negative-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/negative-impl.rs
rename to tests/rustdoc-html/impl/negative-impl.rs
diff --git a/tests/rustdoc/impl/return-impl-trait.rs b/tests/rustdoc-html/impl/return-impl-trait.rs
similarity index 100%
rename from tests/rustdoc/impl/return-impl-trait.rs
rename to tests/rustdoc-html/impl/return-impl-trait.rs
diff --git a/tests/rustdoc/impl/rustc-incoherent-impls.rs b/tests/rustdoc-html/impl/rustc-incoherent-impls.rs
similarity index 100%
rename from tests/rustdoc/impl/rustc-incoherent-impls.rs
rename to tests/rustdoc-html/impl/rustc-incoherent-impls.rs
diff --git a/tests/rustdoc/impl/same-crate-hidden-impl-parameter.rs b/tests/rustdoc-html/impl/same-crate-hidden-impl-parameter.rs
similarity index 100%
rename from tests/rustdoc/impl/same-crate-hidden-impl-parameter.rs
rename to tests/rustdoc-html/impl/same-crate-hidden-impl-parameter.rs
diff --git a/tests/rustdoc/impl/sidebar-trait-impl-disambiguate-78701.rs b/tests/rustdoc-html/impl/sidebar-trait-impl-disambiguate-78701.rs
similarity index 100%
rename from tests/rustdoc/impl/sidebar-trait-impl-disambiguate-78701.rs
rename to tests/rustdoc-html/impl/sidebar-trait-impl-disambiguate-78701.rs
diff --git a/tests/rustdoc/impl/struct-implementations-title.rs b/tests/rustdoc-html/impl/struct-implementations-title.rs
similarity index 100%
rename from tests/rustdoc/impl/struct-implementations-title.rs
rename to tests/rustdoc-html/impl/struct-implementations-title.rs
diff --git a/tests/rustdoc/impl/trait-impl.rs b/tests/rustdoc-html/impl/trait-impl.rs
similarity index 100%
rename from tests/rustdoc/impl/trait-impl.rs
rename to tests/rustdoc-html/impl/trait-impl.rs
diff --git a/tests/rustdoc/impl/trait-implementations-duplicate-self-45584.rs b/tests/rustdoc-html/impl/trait-implementations-duplicate-self-45584.rs
similarity index 100%
rename from tests/rustdoc/impl/trait-implementations-duplicate-self-45584.rs
rename to tests/rustdoc-html/impl/trait-implementations-duplicate-self-45584.rs
diff --git a/tests/rustdoc/impl/underscore-type-in-trait-impl-96381.rs b/tests/rustdoc-html/impl/underscore-type-in-trait-impl-96381.rs
similarity index 100%
rename from tests/rustdoc/impl/underscore-type-in-trait-impl-96381.rs
rename to tests/rustdoc-html/impl/underscore-type-in-trait-impl-96381.rs
diff --git a/tests/rustdoc/impl/universal-impl-trait.rs b/tests/rustdoc-html/impl/universal-impl-trait.rs
similarity index 100%
rename from tests/rustdoc/impl/universal-impl-trait.rs
rename to tests/rustdoc-html/impl/universal-impl-trait.rs
diff --git a/tests/rustdoc/impl/unneeded-trait-implementations-title.rs b/tests/rustdoc-html/impl/unneeded-trait-implementations-title.rs
similarity index 100%
rename from tests/rustdoc/impl/unneeded-trait-implementations-title.rs
rename to tests/rustdoc-html/impl/unneeded-trait-implementations-title.rs
diff --git a/tests/rustdoc/import-remapped-paths.rs b/tests/rustdoc-html/import-remapped-paths.rs
similarity index 100%
rename from tests/rustdoc/import-remapped-paths.rs
rename to tests/rustdoc-html/import-remapped-paths.rs
diff --git a/tests/rustdoc/impossible-default.rs b/tests/rustdoc-html/impossible-default.rs
similarity index 100%
rename from tests/rustdoc/impossible-default.rs
rename to tests/rustdoc-html/impossible-default.rs
diff --git a/tests/rustdoc/include_str_cut.rs b/tests/rustdoc-html/include_str_cut.rs
similarity index 100%
rename from tests/rustdoc/include_str_cut.rs
rename to tests/rustdoc-html/include_str_cut.rs
diff --git a/tests/rustdoc/index-page.rs b/tests/rustdoc-html/index-page.rs
similarity index 100%
rename from tests/rustdoc/index-page.rs
rename to tests/rustdoc-html/index-page.rs
diff --git a/tests/rustdoc/infinite-redirection-16265-1.rs b/tests/rustdoc-html/infinite-redirection-16265-1.rs
similarity index 100%
rename from tests/rustdoc/infinite-redirection-16265-1.rs
rename to tests/rustdoc-html/infinite-redirection-16265-1.rs
diff --git a/tests/rustdoc/infinite-redirection-16265-2.rs b/tests/rustdoc-html/infinite-redirection-16265-2.rs
similarity index 100%
rename from tests/rustdoc/infinite-redirection-16265-2.rs
rename to tests/rustdoc-html/infinite-redirection-16265-2.rs
diff --git a/tests/rustdoc/infinite-redirection.rs b/tests/rustdoc-html/infinite-redirection.rs
similarity index 100%
rename from tests/rustdoc/infinite-redirection.rs
rename to tests/rustdoc-html/infinite-redirection.rs
diff --git a/tests/rustdoc/inherent-projections.rs b/tests/rustdoc-html/inherent-projections.rs
similarity index 100%
rename from tests/rustdoc/inherent-projections.rs
rename to tests/rustdoc-html/inherent-projections.rs
diff --git a/tests/rustdoc/inline-default-methods.rs b/tests/rustdoc-html/inline-default-methods.rs
similarity index 100%
rename from tests/rustdoc/inline-default-methods.rs
rename to tests/rustdoc-html/inline-default-methods.rs
diff --git a/tests/rustdoc/inline-rename-34473.rs b/tests/rustdoc-html/inline-rename-34473.rs
similarity index 100%
rename from tests/rustdoc/inline-rename-34473.rs
rename to tests/rustdoc-html/inline-rename-34473.rs
diff --git a/tests/rustdoc/inline_cross/add-docs.rs b/tests/rustdoc-html/inline_cross/add-docs.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/add-docs.rs
rename to tests/rustdoc-html/inline_cross/add-docs.rs
diff --git a/tests/rustdoc/inline_cross/assoc-const-equality.rs b/tests/rustdoc-html/inline_cross/assoc-const-equality.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc-const-equality.rs
rename to tests/rustdoc-html/inline_cross/assoc-const-equality.rs
diff --git a/tests/rustdoc/inline_cross/assoc-items.rs b/tests/rustdoc-html/inline_cross/assoc-items.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc-items.rs
rename to tests/rustdoc-html/inline_cross/assoc-items.rs
diff --git a/tests/rustdoc/inline_cross/assoc_item_trait_bounds.out0.html b/tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out0.html
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc_item_trait_bounds.out0.html
rename to tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out0.html
diff --git a/tests/rustdoc/inline_cross/assoc_item_trait_bounds.out2.html b/tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out2.html
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc_item_trait_bounds.out2.html
rename to tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out2.html
diff --git a/tests/rustdoc/inline_cross/assoc_item_trait_bounds.out9.html b/tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out9.html
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc_item_trait_bounds.out9.html
rename to tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.out9.html
diff --git a/tests/rustdoc/inline_cross/assoc_item_trait_bounds.rs b/tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/assoc_item_trait_bounds.rs
rename to tests/rustdoc-html/inline_cross/assoc_item_trait_bounds.rs
diff --git a/tests/rustdoc/inline_cross/async-fn.rs b/tests/rustdoc-html/inline_cross/async-fn.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/async-fn.rs
rename to tests/rustdoc-html/inline_cross/async-fn.rs
diff --git a/tests/rustdoc/inline_cross/attributes.rs b/tests/rustdoc-html/inline_cross/attributes.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/attributes.rs
rename to tests/rustdoc-html/inline_cross/attributes.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/add-docs.rs b/tests/rustdoc-html/inline_cross/auxiliary/add-docs.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/add-docs.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/add-docs.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/assoc-const-equality.rs b/tests/rustdoc-html/inline_cross/auxiliary/assoc-const-equality.rs
similarity index 67%
rename from tests/rustdoc/inline_cross/auxiliary/assoc-const-equality.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/assoc-const-equality.rs
index f6c03d189b5e..598d2b5bf29d 100644
--- a/tests/rustdoc/inline_cross/auxiliary/assoc-const-equality.rs
+++ b/tests/rustdoc-html/inline_cross/auxiliary/assoc-const-equality.rs
@@ -1,5 +1,5 @@
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 pub fn accept(_: impl Trait<K = 0>) {}
 
diff --git a/tests/rustdoc/inline_cross/auxiliary/assoc-items.rs b/tests/rustdoc-html/inline_cross/auxiliary/assoc-items.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/assoc-items.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/assoc-items.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/assoc_item_trait_bounds.rs b/tests/rustdoc-html/inline_cross/auxiliary/assoc_item_trait_bounds.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/assoc_item_trait_bounds.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/assoc_item_trait_bounds.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/async-fn.rs b/tests/rustdoc-html/inline_cross/auxiliary/async-fn.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/async-fn.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/async-fn.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/attributes.rs b/tests/rustdoc-html/inline_cross/auxiliary/attributes.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/attributes.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/attributes.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/const-effect-param.rs b/tests/rustdoc-html/inline_cross/auxiliary/const-effect-param.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/const-effect-param.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/const-effect-param.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/cross-glob.rs b/tests/rustdoc-html/inline_cross/auxiliary/cross-glob.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/cross-glob.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/cross-glob.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/default-generic-args.rs b/tests/rustdoc-html/inline_cross/auxiliary/default-generic-args.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/default-generic-args.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/default-generic-args.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/default-trait-method.rs b/tests/rustdoc-html/inline_cross/auxiliary/default-trait-method.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/default-trait-method.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/default-trait-method.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/doc-auto-cfg.rs b/tests/rustdoc-html/inline_cross/auxiliary/doc-auto-cfg.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/doc-auto-cfg.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/doc-auto-cfg.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/dyn_trait.rs b/tests/rustdoc-html/inline_cross/auxiliary/dyn_trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/dyn_trait.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/dyn_trait.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/early-late-bound-lifetime-params.rs b/tests/rustdoc-html/inline_cross/auxiliary/early-late-bound-lifetime-params.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/early-late-bound-lifetime-params.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/early-late-bound-lifetime-params.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/fn-ptr-ty.rs b/tests/rustdoc-html/inline_cross/auxiliary/fn-ptr-ty.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/fn-ptr-ty.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/fn-ptr-ty.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/generic-const-items.rs b/tests/rustdoc-html/inline_cross/auxiliary/generic-const-items.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/generic-const-items.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/generic-const-items.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/impl-inline-without-trait.rs b/tests/rustdoc-html/inline_cross/auxiliary/impl-inline-without-trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/impl-inline-without-trait.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/impl-inline-without-trait.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/impl-sized.rs b/tests/rustdoc-html/inline_cross/auxiliary/impl-sized.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/impl-sized.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/impl-sized.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/impl_trait_aux.rs b/tests/rustdoc-html/inline_cross/auxiliary/impl_trait_aux.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/impl_trait_aux.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/impl_trait_aux.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/implementors_inline.rs b/tests/rustdoc-html/inline_cross/auxiliary/implementors_inline.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/implementors_inline.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/implementors_inline.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-21801.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-21801.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-21801.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-21801.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-23207-1.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-23207-1.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-23207-1.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-23207-1.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-23207-2.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-23207-2.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-23207-2.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-23207-2.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-24183.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-24183.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-24183.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-24183.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-27362-aux.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-27362-aux.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-27362-aux.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-27362-aux.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-29584.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-29584.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-29584.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-29584.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-33113.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-33113.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-33113.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-33113.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-46727.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-46727.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-46727.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-46727.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-57180.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-57180.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-57180.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-57180.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-76736-1.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-76736-1.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-76736-1.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-76736-1.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-76736-2.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-76736-2.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-76736-2.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-76736-2.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/issue-85454.rs b/tests/rustdoc-html/inline_cross/auxiliary/issue-85454.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/issue-85454.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/issue-85454.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/macro-vis.rs b/tests/rustdoc-html/inline_cross/auxiliary/macro-vis.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/macro-vis.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/macro-vis.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/macros.rs b/tests/rustdoc-html/inline_cross/auxiliary/macros.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/macros.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/macros.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/non_lifetime_binders.rs b/tests/rustdoc-html/inline_cross/auxiliary/non_lifetime_binders.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/non_lifetime_binders.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/non_lifetime_binders.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/proc_macro.rs b/tests/rustdoc-html/inline_cross/auxiliary/proc_macro.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/proc_macro.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/proc_macro.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs b/tests/rustdoc-html/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/renamed-via-module.rs b/tests/rustdoc-html/inline_cross/auxiliary/renamed-via-module.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/renamed-via-module.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/renamed-via-module.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/ret-pos-impl-trait-in-trait.rs b/tests/rustdoc-html/inline_cross/auxiliary/ret-pos-impl-trait-in-trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/ret-pos-impl-trait-in-trait.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/ret-pos-impl-trait-in-trait.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/rustdoc-hidden-sig.rs b/tests/rustdoc-html/inline_cross/auxiliary/rustdoc-hidden-sig.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/rustdoc-hidden-sig.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/rustdoc-hidden-sig.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/rustdoc-hidden.rs b/tests/rustdoc-html/inline_cross/auxiliary/rustdoc-hidden.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/rustdoc-hidden.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/rustdoc-hidden.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/rustdoc-nonreachable-impls.rs b/tests/rustdoc-html/inline_cross/auxiliary/rustdoc-nonreachable-impls.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/rustdoc-nonreachable-impls.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/rustdoc-nonreachable-impls.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/rustdoc-trait-object-impl.rs b/tests/rustdoc-html/inline_cross/auxiliary/rustdoc-trait-object-impl.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/rustdoc-trait-object-impl.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/rustdoc-trait-object-impl.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/trait-vis.rs b/tests/rustdoc-html/inline_cross/auxiliary/trait-vis.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/trait-vis.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/trait-vis.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/use_crate.rs b/tests/rustdoc-html/inline_cross/auxiliary/use_crate.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/use_crate.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/use_crate.rs
diff --git a/tests/rustdoc/inline_cross/auxiliary/use_crate_2.rs b/tests/rustdoc-html/inline_cross/auxiliary/use_crate_2.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/auxiliary/use_crate_2.rs
rename to tests/rustdoc-html/inline_cross/auxiliary/use_crate_2.rs
diff --git a/tests/rustdoc/inline_cross/const-effect-param.rs b/tests/rustdoc-html/inline_cross/const-effect-param.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/const-effect-param.rs
rename to tests/rustdoc-html/inline_cross/const-effect-param.rs
diff --git a/tests/rustdoc/inline_cross/const-eval-46727.rs b/tests/rustdoc-html/inline_cross/const-eval-46727.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/const-eval-46727.rs
rename to tests/rustdoc-html/inline_cross/const-eval-46727.rs
diff --git a/tests/rustdoc/inline_cross/const-fn-27362.rs b/tests/rustdoc-html/inline_cross/const-fn-27362.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/const-fn-27362.rs
rename to tests/rustdoc-html/inline_cross/const-fn-27362.rs
diff --git a/tests/rustdoc/inline_cross/cross-glob.rs b/tests/rustdoc-html/inline_cross/cross-glob.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/cross-glob.rs
rename to tests/rustdoc-html/inline_cross/cross-glob.rs
diff --git a/tests/rustdoc/inline_cross/deduplicate-inlined-items-23207.rs b/tests/rustdoc-html/inline_cross/deduplicate-inlined-items-23207.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/deduplicate-inlined-items-23207.rs
rename to tests/rustdoc-html/inline_cross/deduplicate-inlined-items-23207.rs
diff --git a/tests/rustdoc/inline_cross/default-generic-args.rs b/tests/rustdoc-html/inline_cross/default-generic-args.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/default-generic-args.rs
rename to tests/rustdoc-html/inline_cross/default-generic-args.rs
diff --git a/tests/rustdoc/inline_cross/default-trait-method.rs b/tests/rustdoc-html/inline_cross/default-trait-method.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/default-trait-method.rs
rename to tests/rustdoc-html/inline_cross/default-trait-method.rs
diff --git a/tests/rustdoc/inline_cross/doc-auto-cfg.rs b/tests/rustdoc-html/inline_cross/doc-auto-cfg.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-auto-cfg.rs
rename to tests/rustdoc-html/inline_cross/doc-auto-cfg.rs
diff --git a/tests/rustdoc/inline_cross/doc-hidden-broken-link-28480.rs b/tests/rustdoc-html/inline_cross/doc-hidden-broken-link-28480.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-hidden-broken-link-28480.rs
rename to tests/rustdoc-html/inline_cross/doc-hidden-broken-link-28480.rs
diff --git a/tests/rustdoc/inline_cross/doc-hidden-extern-trait-impl-29584.rs b/tests/rustdoc-html/inline_cross/doc-hidden-extern-trait-impl-29584.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-hidden-extern-trait-impl-29584.rs
rename to tests/rustdoc-html/inline_cross/doc-hidden-extern-trait-impl-29584.rs
diff --git a/tests/rustdoc/inline_cross/doc-reachability-impl-31948-1.rs b/tests/rustdoc-html/inline_cross/doc-reachability-impl-31948-1.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-reachability-impl-31948-1.rs
rename to tests/rustdoc-html/inline_cross/doc-reachability-impl-31948-1.rs
diff --git a/tests/rustdoc/inline_cross/doc-reachability-impl-31948-2.rs b/tests/rustdoc-html/inline_cross/doc-reachability-impl-31948-2.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-reachability-impl-31948-2.rs
rename to tests/rustdoc-html/inline_cross/doc-reachability-impl-31948-2.rs
diff --git a/tests/rustdoc/inline_cross/doc-reachability-impl-31948.rs b/tests/rustdoc-html/inline_cross/doc-reachability-impl-31948.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/doc-reachability-impl-31948.rs
rename to tests/rustdoc-html/inline_cross/doc-reachability-impl-31948.rs
diff --git a/tests/rustdoc/inline_cross/dyn_trait.rs b/tests/rustdoc-html/inline_cross/dyn_trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/dyn_trait.rs
rename to tests/rustdoc-html/inline_cross/dyn_trait.rs
diff --git a/tests/rustdoc/inline_cross/early-late-bound-lifetime-params.rs b/tests/rustdoc-html/inline_cross/early-late-bound-lifetime-params.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/early-late-bound-lifetime-params.rs
rename to tests/rustdoc-html/inline_cross/early-late-bound-lifetime-params.rs
diff --git a/tests/rustdoc/inline_cross/fn-ptr-ty.rs b/tests/rustdoc-html/inline_cross/fn-ptr-ty.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/fn-ptr-ty.rs
rename to tests/rustdoc-html/inline_cross/fn-ptr-ty.rs
diff --git a/tests/rustdoc/inline_cross/generic-const-items.rs b/tests/rustdoc-html/inline_cross/generic-const-items.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/generic-const-items.rs
rename to tests/rustdoc-html/inline_cross/generic-const-items.rs
diff --git a/tests/rustdoc/inline_cross/hidden-use.rs b/tests/rustdoc-html/inline_cross/hidden-use.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/hidden-use.rs
rename to tests/rustdoc-html/inline_cross/hidden-use.rs
diff --git a/tests/rustdoc/inline_cross/ice-import-crate-57180.rs b/tests/rustdoc-html/inline_cross/ice-import-crate-57180.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/ice-import-crate-57180.rs
rename to tests/rustdoc-html/inline_cross/ice-import-crate-57180.rs
diff --git a/tests/rustdoc/inline_cross/impl-dyn-trait-32881.rs b/tests/rustdoc-html/inline_cross/impl-dyn-trait-32881.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/impl-dyn-trait-32881.rs
rename to tests/rustdoc-html/inline_cross/impl-dyn-trait-32881.rs
diff --git a/tests/rustdoc/inline_cross/impl-inline-without-trait.rs b/tests/rustdoc-html/inline_cross/impl-inline-without-trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/impl-inline-without-trait.rs
rename to tests/rustdoc-html/inline_cross/impl-inline-without-trait.rs
diff --git a/tests/rustdoc/inline_cross/impl-ref-33113.rs b/tests/rustdoc-html/inline_cross/impl-ref-33113.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/impl-ref-33113.rs
rename to tests/rustdoc-html/inline_cross/impl-ref-33113.rs
diff --git a/tests/rustdoc/inline_cross/impl-sized.rs b/tests/rustdoc-html/inline_cross/impl-sized.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/impl-sized.rs
rename to tests/rustdoc-html/inline_cross/impl-sized.rs
diff --git a/tests/rustdoc/inline_cross/impl_trait.rs b/tests/rustdoc-html/inline_cross/impl_trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/impl_trait.rs
rename to tests/rustdoc-html/inline_cross/impl_trait.rs
diff --git a/tests/rustdoc/inline_cross/implementors-js.rs b/tests/rustdoc-html/inline_cross/implementors-js.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/implementors-js.rs
rename to tests/rustdoc-html/inline_cross/implementors-js.rs
diff --git a/tests/rustdoc/inline_cross/inline_hidden.rs b/tests/rustdoc-html/inline_cross/inline_hidden.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/inline_hidden.rs
rename to tests/rustdoc-html/inline_cross/inline_hidden.rs
diff --git a/tests/rustdoc/inline_cross/macro-vis.rs b/tests/rustdoc-html/inline_cross/macro-vis.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/macro-vis.rs
rename to tests/rustdoc-html/inline_cross/macro-vis.rs
diff --git a/tests/rustdoc/inline_cross/macros.rs b/tests/rustdoc-html/inline_cross/macros.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/macros.rs
rename to tests/rustdoc-html/inline_cross/macros.rs
diff --git a/tests/rustdoc/inline_cross/non_lifetime_binders.rs b/tests/rustdoc-html/inline_cross/non_lifetime_binders.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/non_lifetime_binders.rs
rename to tests/rustdoc-html/inline_cross/non_lifetime_binders.rs
diff --git a/tests/rustdoc/inline_cross/proc_macro.rs b/tests/rustdoc-html/inline_cross/proc_macro.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/proc_macro.rs
rename to tests/rustdoc-html/inline_cross/proc_macro.rs
diff --git a/tests/rustdoc/inline_cross/qpath-self-85454.rs b/tests/rustdoc-html/inline_cross/qpath-self-85454.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/qpath-self-85454.rs
rename to tests/rustdoc-html/inline_cross/qpath-self-85454.rs
diff --git a/tests/rustdoc/inline_cross/reexport-with-anonymous-lifetime-98697.rs b/tests/rustdoc-html/inline_cross/reexport-with-anonymous-lifetime-98697.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/reexport-with-anonymous-lifetime-98697.rs
rename to tests/rustdoc-html/inline_cross/reexport-with-anonymous-lifetime-98697.rs
diff --git a/tests/rustdoc/inline_cross/renamed-via-module.rs b/tests/rustdoc-html/inline_cross/renamed-via-module.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/renamed-via-module.rs
rename to tests/rustdoc-html/inline_cross/renamed-via-module.rs
diff --git a/tests/rustdoc/inline_cross/ret-pos-impl-trait-in-trait.rs b/tests/rustdoc-html/inline_cross/ret-pos-impl-trait-in-trait.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/ret-pos-impl-trait-in-trait.rs
rename to tests/rustdoc-html/inline_cross/ret-pos-impl-trait-in-trait.rs
diff --git a/tests/rustdoc/inline_cross/rustc-private-76736-1.rs b/tests/rustdoc-html/inline_cross/rustc-private-76736-1.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/rustc-private-76736-1.rs
rename to tests/rustdoc-html/inline_cross/rustc-private-76736-1.rs
diff --git a/tests/rustdoc/inline_cross/rustc-private-76736-2.rs b/tests/rustdoc-html/inline_cross/rustc-private-76736-2.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/rustc-private-76736-2.rs
rename to tests/rustdoc-html/inline_cross/rustc-private-76736-2.rs
diff --git a/tests/rustdoc/inline_cross/rustc-private-76736-3.rs b/tests/rustdoc-html/inline_cross/rustc-private-76736-3.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/rustc-private-76736-3.rs
rename to tests/rustdoc-html/inline_cross/rustc-private-76736-3.rs
diff --git a/tests/rustdoc/inline_cross/rustc-private-76736-4.rs b/tests/rustdoc-html/inline_cross/rustc-private-76736-4.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/rustc-private-76736-4.rs
rename to tests/rustdoc-html/inline_cross/rustc-private-76736-4.rs
diff --git a/tests/rustdoc/inline_cross/self-sized-bounds-24183.method_no_where_self_sized.html b/tests/rustdoc-html/inline_cross/self-sized-bounds-24183.method_no_where_self_sized.html
similarity index 100%
rename from tests/rustdoc/inline_cross/self-sized-bounds-24183.method_no_where_self_sized.html
rename to tests/rustdoc-html/inline_cross/self-sized-bounds-24183.method_no_where_self_sized.html
diff --git a/tests/rustdoc/inline_cross/self-sized-bounds-24183.rs b/tests/rustdoc-html/inline_cross/self-sized-bounds-24183.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/self-sized-bounds-24183.rs
rename to tests/rustdoc-html/inline_cross/self-sized-bounds-24183.rs
diff --git a/tests/rustdoc/inline_cross/sugar-closure-crate-21801.rs b/tests/rustdoc-html/inline_cross/sugar-closure-crate-21801.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/sugar-closure-crate-21801.rs
rename to tests/rustdoc-html/inline_cross/sugar-closure-crate-21801.rs
diff --git a/tests/rustdoc/inline_cross/trait-vis.rs b/tests/rustdoc-html/inline_cross/trait-vis.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/trait-vis.rs
rename to tests/rustdoc-html/inline_cross/trait-vis.rs
diff --git a/tests/rustdoc/inline_cross/use_crate.rs b/tests/rustdoc-html/inline_cross/use_crate.rs
similarity index 100%
rename from tests/rustdoc/inline_cross/use_crate.rs
rename to tests/rustdoc-html/inline_cross/use_crate.rs
diff --git a/tests/rustdoc/inline_local/blanket-impl-reexported-trait-94183.rs b/tests/rustdoc-html/inline_local/blanket-impl-reexported-trait-94183.rs
similarity index 100%
rename from tests/rustdoc/inline_local/blanket-impl-reexported-trait-94183.rs
rename to tests/rustdoc-html/inline_local/blanket-impl-reexported-trait-94183.rs
diff --git a/tests/rustdoc/inline_local/doc-no-inline-32343.rs b/tests/rustdoc-html/inline_local/doc-no-inline-32343.rs
similarity index 100%
rename from tests/rustdoc/inline_local/doc-no-inline-32343.rs
rename to tests/rustdoc-html/inline_local/doc-no-inline-32343.rs
diff --git a/tests/rustdoc/inline_local/enum-variant-reexport-46766.rs b/tests/rustdoc-html/inline_local/enum-variant-reexport-46766.rs
similarity index 100%
rename from tests/rustdoc/inline_local/enum-variant-reexport-46766.rs
rename to tests/rustdoc-html/inline_local/enum-variant-reexport-46766.rs
diff --git a/tests/rustdoc/inline_local/fully-stable-path-is-better.rs b/tests/rustdoc-html/inline_local/fully-stable-path-is-better.rs
similarity index 100%
rename from tests/rustdoc/inline_local/fully-stable-path-is-better.rs
rename to tests/rustdoc-html/inline_local/fully-stable-path-is-better.rs
diff --git a/tests/rustdoc/inline_local/glob-extern-document-private-items.rs b/tests/rustdoc-html/inline_local/glob-extern-document-private-items.rs
similarity index 100%
rename from tests/rustdoc/inline_local/glob-extern-document-private-items.rs
rename to tests/rustdoc-html/inline_local/glob-extern-document-private-items.rs
diff --git a/tests/rustdoc/inline_local/glob-extern.rs b/tests/rustdoc-html/inline_local/glob-extern.rs
similarity index 100%
rename from tests/rustdoc/inline_local/glob-extern.rs
rename to tests/rustdoc-html/inline_local/glob-extern.rs
diff --git a/tests/rustdoc/inline_local/glob-private-document-private-items.rs b/tests/rustdoc-html/inline_local/glob-private-document-private-items.rs
similarity index 100%
rename from tests/rustdoc/inline_local/glob-private-document-private-items.rs
rename to tests/rustdoc-html/inline_local/glob-private-document-private-items.rs
diff --git a/tests/rustdoc/inline_local/glob-private.rs b/tests/rustdoc-html/inline_local/glob-private.rs
similarity index 100%
rename from tests/rustdoc/inline_local/glob-private.rs
rename to tests/rustdoc-html/inline_local/glob-private.rs
diff --git a/tests/rustdoc/inline_local/hidden-use.rs b/tests/rustdoc-html/inline_local/hidden-use.rs
similarity index 100%
rename from tests/rustdoc/inline_local/hidden-use.rs
rename to tests/rustdoc-html/inline_local/hidden-use.rs
diff --git a/tests/rustdoc/inline_local/macro_by_example.rs b/tests/rustdoc-html/inline_local/macro_by_example.rs
similarity index 100%
rename from tests/rustdoc/inline_local/macro_by_example.rs
rename to tests/rustdoc-html/inline_local/macro_by_example.rs
diff --git a/tests/rustdoc/inline_local/parent-path-is-better.rs b/tests/rustdoc-html/inline_local/parent-path-is-better.rs
similarity index 100%
rename from tests/rustdoc/inline_local/parent-path-is-better.rs
rename to tests/rustdoc-html/inline_local/parent-path-is-better.rs
diff --git a/tests/rustdoc/inline_local/please_inline.rs b/tests/rustdoc-html/inline_local/please_inline.rs
similarity index 100%
rename from tests/rustdoc/inline_local/please_inline.rs
rename to tests/rustdoc-html/inline_local/please_inline.rs
diff --git a/tests/rustdoc/inline_local/private-reexport-in-public-api-81141-2.rs b/tests/rustdoc-html/inline_local/private-reexport-in-public-api-81141-2.rs
similarity index 100%
rename from tests/rustdoc/inline_local/private-reexport-in-public-api-81141-2.rs
rename to tests/rustdoc-html/inline_local/private-reexport-in-public-api-81141-2.rs
diff --git a/tests/rustdoc/inline_local/private-reexport-in-public-api-81141.rs b/tests/rustdoc-html/inline_local/private-reexport-in-public-api-81141.rs
similarity index 100%
rename from tests/rustdoc/inline_local/private-reexport-in-public-api-81141.rs
rename to tests/rustdoc-html/inline_local/private-reexport-in-public-api-81141.rs
diff --git a/tests/rustdoc/inline_local/private-reexport-in-public-api-generics-81141.rs b/tests/rustdoc-html/inline_local/private-reexport-in-public-api-generics-81141.rs
similarity index 100%
rename from tests/rustdoc/inline_local/private-reexport-in-public-api-generics-81141.rs
rename to tests/rustdoc-html/inline_local/private-reexport-in-public-api-generics-81141.rs
diff --git a/tests/rustdoc/inline_local/private-reexport-in-public-api-hidden-81141.rs b/tests/rustdoc-html/inline_local/private-reexport-in-public-api-hidden-81141.rs
similarity index 100%
rename from tests/rustdoc/inline_local/private-reexport-in-public-api-hidden-81141.rs
rename to tests/rustdoc-html/inline_local/private-reexport-in-public-api-hidden-81141.rs
diff --git a/tests/rustdoc/inline_local/private-reexport-in-public-api-private-81141.rs b/tests/rustdoc-html/inline_local/private-reexport-in-public-api-private-81141.rs
similarity index 100%
rename from tests/rustdoc/inline_local/private-reexport-in-public-api-private-81141.rs
rename to tests/rustdoc-html/inline_local/private-reexport-in-public-api-private-81141.rs
diff --git a/tests/rustdoc/inline_local/pub-re-export-28537.rs b/tests/rustdoc-html/inline_local/pub-re-export-28537.rs
similarity index 100%
rename from tests/rustdoc/inline_local/pub-re-export-28537.rs
rename to tests/rustdoc-html/inline_local/pub-re-export-28537.rs
diff --git a/tests/rustdoc/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs b/tests/rustdoc-html/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs
similarity index 100%
rename from tests/rustdoc/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs
rename to tests/rustdoc-html/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs
diff --git a/tests/rustdoc/inline_local/staged-inline.rs b/tests/rustdoc-html/inline_local/staged-inline.rs
similarity index 100%
rename from tests/rustdoc/inline_local/staged-inline.rs
rename to tests/rustdoc-html/inline_local/staged-inline.rs
diff --git a/tests/rustdoc/inline_local/trait-vis.rs b/tests/rustdoc-html/inline_local/trait-vis.rs
similarity index 100%
rename from tests/rustdoc/inline_local/trait-vis.rs
rename to tests/rustdoc-html/inline_local/trait-vis.rs
diff --git a/tests/rustdoc/internal.rs b/tests/rustdoc-html/internal.rs
similarity index 100%
rename from tests/rustdoc/internal.rs
rename to tests/rustdoc-html/internal.rs
diff --git a/tests/rustdoc/intra-doc-crate/auxiliary/self.rs b/tests/rustdoc-html/intra-doc-crate/auxiliary/self.rs
similarity index 100%
rename from tests/rustdoc/intra-doc-crate/auxiliary/self.rs
rename to tests/rustdoc-html/intra-doc-crate/auxiliary/self.rs
diff --git a/tests/rustdoc/intra-doc-crate/self.rs b/tests/rustdoc-html/intra-doc-crate/self.rs
similarity index 100%
rename from tests/rustdoc/intra-doc-crate/self.rs
rename to tests/rustdoc-html/intra-doc-crate/self.rs
diff --git a/tests/rustdoc/intra-doc/anchors.rs b/tests/rustdoc-html/intra-doc/anchors.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/anchors.rs
rename to tests/rustdoc-html/intra-doc/anchors.rs
diff --git a/tests/rustdoc/intra-doc/assoc-reexport-super.rs b/tests/rustdoc-html/intra-doc/assoc-reexport-super.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/assoc-reexport-super.rs
rename to tests/rustdoc-html/intra-doc/assoc-reexport-super.rs
diff --git a/tests/rustdoc/intra-doc/associated-defaults.rs b/tests/rustdoc-html/intra-doc/associated-defaults.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/associated-defaults.rs
rename to tests/rustdoc-html/intra-doc/associated-defaults.rs
diff --git a/tests/rustdoc/intra-doc/associated-items.rs b/tests/rustdoc-html/intra-doc/associated-items.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/associated-items.rs
rename to tests/rustdoc-html/intra-doc/associated-items.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/empty.rs b/tests/rustdoc-html/intra-doc/auxiliary/empty.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/empty.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/empty.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/empty2.rs b/tests/rustdoc-html/intra-doc/auxiliary/empty2.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/empty2.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/empty2.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/extern-builtin-type-impl-dep.rs b/tests/rustdoc-html/intra-doc/auxiliary/extern-builtin-type-impl-dep.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/extern-builtin-type-impl-dep.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/extern-builtin-type-impl-dep.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/extern-inherent-impl-dep.rs b/tests/rustdoc-html/intra-doc/auxiliary/extern-inherent-impl-dep.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/extern-inherent-impl-dep.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/extern-inherent-impl-dep.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/intra-link-extern-crate.rs b/tests/rustdoc-html/intra-doc/auxiliary/intra-link-extern-crate.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/intra-link-extern-crate.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/intra-link-extern-crate.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/intra-link-pub-use.rs b/tests/rustdoc-html/intra-doc/auxiliary/intra-link-pub-use.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/intra-link-pub-use.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/intra-link-pub-use.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/intra-link-reexport-additional-docs.rs b/tests/rustdoc-html/intra-doc/auxiliary/intra-link-reexport-additional-docs.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/intra-link-reexport-additional-docs.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/intra-link-reexport-additional-docs.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/intra-links-external-traits.rs b/tests/rustdoc-html/intra-doc/auxiliary/intra-links-external-traits.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/intra-links-external-traits.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/intra-links-external-traits.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/issue-66159-1.rs b/tests/rustdoc-html/intra-doc/auxiliary/issue-66159-1.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/issue-66159-1.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/issue-66159-1.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/my-core.rs b/tests/rustdoc-html/intra-doc/auxiliary/my-core.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/my-core.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/my-core.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/proc-macro-macro.rs b/tests/rustdoc-html/intra-doc/auxiliary/proc-macro-macro.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/proc-macro-macro.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/proc-macro-macro.rs
diff --git a/tests/rustdoc/intra-doc/auxiliary/pub-struct.rs b/tests/rustdoc-html/intra-doc/auxiliary/pub-struct.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/auxiliary/pub-struct.rs
rename to tests/rustdoc-html/intra-doc/auxiliary/pub-struct.rs
diff --git a/tests/rustdoc/intra-doc/basic.rs b/tests/rustdoc-html/intra-doc/basic.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/basic.rs
rename to tests/rustdoc-html/intra-doc/basic.rs
diff --git a/tests/rustdoc/intra-doc/builtin-macros.rs b/tests/rustdoc-html/intra-doc/builtin-macros.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/builtin-macros.rs
rename to tests/rustdoc-html/intra-doc/builtin-macros.rs
diff --git a/tests/rustdoc/intra-doc/crate-relative-assoc.rs b/tests/rustdoc-html/intra-doc/crate-relative-assoc.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/crate-relative-assoc.rs
rename to tests/rustdoc-html/intra-doc/crate-relative-assoc.rs
diff --git a/tests/rustdoc/intra-doc/crate-relative.rs b/tests/rustdoc-html/intra-doc/crate-relative.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/crate-relative.rs
rename to tests/rustdoc-html/intra-doc/crate-relative.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/additional_doc.rs b/tests/rustdoc-html/intra-doc/cross-crate/additional_doc.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/additional_doc.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/additional_doc.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/additional_doc.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/additional_doc.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/additional_doc.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/additional_doc.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/hidden.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/hidden.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/hidden.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/hidden.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/intra-doc-basic.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/intra-doc-basic.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/intra-doc-basic.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/intra-doc-basic.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/intra-link-cross-crate-crate.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/intra-link-cross-crate-crate.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/intra-link-cross-crate-crate.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/intra-link-cross-crate-crate.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/macro_inner.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/macro_inner.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/macro_inner.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/macro_inner.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/module.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/module.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/module.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/module.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/proc_macro.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/proc_macro.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/proc_macro.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/proc_macro.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/submodule-inner.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/submodule-inner.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/submodule-inner.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/submodule-inner.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/submodule-outer.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/submodule-outer.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/submodule-outer.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/submodule-outer.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/auxiliary/traits.rs b/tests/rustdoc-html/intra-doc/cross-crate/auxiliary/traits.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/auxiliary/traits.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/auxiliary/traits.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/basic.rs b/tests/rustdoc-html/intra-doc/cross-crate/basic.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/basic.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/basic.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/crate.rs b/tests/rustdoc-html/intra-doc/cross-crate/crate.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/crate.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/crate.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/hidden.rs b/tests/rustdoc-html/intra-doc/cross-crate/hidden.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/hidden.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/hidden.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/macro.rs b/tests/rustdoc-html/intra-doc/cross-crate/macro.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/macro.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/macro.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/module.rs b/tests/rustdoc-html/intra-doc/cross-crate/module.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/module.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/module.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/submodule-inner.rs b/tests/rustdoc-html/intra-doc/cross-crate/submodule-inner.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/submodule-inner.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/submodule-inner.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/submodule-outer.rs b/tests/rustdoc-html/intra-doc/cross-crate/submodule-outer.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/submodule-outer.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/submodule-outer.rs
diff --git a/tests/rustdoc/intra-doc/cross-crate/traits.rs b/tests/rustdoc-html/intra-doc/cross-crate/traits.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/cross-crate/traits.rs
rename to tests/rustdoc-html/intra-doc/cross-crate/traits.rs
diff --git a/tests/rustdoc-html/intra-doc/deprecated.rs b/tests/rustdoc-html/intra-doc/deprecated.rs
new file mode 100644
index 000000000000..6f8639593a2d
--- /dev/null
+++ b/tests/rustdoc-html/intra-doc/deprecated.rs
@@ -0,0 +1,12 @@
+//@ has deprecated/struct.A.html '//a[@href="{{channel}}/core/ops/range/struct.Range.html#structfield.start"]' 'start'
+//@ has deprecated/struct.B1.html '//a[@href="{{channel}}/std/io/error/enum.ErrorKind.html#variant.NotFound"]' 'not_found'
+//@ has deprecated/struct.B2.html '//a[@href="{{channel}}/std/io/error/enum.ErrorKind.html#variant.NotFound"]' 'not_found'
+
+#[deprecated = "[start][std::ops::Range::start]"]
+pub struct A;
+
+#[deprecated(since = "0.0.0", note = "[not_found][std::io::ErrorKind::NotFound]")]
+pub struct B1;
+
+#[deprecated(note = "[not_found][std::io::ErrorKind::NotFound]", since = "0.0.0")]
+pub struct B2;
diff --git a/tests/rustdoc/intra-doc/deps.rs b/tests/rustdoc-html/intra-doc/deps.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/deps.rs
rename to tests/rustdoc-html/intra-doc/deps.rs
diff --git a/tests/rustdoc/intra-doc/disambiguators-removed.rs b/tests/rustdoc-html/intra-doc/disambiguators-removed.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/disambiguators-removed.rs
rename to tests/rustdoc-html/intra-doc/disambiguators-removed.rs
diff --git a/tests/rustdoc/intra-doc/email-address.rs b/tests/rustdoc-html/intra-doc/email-address.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/email-address.rs
rename to tests/rustdoc-html/intra-doc/email-address.rs
diff --git a/tests/rustdoc/intra-doc/enum-self-82209.rs b/tests/rustdoc-html/intra-doc/enum-self-82209.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/enum-self-82209.rs
rename to tests/rustdoc-html/intra-doc/enum-self-82209.rs
diff --git a/tests/rustdoc/intra-doc/enum-struct-field.rs b/tests/rustdoc-html/intra-doc/enum-struct-field.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/enum-struct-field.rs
rename to tests/rustdoc-html/intra-doc/enum-struct-field.rs
diff --git a/tests/rustdoc/intra-doc/extern-builtin-type-impl.rs b/tests/rustdoc-html/intra-doc/extern-builtin-type-impl.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-builtin-type-impl.rs
rename to tests/rustdoc-html/intra-doc/extern-builtin-type-impl.rs
diff --git a/tests/rustdoc/intra-doc/extern-crate-only-used-in-link.rs b/tests/rustdoc-html/intra-doc/extern-crate-only-used-in-link.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-crate-only-used-in-link.rs
rename to tests/rustdoc-html/intra-doc/extern-crate-only-used-in-link.rs
diff --git a/tests/rustdoc/intra-doc/extern-crate.rs b/tests/rustdoc-html/intra-doc/extern-crate.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-crate.rs
rename to tests/rustdoc-html/intra-doc/extern-crate.rs
diff --git a/tests/rustdoc/intra-doc/extern-inherent-impl.rs b/tests/rustdoc-html/intra-doc/extern-inherent-impl.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-inherent-impl.rs
rename to tests/rustdoc-html/intra-doc/extern-inherent-impl.rs
diff --git a/tests/rustdoc/intra-doc/extern-reference-link.rs b/tests/rustdoc-html/intra-doc/extern-reference-link.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-reference-link.rs
rename to tests/rustdoc-html/intra-doc/extern-reference-link.rs
diff --git a/tests/rustdoc/intra-doc/extern-type.rs b/tests/rustdoc-html/intra-doc/extern-type.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/extern-type.rs
rename to tests/rustdoc-html/intra-doc/extern-type.rs
diff --git a/tests/rustdoc/intra-doc/external-traits.rs b/tests/rustdoc-html/intra-doc/external-traits.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/external-traits.rs
rename to tests/rustdoc-html/intra-doc/external-traits.rs
diff --git a/tests/rustdoc/intra-doc/field.rs b/tests/rustdoc-html/intra-doc/field.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/field.rs
rename to tests/rustdoc-html/intra-doc/field.rs
diff --git a/tests/rustdoc/intra-doc/filter-out-private.rs b/tests/rustdoc-html/intra-doc/filter-out-private.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/filter-out-private.rs
rename to tests/rustdoc-html/intra-doc/filter-out-private.rs
diff --git a/tests/rustdoc/intra-doc/generic-params.rs b/tests/rustdoc-html/intra-doc/generic-params.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/generic-params.rs
rename to tests/rustdoc-html/intra-doc/generic-params.rs
diff --git a/tests/rustdoc/intra-doc/generic-trait-impl.rs b/tests/rustdoc-html/intra-doc/generic-trait-impl.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/generic-trait-impl.rs
rename to tests/rustdoc-html/intra-doc/generic-trait-impl.rs
diff --git a/tests/rustdoc/intra-doc/ice-intra-doc-links-107995.rs b/tests/rustdoc-html/intra-doc/ice-intra-doc-links-107995.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/ice-intra-doc-links-107995.rs
rename to tests/rustdoc-html/intra-doc/ice-intra-doc-links-107995.rs
diff --git a/tests/rustdoc/intra-doc/in-bodies.rs b/tests/rustdoc-html/intra-doc/in-bodies.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/in-bodies.rs
rename to tests/rustdoc-html/intra-doc/in-bodies.rs
diff --git a/tests/rustdoc/intra-doc/inherent-associated-types.rs b/tests/rustdoc-html/intra-doc/inherent-associated-types.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/inherent-associated-types.rs
rename to tests/rustdoc-html/intra-doc/inherent-associated-types.rs
diff --git a/tests/rustdoc/intra-doc/intra-doc-link-method-trait-impl-72340.rs b/tests/rustdoc-html/intra-doc/intra-doc-link-method-trait-impl-72340.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/intra-doc-link-method-trait-impl-72340.rs
rename to tests/rustdoc-html/intra-doc/intra-doc-link-method-trait-impl-72340.rs
diff --git a/tests/rustdoc/intra-doc/libstd-re-export.rs b/tests/rustdoc-html/intra-doc/libstd-re-export.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/libstd-re-export.rs
rename to tests/rustdoc-html/intra-doc/libstd-re-export.rs
diff --git a/tests/rustdoc/intra-doc/link-in-footnotes-132208.rs b/tests/rustdoc-html/intra-doc/link-in-footnotes-132208.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/link-in-footnotes-132208.rs
rename to tests/rustdoc-html/intra-doc/link-in-footnotes-132208.rs
diff --git a/tests/rustdoc/intra-doc/link-same-name-different-disambiguator-108459.rs b/tests/rustdoc-html/intra-doc/link-same-name-different-disambiguator-108459.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/link-same-name-different-disambiguator-108459.rs
rename to tests/rustdoc-html/intra-doc/link-same-name-different-disambiguator-108459.rs
diff --git a/tests/rustdoc/intra-doc/link-to-proc-macro.rs b/tests/rustdoc-html/intra-doc/link-to-proc-macro.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/link-to-proc-macro.rs
rename to tests/rustdoc-html/intra-doc/link-to-proc-macro.rs
diff --git a/tests/rustdoc/intra-doc/macro-caching-144965.rs b/tests/rustdoc-html/intra-doc/macro-caching-144965.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/macro-caching-144965.rs
rename to tests/rustdoc-html/intra-doc/macro-caching-144965.rs
diff --git a/tests/rustdoc/intra-doc/macros-disambiguators.rs b/tests/rustdoc-html/intra-doc/macros-disambiguators.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/macros-disambiguators.rs
rename to tests/rustdoc-html/intra-doc/macros-disambiguators.rs
diff --git a/tests/rustdoc/intra-doc/mod-ambiguity.rs b/tests/rustdoc-html/intra-doc/mod-ambiguity.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/mod-ambiguity.rs
rename to tests/rustdoc-html/intra-doc/mod-ambiguity.rs
diff --git a/tests/rustdoc/intra-doc/mod-relative.rs b/tests/rustdoc-html/intra-doc/mod-relative.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/mod-relative.rs
rename to tests/rustdoc-html/intra-doc/mod-relative.rs
diff --git a/tests/rustdoc/intra-doc/module-scope-name-resolution-55364.rs b/tests/rustdoc-html/intra-doc/module-scope-name-resolution-55364.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/module-scope-name-resolution-55364.rs
rename to tests/rustdoc-html/intra-doc/module-scope-name-resolution-55364.rs
diff --git a/tests/rustdoc/intra-doc/nested-use.rs b/tests/rustdoc-html/intra-doc/nested-use.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/nested-use.rs
rename to tests/rustdoc-html/intra-doc/nested-use.rs
diff --git a/tests/rustdoc/intra-doc/no-doc-primitive.rs b/tests/rustdoc-html/intra-doc/no-doc-primitive.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/no-doc-primitive.rs
rename to tests/rustdoc-html/intra-doc/no-doc-primitive.rs
diff --git a/tests/rustdoc/intra-doc/non-path-primitives.rs b/tests/rustdoc-html/intra-doc/non-path-primitives.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/non-path-primitives.rs
rename to tests/rustdoc-html/intra-doc/non-path-primitives.rs
diff --git a/tests/rustdoc/intra-doc/prim-assoc.rs b/tests/rustdoc-html/intra-doc/prim-assoc.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-assoc.rs
rename to tests/rustdoc-html/intra-doc/prim-assoc.rs
diff --git a/tests/rustdoc/intra-doc/prim-associated-traits.rs b/tests/rustdoc-html/intra-doc/prim-associated-traits.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-associated-traits.rs
rename to tests/rustdoc-html/intra-doc/prim-associated-traits.rs
diff --git a/tests/rustdoc/intra-doc/prim-methods-external-core.rs b/tests/rustdoc-html/intra-doc/prim-methods-external-core.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-methods-external-core.rs
rename to tests/rustdoc-html/intra-doc/prim-methods-external-core.rs
diff --git a/tests/rustdoc/intra-doc/prim-methods-local.rs b/tests/rustdoc-html/intra-doc/prim-methods-local.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-methods-local.rs
rename to tests/rustdoc-html/intra-doc/prim-methods-local.rs
diff --git a/tests/rustdoc/intra-doc/prim-methods.rs b/tests/rustdoc-html/intra-doc/prim-methods.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-methods.rs
rename to tests/rustdoc-html/intra-doc/prim-methods.rs
diff --git a/tests/rustdoc/intra-doc/prim-precedence.rs b/tests/rustdoc-html/intra-doc/prim-precedence.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-precedence.rs
rename to tests/rustdoc-html/intra-doc/prim-precedence.rs
diff --git a/tests/rustdoc/intra-doc/prim-self.rs b/tests/rustdoc-html/intra-doc/prim-self.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/prim-self.rs
rename to tests/rustdoc-html/intra-doc/prim-self.rs
diff --git a/tests/rustdoc/intra-doc/primitive-disambiguators.rs b/tests/rustdoc-html/intra-doc/primitive-disambiguators.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/primitive-disambiguators.rs
rename to tests/rustdoc-html/intra-doc/primitive-disambiguators.rs
diff --git a/tests/rustdoc/intra-doc/primitive-non-default-impl.rs b/tests/rustdoc-html/intra-doc/primitive-non-default-impl.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/primitive-non-default-impl.rs
rename to tests/rustdoc-html/intra-doc/primitive-non-default-impl.rs
diff --git a/tests/rustdoc/intra-doc/private-failures-ignored.rs b/tests/rustdoc-html/intra-doc/private-failures-ignored.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/private-failures-ignored.rs
rename to tests/rustdoc-html/intra-doc/private-failures-ignored.rs
diff --git a/tests/rustdoc/intra-doc/private.rs b/tests/rustdoc-html/intra-doc/private.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/private.rs
rename to tests/rustdoc-html/intra-doc/private.rs
diff --git a/tests/rustdoc/intra-doc/proc-macro.rs b/tests/rustdoc-html/intra-doc/proc-macro.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/proc-macro.rs
rename to tests/rustdoc-html/intra-doc/proc-macro.rs
diff --git a/tests/rustdoc/intra-doc/pub-use.rs b/tests/rustdoc-html/intra-doc/pub-use.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/pub-use.rs
rename to tests/rustdoc-html/intra-doc/pub-use.rs
diff --git a/tests/rustdoc/intra-doc/raw-ident-self.rs b/tests/rustdoc-html/intra-doc/raw-ident-self.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/raw-ident-self.rs
rename to tests/rustdoc-html/intra-doc/raw-ident-self.rs
diff --git a/tests/rustdoc/intra-doc/reexport-additional-docs.rs b/tests/rustdoc-html/intra-doc/reexport-additional-docs.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/reexport-additional-docs.rs
rename to tests/rustdoc-html/intra-doc/reexport-additional-docs.rs
diff --git a/tests/rustdoc/intra-doc/same-name-different-crates-66159.rs b/tests/rustdoc-html/intra-doc/same-name-different-crates-66159.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/same-name-different-crates-66159.rs
rename to tests/rustdoc-html/intra-doc/same-name-different-crates-66159.rs
diff --git a/tests/rustdoc/intra-doc/self-cache.rs b/tests/rustdoc-html/intra-doc/self-cache.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/self-cache.rs
rename to tests/rustdoc-html/intra-doc/self-cache.rs
diff --git a/tests/rustdoc/intra-doc/self.rs b/tests/rustdoc-html/intra-doc/self.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/self.rs
rename to tests/rustdoc-html/intra-doc/self.rs
diff --git a/tests/rustdoc/intra-doc/trait-impl.rs b/tests/rustdoc-html/intra-doc/trait-impl.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/trait-impl.rs
rename to tests/rustdoc-html/intra-doc/trait-impl.rs
diff --git a/tests/rustdoc/intra-doc/trait-item.rs b/tests/rustdoc-html/intra-doc/trait-item.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/trait-item.rs
rename to tests/rustdoc-html/intra-doc/trait-item.rs
diff --git a/tests/rustdoc/intra-doc/true-false.rs b/tests/rustdoc-html/intra-doc/true-false.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/true-false.rs
rename to tests/rustdoc-html/intra-doc/true-false.rs
diff --git a/tests/rustdoc/intra-doc/type-alias-primitive.rs b/tests/rustdoc-html/intra-doc/type-alias-primitive.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/type-alias-primitive.rs
rename to tests/rustdoc-html/intra-doc/type-alias-primitive.rs
diff --git a/tests/rustdoc/intra-doc/type-alias.rs b/tests/rustdoc-html/intra-doc/type-alias.rs
similarity index 100%
rename from tests/rustdoc/intra-doc/type-alias.rs
rename to tests/rustdoc-html/intra-doc/type-alias.rs
diff --git a/tests/rustdoc/invalid$crate$name.rs b/tests/rustdoc-html/invalid$crate$name.rs
similarity index 100%
rename from tests/rustdoc/invalid$crate$name.rs
rename to tests/rustdoc-html/invalid$crate$name.rs
diff --git a/tests/rustdoc/item-desc-list-at-start.item-table.html b/tests/rustdoc-html/item-desc-list-at-start.item-table.html
similarity index 100%
rename from tests/rustdoc/item-desc-list-at-start.item-table.html
rename to tests/rustdoc-html/item-desc-list-at-start.item-table.html
diff --git a/tests/rustdoc/item-desc-list-at-start.rs b/tests/rustdoc-html/item-desc-list-at-start.rs
similarity index 100%
rename from tests/rustdoc/item-desc-list-at-start.rs
rename to tests/rustdoc-html/item-desc-list-at-start.rs
diff --git a/tests/rustdoc/jump-to-def/assoc-items.rs b/tests/rustdoc-html/jump-to-def/assoc-items.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/assoc-items.rs
rename to tests/rustdoc-html/jump-to-def/assoc-items.rs
diff --git a/tests/rustdoc/jump-to-def/assoc-types.rs b/tests/rustdoc-html/jump-to-def/assoc-types.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/assoc-types.rs
rename to tests/rustdoc-html/jump-to-def/assoc-types.rs
diff --git a/tests/rustdoc/jump-to-def/auxiliary/symbols.rs b/tests/rustdoc-html/jump-to-def/auxiliary/symbols.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/auxiliary/symbols.rs
rename to tests/rustdoc-html/jump-to-def/auxiliary/symbols.rs
diff --git a/tests/rustdoc/jump-to-def/derive-macro.rs b/tests/rustdoc-html/jump-to-def/derive-macro.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/derive-macro.rs
rename to tests/rustdoc-html/jump-to-def/derive-macro.rs
diff --git a/tests/rustdoc/jump-to-def/doc-links-calls.rs b/tests/rustdoc-html/jump-to-def/doc-links-calls.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/doc-links-calls.rs
rename to tests/rustdoc-html/jump-to-def/doc-links-calls.rs
diff --git a/tests/rustdoc/jump-to-def/doc-links.rs b/tests/rustdoc-html/jump-to-def/doc-links.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/doc-links.rs
rename to tests/rustdoc-html/jump-to-def/doc-links.rs
diff --git a/tests/rustdoc/jump-to-def/macro.rs b/tests/rustdoc-html/jump-to-def/macro.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/macro.rs
rename to tests/rustdoc-html/jump-to-def/macro.rs
diff --git a/tests/rustdoc/jump-to-def/no-body-items.rs b/tests/rustdoc-html/jump-to-def/no-body-items.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/no-body-items.rs
rename to tests/rustdoc-html/jump-to-def/no-body-items.rs
diff --git a/tests/rustdoc/jump-to-def/non-local-method.rs b/tests/rustdoc-html/jump-to-def/non-local-method.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/non-local-method.rs
rename to tests/rustdoc-html/jump-to-def/non-local-method.rs
diff --git a/tests/rustdoc/jump-to-def/patterns.rs b/tests/rustdoc-html/jump-to-def/patterns.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/patterns.rs
rename to tests/rustdoc-html/jump-to-def/patterns.rs
diff --git a/tests/rustdoc/jump-to-def/prelude-types.rs b/tests/rustdoc-html/jump-to-def/prelude-types.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/prelude-types.rs
rename to tests/rustdoc-html/jump-to-def/prelude-types.rs
diff --git a/tests/rustdoc/jump-to-def/shebang.rs b/tests/rustdoc-html/jump-to-def/shebang.rs
similarity index 100%
rename from tests/rustdoc/jump-to-def/shebang.rs
rename to tests/rustdoc-html/jump-to-def/shebang.rs
diff --git a/tests/rustdoc/keyword.rs b/tests/rustdoc-html/keyword.rs
similarity index 100%
rename from tests/rustdoc/keyword.rs
rename to tests/rustdoc-html/keyword.rs
diff --git a/tests/rustdoc/lifetime-name.rs b/tests/rustdoc-html/lifetime-name.rs
similarity index 100%
rename from tests/rustdoc/lifetime-name.rs
rename to tests/rustdoc-html/lifetime-name.rs
diff --git a/tests/rustdoc/line-breaks.rs b/tests/rustdoc-html/line-breaks.rs
similarity index 100%
rename from tests/rustdoc/line-breaks.rs
rename to tests/rustdoc-html/line-breaks.rs
diff --git a/tests/rustdoc/link-on-path-with-generics.rs b/tests/rustdoc-html/link-on-path-with-generics.rs
similarity index 100%
rename from tests/rustdoc/link-on-path-with-generics.rs
rename to tests/rustdoc-html/link-on-path-with-generics.rs
diff --git a/tests/rustdoc/link-title-escape.rs b/tests/rustdoc-html/link-title-escape.rs
similarity index 100%
rename from tests/rustdoc/link-title-escape.rs
rename to tests/rustdoc-html/link-title-escape.rs
diff --git a/tests/rustdoc/links-in-headings.rs b/tests/rustdoc-html/links-in-headings.rs
similarity index 100%
rename from tests/rustdoc/links-in-headings.rs
rename to tests/rustdoc-html/links-in-headings.rs
diff --git a/tests/rustdoc/logo-class-default.rs b/tests/rustdoc-html/logo-class-default.rs
similarity index 100%
rename from tests/rustdoc/logo-class-default.rs
rename to tests/rustdoc-html/logo-class-default.rs
diff --git a/tests/rustdoc/logo-class-rust.rs b/tests/rustdoc-html/logo-class-rust.rs
similarity index 100%
rename from tests/rustdoc/logo-class-rust.rs
rename to tests/rustdoc-html/logo-class-rust.rs
diff --git a/tests/rustdoc/logo-class.rs b/tests/rustdoc-html/logo-class.rs
similarity index 100%
rename from tests/rustdoc/logo-class.rs
rename to tests/rustdoc-html/logo-class.rs
diff --git a/tests/rustdoc/macro-expansion/field-followed-by-exclamation.rs b/tests/rustdoc-html/macro-expansion/field-followed-by-exclamation.rs
similarity index 100%
rename from tests/rustdoc/macro-expansion/field-followed-by-exclamation.rs
rename to tests/rustdoc-html/macro-expansion/field-followed-by-exclamation.rs
diff --git a/tests/rustdoc/macro-expansion/type-macro-expansion.rs b/tests/rustdoc-html/macro-expansion/type-macro-expansion.rs
similarity index 100%
rename from tests/rustdoc/macro-expansion/type-macro-expansion.rs
rename to tests/rustdoc-html/macro-expansion/type-macro-expansion.rs
diff --git a/tests/rustdoc/macro/auxiliary/external-macro-src.rs b/tests/rustdoc-html/macro/auxiliary/external-macro-src.rs
similarity index 100%
rename from tests/rustdoc/macro/auxiliary/external-macro-src.rs
rename to tests/rustdoc-html/macro/auxiliary/external-macro-src.rs
diff --git a/tests/rustdoc/macro/auxiliary/issue-99221-aux.rs b/tests/rustdoc-html/macro/auxiliary/issue-99221-aux.rs
similarity index 100%
rename from tests/rustdoc/macro/auxiliary/issue-99221-aux.rs
rename to tests/rustdoc-html/macro/auxiliary/issue-99221-aux.rs
diff --git a/tests/rustdoc/macro/auxiliary/macro_pub_in_module.rs b/tests/rustdoc-html/macro/auxiliary/macro_pub_in_module.rs
similarity index 100%
rename from tests/rustdoc/macro/auxiliary/macro_pub_in_module.rs
rename to tests/rustdoc-html/macro/auxiliary/macro_pub_in_module.rs
diff --git a/tests/rustdoc/macro/auxiliary/one-line-expand.rs b/tests/rustdoc-html/macro/auxiliary/one-line-expand.rs
similarity index 100%
rename from tests/rustdoc/macro/auxiliary/one-line-expand.rs
rename to tests/rustdoc-html/macro/auxiliary/one-line-expand.rs
diff --git a/tests/rustdoc/macro/auxiliary/pub-use-extern-macros.rs b/tests/rustdoc-html/macro/auxiliary/pub-use-extern-macros.rs
similarity index 100%
rename from tests/rustdoc/macro/auxiliary/pub-use-extern-macros.rs
rename to tests/rustdoc-html/macro/auxiliary/pub-use-extern-macros.rs
diff --git a/tests/rustdoc/macro/compiler-derive-proc-macro.rs b/tests/rustdoc-html/macro/compiler-derive-proc-macro.rs
similarity index 100%
rename from tests/rustdoc/macro/compiler-derive-proc-macro.rs
rename to tests/rustdoc-html/macro/compiler-derive-proc-macro.rs
diff --git a/tests/rustdoc/macro/const-rendering-macros-33302.rs b/tests/rustdoc-html/macro/const-rendering-macros-33302.rs
similarity index 100%
rename from tests/rustdoc/macro/const-rendering-macros-33302.rs
rename to tests/rustdoc-html/macro/const-rendering-macros-33302.rs
diff --git a/tests/rustdoc/macro/decl_macro.rs b/tests/rustdoc-html/macro/decl_macro.rs
similarity index 100%
rename from tests/rustdoc/macro/decl_macro.rs
rename to tests/rustdoc-html/macro/decl_macro.rs
diff --git a/tests/rustdoc/macro/decl_macro_priv.rs b/tests/rustdoc-html/macro/decl_macro_priv.rs
similarity index 100%
rename from tests/rustdoc/macro/decl_macro_priv.rs
rename to tests/rustdoc-html/macro/decl_macro_priv.rs
diff --git a/tests/rustdoc/macro/doc-proc-macro.rs b/tests/rustdoc-html/macro/doc-proc-macro.rs
similarity index 100%
rename from tests/rustdoc/macro/doc-proc-macro.rs
rename to tests/rustdoc-html/macro/doc-proc-macro.rs
diff --git a/tests/rustdoc/macro/external-macro-src.rs b/tests/rustdoc-html/macro/external-macro-src.rs
similarity index 100%
rename from tests/rustdoc/macro/external-macro-src.rs
rename to tests/rustdoc-html/macro/external-macro-src.rs
diff --git a/tests/rustdoc/macro/macro-const-display-115295.rs b/tests/rustdoc-html/macro/macro-const-display-115295.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-const-display-115295.rs
rename to tests/rustdoc-html/macro/macro-const-display-115295.rs
diff --git a/tests/rustdoc/macro/macro-doc-comment-23812.rs b/tests/rustdoc-html/macro/macro-doc-comment-23812.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-doc-comment-23812.rs
rename to tests/rustdoc-html/macro/macro-doc-comment-23812.rs
diff --git a/tests/rustdoc/macro/macro-export-crate-root-108231.rs b/tests/rustdoc-html/macro/macro-export-crate-root-108231.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-export-crate-root-108231.rs
rename to tests/rustdoc-html/macro/macro-export-crate-root-108231.rs
diff --git a/tests/rustdoc/macro/macro-generated-macro.macro_linebreak_pre.html b/tests/rustdoc-html/macro/macro-generated-macro.macro_linebreak_pre.html
similarity index 100%
rename from tests/rustdoc/macro/macro-generated-macro.macro_linebreak_pre.html
rename to tests/rustdoc-html/macro/macro-generated-macro.macro_linebreak_pre.html
diff --git a/tests/rustdoc/macro/macro-generated-macro.macro_morestuff_pre.html b/tests/rustdoc-html/macro/macro-generated-macro.macro_morestuff_pre.html
similarity index 100%
rename from tests/rustdoc/macro/macro-generated-macro.macro_morestuff_pre.html
rename to tests/rustdoc-html/macro/macro-generated-macro.macro_morestuff_pre.html
diff --git a/tests/rustdoc/macro/macro-generated-macro.rs b/tests/rustdoc-html/macro/macro-generated-macro.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-generated-macro.rs
rename to tests/rustdoc-html/macro/macro-generated-macro.rs
diff --git a/tests/rustdoc/macro/macro-higher-kinded-function.rs b/tests/rustdoc-html/macro/macro-higher-kinded-function.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-higher-kinded-function.rs
rename to tests/rustdoc-html/macro/macro-higher-kinded-function.rs
diff --git a/tests/rustdoc/macro/macro-ice-16019.rs b/tests/rustdoc-html/macro/macro-ice-16019.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-ice-16019.rs
rename to tests/rustdoc-html/macro/macro-ice-16019.rs
diff --git a/tests/rustdoc/macro/macro-in-async-block.rs b/tests/rustdoc-html/macro/macro-in-async-block.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-in-async-block.rs
rename to tests/rustdoc-html/macro/macro-in-async-block.rs
diff --git a/tests/rustdoc/macro/macro-in-closure.rs b/tests/rustdoc-html/macro/macro-in-closure.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-in-closure.rs
rename to tests/rustdoc-html/macro/macro-in-closure.rs
diff --git a/tests/rustdoc/macro/macro-indirect-use.rs b/tests/rustdoc-html/macro/macro-indirect-use.rs
similarity index 100%
rename from tests/rustdoc/macro/macro-indirect-use.rs
rename to tests/rustdoc-html/macro/macro-indirect-use.rs
diff --git a/tests/rustdoc/macro/macro_expansion.rs b/tests/rustdoc-html/macro/macro_expansion.rs
similarity index 100%
rename from tests/rustdoc/macro/macro_expansion.rs
rename to tests/rustdoc-html/macro/macro_expansion.rs
diff --git a/tests/rustdoc/macro/macro_pub_in_module.rs b/tests/rustdoc-html/macro/macro_pub_in_module.rs
similarity index 97%
rename from tests/rustdoc/macro/macro_pub_in_module.rs
rename to tests/rustdoc-html/macro/macro_pub_in_module.rs
index 2dce73c2cf26..a4b39e20d126 100644
--- a/tests/rustdoc/macro/macro_pub_in_module.rs
+++ b/tests/rustdoc-html/macro/macro_pub_in_module.rs
@@ -33,7 +33,7 @@ pub mod inner {
     // Make sure the logic is not affected by re-exports.
     mod unrenamed {
         //@ !has krate/macro.unrenamed.html
-        #[rustc_macro_transparency = "semitransparent"]
+        #[rustc_macro_transparency = "semiopaque"]
         pub macro unrenamed() {}
     }
     //@ has krate/inner/macro.unrenamed.html
diff --git a/tests/rustdoc/macro/macro_rules-matchers.rs b/tests/rustdoc-html/macro/macro_rules-matchers.rs
similarity index 100%
rename from tests/rustdoc/macro/macro_rules-matchers.rs
rename to tests/rustdoc-html/macro/macro_rules-matchers.rs
diff --git a/tests/rustdoc/macro/macros.rs b/tests/rustdoc-html/macro/macros.rs
similarity index 100%
rename from tests/rustdoc/macro/macros.rs
rename to tests/rustdoc-html/macro/macros.rs
diff --git a/tests/rustdoc/macro/multiple-macro-rules-w-same-name-99221.rs b/tests/rustdoc-html/macro/multiple-macro-rules-w-same-name-99221.rs
similarity index 100%
rename from tests/rustdoc/macro/multiple-macro-rules-w-same-name-99221.rs
rename to tests/rustdoc-html/macro/multiple-macro-rules-w-same-name-99221.rs
diff --git a/tests/rustdoc/macro/multiple-macro-rules-w-same-name-submodule-99221.rs b/tests/rustdoc-html/macro/multiple-macro-rules-w-same-name-submodule-99221.rs
similarity index 100%
rename from tests/rustdoc/macro/multiple-macro-rules-w-same-name-submodule-99221.rs
rename to tests/rustdoc-html/macro/multiple-macro-rules-w-same-name-submodule-99221.rs
diff --git a/tests/rustdoc/macro/one-line-expand.rs b/tests/rustdoc-html/macro/one-line-expand.rs
similarity index 100%
rename from tests/rustdoc/macro/one-line-expand.rs
rename to tests/rustdoc-html/macro/one-line-expand.rs
diff --git a/tests/rustdoc/macro/proc-macro.rs b/tests/rustdoc-html/macro/proc-macro.rs
similarity index 100%
rename from tests/rustdoc/macro/proc-macro.rs
rename to tests/rustdoc-html/macro/proc-macro.rs
diff --git a/tests/rustdoc/macro/pub-use-extern-macros.rs b/tests/rustdoc-html/macro/pub-use-extern-macros.rs
similarity index 100%
rename from tests/rustdoc/macro/pub-use-extern-macros.rs
rename to tests/rustdoc-html/macro/pub-use-extern-macros.rs
diff --git a/tests/rustdoc/macro/rustc-macro-crate.rs b/tests/rustdoc-html/macro/rustc-macro-crate.rs
similarity index 100%
rename from tests/rustdoc/macro/rustc-macro-crate.rs
rename to tests/rustdoc-html/macro/rustc-macro-crate.rs
diff --git a/tests/rustdoc/markdown-60482.rs b/tests/rustdoc-html/markdown-60482.rs
similarity index 100%
rename from tests/rustdoc/markdown-60482.rs
rename to tests/rustdoc-html/markdown-60482.rs
diff --git a/tests/rustdoc/markdown-table-escape-pipe-27862.rs b/tests/rustdoc-html/markdown-table-escape-pipe-27862.rs
similarity index 100%
rename from tests/rustdoc/markdown-table-escape-pipe-27862.rs
rename to tests/rustdoc-html/markdown-table-escape-pipe-27862.rs
diff --git a/tests/rustdoc/masked.rs b/tests/rustdoc-html/masked.rs
similarity index 100%
rename from tests/rustdoc/masked.rs
rename to tests/rustdoc-html/masked.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/cargo-transitive-read-write/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/cargo-transitive-read-write/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/romeo.rs b/tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/romeo.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/romeo.rs
rename to tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/romeo.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/indigo.rs b/tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/indigo.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/kitchen-sink-separate-dirs/indigo.rs
rename to tests/rustdoc-html/merge-cross-crate-info/kitchen-sink-separate-dirs/indigo.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-separate/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-separate/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-separate/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-separate/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-separate/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-separate/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-separate/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/no-merge-write-anyway/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/no-merge-write-anyway/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-include/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-include/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-include/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-include/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-include/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-include/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-include/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite-but-separate/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite-but-separate/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/overwrite/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/overwrite/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/overwrite/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/overwrite/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/single-crate-finalize/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/single-crate-finalize/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/single-crate-finalize/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/single-crate-finalize/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/single-crate-read-write/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/single-crate-read-write/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/single-crate-read-write/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/single-crate-read-write/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/single-crate-write-anyway/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/single-crate-write-anyway/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/single-crate-write-anyway/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/single-crate-write-anyway/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/single-merge-none-useless-write/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/single-merge-none-useless-write/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/single-merge-none-useless-write/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/single-merge-none-useless-write/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-finalize/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-finalize/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-finalize/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-finalize/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-finalize/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-finalize/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-finalize/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-none/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-none/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-none/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-none/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-none/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-none/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-none/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-merge-read-write/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-merge-read-write/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-no-info/auxiliary/quebec.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/auxiliary/quebec.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-no-info/auxiliary/quebec.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/auxiliary/quebec.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-no-info/auxiliary/tango.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/auxiliary/tango.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-no-info/auxiliary/tango.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/auxiliary/tango.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/transitive-no-info/sierra.rs b/tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/sierra.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/transitive-no-info/sierra.rs
rename to tests/rustdoc-html/merge-cross-crate-info/transitive-no-info/sierra.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/two-separate-out-dir/auxiliary/foxtrot.rs b/tests/rustdoc-html/merge-cross-crate-info/two-separate-out-dir/auxiliary/foxtrot.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/two-separate-out-dir/auxiliary/foxtrot.rs
rename to tests/rustdoc-html/merge-cross-crate-info/two-separate-out-dir/auxiliary/foxtrot.rs
diff --git a/tests/rustdoc/merge-cross-crate-info/two-separate-out-dir/echo.rs b/tests/rustdoc-html/merge-cross-crate-info/two-separate-out-dir/echo.rs
similarity index 100%
rename from tests/rustdoc/merge-cross-crate-info/two-separate-out-dir/echo.rs
rename to tests/rustdoc-html/merge-cross-crate-info/two-separate-out-dir/echo.rs
diff --git a/tests/rustdoc/method-list.rs b/tests/rustdoc-html/method-list.rs
similarity index 100%
rename from tests/rustdoc/method-list.rs
rename to tests/rustdoc-html/method-list.rs
diff --git a/tests/rustdoc/mixing-doc-comments-and-attrs.S1_top-doc.html b/tests/rustdoc-html/mixing-doc-comments-and-attrs.S1_top-doc.html
similarity index 100%
rename from tests/rustdoc/mixing-doc-comments-and-attrs.S1_top-doc.html
rename to tests/rustdoc-html/mixing-doc-comments-and-attrs.S1_top-doc.html
diff --git a/tests/rustdoc/mixing-doc-comments-and-attrs.S2_top-doc.html b/tests/rustdoc-html/mixing-doc-comments-and-attrs.S2_top-doc.html
similarity index 100%
rename from tests/rustdoc/mixing-doc-comments-and-attrs.S2_top-doc.html
rename to tests/rustdoc-html/mixing-doc-comments-and-attrs.S2_top-doc.html
diff --git a/tests/rustdoc/mixing-doc-comments-and-attrs.S3_top-doc.html b/tests/rustdoc-html/mixing-doc-comments-and-attrs.S3_top-doc.html
similarity index 100%
rename from tests/rustdoc/mixing-doc-comments-and-attrs.S3_top-doc.html
rename to tests/rustdoc-html/mixing-doc-comments-and-attrs.S3_top-doc.html
diff --git a/tests/rustdoc/mixing-doc-comments-and-attrs.rs b/tests/rustdoc-html/mixing-doc-comments-and-attrs.rs
similarity index 100%
rename from tests/rustdoc/mixing-doc-comments-and-attrs.rs
rename to tests/rustdoc-html/mixing-doc-comments-and-attrs.rs
diff --git a/tests/rustdoc/mod-stackoverflow.rs b/tests/rustdoc-html/mod-stackoverflow.rs
similarity index 100%
rename from tests/rustdoc/mod-stackoverflow.rs
rename to tests/rustdoc-html/mod-stackoverflow.rs
diff --git a/tests/rustdoc/multiple-foreigns-w-same-name-99734.rs b/tests/rustdoc-html/multiple-foreigns-w-same-name-99734.rs
similarity index 100%
rename from tests/rustdoc/multiple-foreigns-w-same-name-99734.rs
rename to tests/rustdoc-html/multiple-foreigns-w-same-name-99734.rs
diff --git a/tests/rustdoc/multiple-import-levels.rs b/tests/rustdoc-html/multiple-import-levels.rs
similarity index 100%
rename from tests/rustdoc/multiple-import-levels.rs
rename to tests/rustdoc-html/multiple-import-levels.rs
diff --git a/tests/rustdoc/multiple-mods-w-same-name-99734.rs b/tests/rustdoc-html/multiple-mods-w-same-name-99734.rs
similarity index 100%
rename from tests/rustdoc/multiple-mods-w-same-name-99734.rs
rename to tests/rustdoc-html/multiple-mods-w-same-name-99734.rs
diff --git a/tests/rustdoc/multiple-mods-w-same-name-doc-inline-83375.rs b/tests/rustdoc-html/multiple-mods-w-same-name-doc-inline-83375.rs
similarity index 100%
rename from tests/rustdoc/multiple-mods-w-same-name-doc-inline-83375.rs
rename to tests/rustdoc-html/multiple-mods-w-same-name-doc-inline-83375.rs
diff --git a/tests/rustdoc/multiple-mods-w-same-name-doc-inline-last-item-83375.rs b/tests/rustdoc-html/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
similarity index 100%
rename from tests/rustdoc/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
rename to tests/rustdoc-html/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
diff --git a/tests/rustdoc/multiple-structs-w-same-name-99221.rs b/tests/rustdoc-html/multiple-structs-w-same-name-99221.rs
similarity index 100%
rename from tests/rustdoc/multiple-structs-w-same-name-99221.rs
rename to tests/rustdoc-html/multiple-structs-w-same-name-99221.rs
diff --git a/tests/rustdoc/mut-params.rs b/tests/rustdoc-html/mut-params.rs
similarity index 100%
rename from tests/rustdoc/mut-params.rs
rename to tests/rustdoc-html/mut-params.rs
diff --git a/tests/rustdoc/namespaces.rs b/tests/rustdoc-html/namespaces.rs
similarity index 100%
rename from tests/rustdoc/namespaces.rs
rename to tests/rustdoc-html/namespaces.rs
diff --git a/tests/rustdoc/nested-items-issue-111415.rs b/tests/rustdoc-html/nested-items-issue-111415.rs
similarity index 100%
rename from tests/rustdoc/nested-items-issue-111415.rs
rename to tests/rustdoc-html/nested-items-issue-111415.rs
diff --git a/tests/rustdoc/nested-modules.rs b/tests/rustdoc-html/nested-modules.rs
similarity index 100%
rename from tests/rustdoc/nested-modules.rs
rename to tests/rustdoc-html/nested-modules.rs
diff --git a/tests/rustdoc/no-run-still-checks-lints.rs b/tests/rustdoc-html/no-run-still-checks-lints.rs
similarity index 100%
rename from tests/rustdoc/no-run-still-checks-lints.rs
rename to tests/rustdoc-html/no-run-still-checks-lints.rs
diff --git a/tests/rustdoc/no-stack-overflow-25295.rs b/tests/rustdoc-html/no-stack-overflow-25295.rs
similarity index 100%
rename from tests/rustdoc/no-stack-overflow-25295.rs
rename to tests/rustdoc-html/no-stack-overflow-25295.rs
diff --git a/tests/rustdoc/no-unit-struct-field.rs b/tests/rustdoc-html/no-unit-struct-field.rs
similarity index 100%
rename from tests/rustdoc/no-unit-struct-field.rs
rename to tests/rustdoc-html/no-unit-struct-field.rs
diff --git a/tests/rustdoc/non_lifetime_binders.rs b/tests/rustdoc-html/non_lifetime_binders.rs
similarity index 100%
rename from tests/rustdoc/non_lifetime_binders.rs
rename to tests/rustdoc-html/non_lifetime_binders.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-mut_t_is_not_an_iterator.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait-mut_t_is_not_an_iterator.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-mut_t_is_not_an_iterator.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-mut_t_is_not_an_iterator.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-mut_t_is_not_ref_t.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait-mut_t_is_not_ref_t.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-mut_t_is_not_ref_t.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-mut_t_is_not_ref_t.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-negative.negative.html b/tests/rustdoc-html/notable-trait/doc-notable_trait-negative.negative.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-negative.negative.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-negative.negative.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-negative.positive.html b/tests/rustdoc-html/notable-trait/doc-notable_trait-negative.positive.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-negative.positive.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-negative.positive.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-negative.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait-negative.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-negative.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-negative.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-slice.bare_fn_matches.html b/tests/rustdoc-html/notable-trait/doc-notable_trait-slice.bare_fn_matches.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-slice.bare_fn_matches.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-slice.bare_fn_matches.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait-slice.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait-slice.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait-slice.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait-slice.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait.bare-fn.html b/tests/rustdoc-html/notable-trait/doc-notable_trait.bare-fn.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait.bare-fn.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait.bare-fn.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait.rs
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait.some-struct-new.html b/tests/rustdoc-html/notable-trait/doc-notable_trait.some-struct-new.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait.some-struct-new.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait.some-struct-new.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait.wrap-me.html b/tests/rustdoc-html/notable-trait/doc-notable_trait.wrap-me.html
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait.wrap-me.html
rename to tests/rustdoc-html/notable-trait/doc-notable_trait.wrap-me.html
diff --git a/tests/rustdoc/notable-trait/doc-notable_trait_box_is_not_an_iterator.rs b/tests/rustdoc-html/notable-trait/doc-notable_trait_box_is_not_an_iterator.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/doc-notable_trait_box_is_not_an_iterator.rs
rename to tests/rustdoc-html/notable-trait/doc-notable_trait_box_is_not_an_iterator.rs
diff --git a/tests/rustdoc/notable-trait/notable-trait-generics.rs b/tests/rustdoc-html/notable-trait/notable-trait-generics.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/notable-trait-generics.rs
rename to tests/rustdoc-html/notable-trait/notable-trait-generics.rs
diff --git a/tests/rustdoc/notable-trait/spotlight-from-dependency.odd.html b/tests/rustdoc-html/notable-trait/spotlight-from-dependency.odd.html
similarity index 100%
rename from tests/rustdoc/notable-trait/spotlight-from-dependency.odd.html
rename to tests/rustdoc-html/notable-trait/spotlight-from-dependency.odd.html
diff --git a/tests/rustdoc/notable-trait/spotlight-from-dependency.rs b/tests/rustdoc-html/notable-trait/spotlight-from-dependency.rs
similarity index 100%
rename from tests/rustdoc/notable-trait/spotlight-from-dependency.rs
rename to tests/rustdoc-html/notable-trait/spotlight-from-dependency.rs
diff --git a/tests/rustdoc/nul-error.rs b/tests/rustdoc-html/nul-error.rs
similarity index 100%
rename from tests/rustdoc/nul-error.rs
rename to tests/rustdoc-html/nul-error.rs
diff --git a/tests/rustdoc/playground-arg.rs b/tests/rustdoc-html/playground-arg.rs
similarity index 100%
rename from tests/rustdoc/playground-arg.rs
rename to tests/rustdoc-html/playground-arg.rs
diff --git a/tests/rustdoc/playground-empty.rs b/tests/rustdoc-html/playground-empty.rs
similarity index 100%
rename from tests/rustdoc/playground-empty.rs
rename to tests/rustdoc-html/playground-empty.rs
diff --git a/tests/rustdoc/playground-none.rs b/tests/rustdoc-html/playground-none.rs
similarity index 100%
rename from tests/rustdoc/playground-none.rs
rename to tests/rustdoc-html/playground-none.rs
diff --git a/tests/rustdoc/playground-syntax-error.rs b/tests/rustdoc-html/playground-syntax-error.rs
similarity index 100%
rename from tests/rustdoc/playground-syntax-error.rs
rename to tests/rustdoc-html/playground-syntax-error.rs
diff --git a/tests/rustdoc/playground.rs b/tests/rustdoc-html/playground.rs
similarity index 100%
rename from tests/rustdoc/playground.rs
rename to tests/rustdoc-html/playground.rs
diff --git a/tests/rustdoc/primitive/auxiliary/issue-15318.rs b/tests/rustdoc-html/primitive/auxiliary/issue-15318.rs
similarity index 100%
rename from tests/rustdoc/primitive/auxiliary/issue-15318.rs
rename to tests/rustdoc-html/primitive/auxiliary/issue-15318.rs
diff --git a/tests/rustdoc/primitive/auxiliary/primitive-doc.rs b/tests/rustdoc-html/primitive/auxiliary/primitive-doc.rs
similarity index 100%
rename from tests/rustdoc/primitive/auxiliary/primitive-doc.rs
rename to tests/rustdoc-html/primitive/auxiliary/primitive-doc.rs
diff --git a/tests/rustdoc/primitive/cross-crate-primitive-doc.rs b/tests/rustdoc-html/primitive/cross-crate-primitive-doc.rs
similarity index 100%
rename from tests/rustdoc/primitive/cross-crate-primitive-doc.rs
rename to tests/rustdoc-html/primitive/cross-crate-primitive-doc.rs
diff --git a/tests/rustdoc/primitive/no_std-primitive.rs b/tests/rustdoc-html/primitive/no_std-primitive.rs
similarity index 100%
rename from tests/rustdoc/primitive/no_std-primitive.rs
rename to tests/rustdoc-html/primitive/no_std-primitive.rs
diff --git a/tests/rustdoc/primitive/no_std.rs b/tests/rustdoc-html/primitive/no_std.rs
similarity index 100%
rename from tests/rustdoc/primitive/no_std.rs
rename to tests/rustdoc-html/primitive/no_std.rs
diff --git a/tests/rustdoc/primitive/primitive-generic-impl.rs b/tests/rustdoc-html/primitive/primitive-generic-impl.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-generic-impl.rs
rename to tests/rustdoc-html/primitive/primitive-generic-impl.rs
diff --git a/tests/rustdoc/primitive/primitive-link.rs b/tests/rustdoc-html/primitive/primitive-link.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-link.rs
rename to tests/rustdoc-html/primitive/primitive-link.rs
diff --git a/tests/rustdoc/primitive/primitive-raw-pointer-dox-15318-3.rs b/tests/rustdoc-html/primitive/primitive-raw-pointer-dox-15318-3.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-raw-pointer-dox-15318-3.rs
rename to tests/rustdoc-html/primitive/primitive-raw-pointer-dox-15318-3.rs
diff --git a/tests/rustdoc/primitive/primitive-raw-pointer-link-15318.rs b/tests/rustdoc-html/primitive/primitive-raw-pointer-link-15318.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-raw-pointer-link-15318.rs
rename to tests/rustdoc-html/primitive/primitive-raw-pointer-link-15318.rs
diff --git a/tests/rustdoc/primitive/primitive-raw-pointer-link-no-inlined-15318-2.rs b/tests/rustdoc-html/primitive/primitive-raw-pointer-link-no-inlined-15318-2.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-raw-pointer-link-no-inlined-15318-2.rs
rename to tests/rustdoc-html/primitive/primitive-raw-pointer-link-no-inlined-15318-2.rs
diff --git a/tests/rustdoc/primitive/primitive-reference.rs b/tests/rustdoc-html/primitive/primitive-reference.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-reference.rs
rename to tests/rustdoc-html/primitive/primitive-reference.rs
diff --git a/tests/rustdoc/primitive/primitive-slice-auto-trait.rs b/tests/rustdoc-html/primitive/primitive-slice-auto-trait.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-slice-auto-trait.rs
rename to tests/rustdoc-html/primitive/primitive-slice-auto-trait.rs
diff --git a/tests/rustdoc/primitive/primitive-tuple-auto-trait.rs b/tests/rustdoc-html/primitive/primitive-tuple-auto-trait.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-tuple-auto-trait.rs
rename to tests/rustdoc-html/primitive/primitive-tuple-auto-trait.rs
diff --git a/tests/rustdoc/primitive/primitive-tuple-variadic.rs b/tests/rustdoc-html/primitive/primitive-tuple-variadic.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-tuple-variadic.rs
rename to tests/rustdoc-html/primitive/primitive-tuple-variadic.rs
diff --git a/tests/rustdoc/primitive/primitive-unit-auto-trait.rs b/tests/rustdoc-html/primitive/primitive-unit-auto-trait.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive-unit-auto-trait.rs
rename to tests/rustdoc-html/primitive/primitive-unit-auto-trait.rs
diff --git a/tests/rustdoc/primitive/primitive.rs b/tests/rustdoc-html/primitive/primitive.rs
similarity index 100%
rename from tests/rustdoc/primitive/primitive.rs
rename to tests/rustdoc-html/primitive/primitive.rs
diff --git a/tests/rustdoc/primitive/search-index-primitive-inherent-method-23511.rs b/tests/rustdoc-html/primitive/search-index-primitive-inherent-method-23511.rs
similarity index 100%
rename from tests/rustdoc/primitive/search-index-primitive-inherent-method-23511.rs
rename to tests/rustdoc-html/primitive/search-index-primitive-inherent-method-23511.rs
diff --git a/tests/rustdoc/private/doc-hidden-private-67851-both.rs b/tests/rustdoc-html/private/doc-hidden-private-67851-both.rs
similarity index 100%
rename from tests/rustdoc/private/doc-hidden-private-67851-both.rs
rename to tests/rustdoc-html/private/doc-hidden-private-67851-both.rs
diff --git a/tests/rustdoc/private/doc-hidden-private-67851-hidden.rs b/tests/rustdoc-html/private/doc-hidden-private-67851-hidden.rs
similarity index 100%
rename from tests/rustdoc/private/doc-hidden-private-67851-hidden.rs
rename to tests/rustdoc-html/private/doc-hidden-private-67851-hidden.rs
diff --git a/tests/rustdoc/private/doc-hidden-private-67851-neither.rs b/tests/rustdoc-html/private/doc-hidden-private-67851-neither.rs
similarity index 100%
rename from tests/rustdoc/private/doc-hidden-private-67851-neither.rs
rename to tests/rustdoc-html/private/doc-hidden-private-67851-neither.rs
diff --git a/tests/rustdoc/private/doc-hidden-private-67851-private.rs b/tests/rustdoc-html/private/doc-hidden-private-67851-private.rs
similarity index 100%
rename from tests/rustdoc/private/doc-hidden-private-67851-private.rs
rename to tests/rustdoc-html/private/doc-hidden-private-67851-private.rs
diff --git a/tests/rustdoc/private/empty-impl-block-private-with-doc.rs b/tests/rustdoc-html/private/empty-impl-block-private-with-doc.rs
similarity index 100%
rename from tests/rustdoc/private/empty-impl-block-private-with-doc.rs
rename to tests/rustdoc-html/private/empty-impl-block-private-with-doc.rs
diff --git a/tests/rustdoc/private/empty-impl-block-private.rs b/tests/rustdoc-html/private/empty-impl-block-private.rs
similarity index 100%
rename from tests/rustdoc/private/empty-impl-block-private.rs
rename to tests/rustdoc-html/private/empty-impl-block-private.rs
diff --git a/tests/rustdoc/private/empty-mod-private.rs b/tests/rustdoc-html/private/empty-mod-private.rs
similarity index 100%
rename from tests/rustdoc/private/empty-mod-private.rs
rename to tests/rustdoc-html/private/empty-mod-private.rs
diff --git a/tests/rustdoc/private/enum-variant-private-46767.rs b/tests/rustdoc-html/private/enum-variant-private-46767.rs
similarity index 100%
rename from tests/rustdoc/private/enum-variant-private-46767.rs
rename to tests/rustdoc-html/private/enum-variant-private-46767.rs
diff --git a/tests/rustdoc/private/files-creation-private.rs b/tests/rustdoc-html/private/files-creation-private.rs
similarity index 100%
rename from tests/rustdoc/private/files-creation-private.rs
rename to tests/rustdoc-html/private/files-creation-private.rs
diff --git a/tests/rustdoc/private/hidden-private.rs b/tests/rustdoc-html/private/hidden-private.rs
similarity index 100%
rename from tests/rustdoc/private/hidden-private.rs
rename to tests/rustdoc-html/private/hidden-private.rs
diff --git a/tests/rustdoc/private/inline-private-with-intermediate-doc-hidden.rs b/tests/rustdoc-html/private/inline-private-with-intermediate-doc-hidden.rs
similarity index 100%
rename from tests/rustdoc/private/inline-private-with-intermediate-doc-hidden.rs
rename to tests/rustdoc-html/private/inline-private-with-intermediate-doc-hidden.rs
diff --git a/tests/rustdoc/private/inner-private-110422.rs b/tests/rustdoc-html/private/inner-private-110422.rs
similarity index 100%
rename from tests/rustdoc/private/inner-private-110422.rs
rename to tests/rustdoc-html/private/inner-private-110422.rs
diff --git a/tests/rustdoc/private/macro-document-private-duplicate.rs b/tests/rustdoc-html/private/macro-document-private-duplicate.rs
similarity index 100%
rename from tests/rustdoc/private/macro-document-private-duplicate.rs
rename to tests/rustdoc-html/private/macro-document-private-duplicate.rs
diff --git a/tests/rustdoc/private/macro-document-private.rs b/tests/rustdoc-html/private/macro-document-private.rs
similarity index 100%
rename from tests/rustdoc/private/macro-document-private.rs
rename to tests/rustdoc-html/private/macro-document-private.rs
diff --git a/tests/rustdoc/private/macro-private-not-documented.rs b/tests/rustdoc-html/private/macro-private-not-documented.rs
similarity index 100%
rename from tests/rustdoc/private/macro-private-not-documented.rs
rename to tests/rustdoc-html/private/macro-private-not-documented.rs
diff --git a/tests/rustdoc/private/missing-private-inlining-109258.rs b/tests/rustdoc-html/private/missing-private-inlining-109258.rs
similarity index 100%
rename from tests/rustdoc/private/missing-private-inlining-109258.rs
rename to tests/rustdoc-html/private/missing-private-inlining-109258.rs
diff --git a/tests/rustdoc/private/private-fields-tuple-struct.rs b/tests/rustdoc-html/private/private-fields-tuple-struct.rs
similarity index 100%
rename from tests/rustdoc/private/private-fields-tuple-struct.rs
rename to tests/rustdoc-html/private/private-fields-tuple-struct.rs
diff --git a/tests/rustdoc/private/private-non-local-fields-2.rs b/tests/rustdoc-html/private/private-non-local-fields-2.rs
similarity index 100%
rename from tests/rustdoc/private/private-non-local-fields-2.rs
rename to tests/rustdoc-html/private/private-non-local-fields-2.rs
diff --git a/tests/rustdoc/private/private-non-local-fields.rs b/tests/rustdoc-html/private/private-non-local-fields.rs
similarity index 100%
rename from tests/rustdoc/private/private-non-local-fields.rs
rename to tests/rustdoc-html/private/private-non-local-fields.rs
diff --git a/tests/rustdoc/private/private-type-alias.rs b/tests/rustdoc-html/private/private-type-alias.rs
similarity index 100%
rename from tests/rustdoc/private/private-type-alias.rs
rename to tests/rustdoc-html/private/private-type-alias.rs
diff --git a/tests/rustdoc/private/private-type-cycle-110629.rs b/tests/rustdoc-html/private/private-type-cycle-110629.rs
similarity index 100%
rename from tests/rustdoc/private/private-type-cycle-110629.rs
rename to tests/rustdoc-html/private/private-type-cycle-110629.rs
diff --git a/tests/rustdoc/private/private-use-decl-macro-47038.rs b/tests/rustdoc-html/private/private-use-decl-macro-47038.rs
similarity index 100%
rename from tests/rustdoc/private/private-use-decl-macro-47038.rs
rename to tests/rustdoc-html/private/private-use-decl-macro-47038.rs
diff --git a/tests/rustdoc/private/private-use.rs b/tests/rustdoc-html/private/private-use.rs
similarity index 100%
rename from tests/rustdoc/private/private-use.rs
rename to tests/rustdoc-html/private/private-use.rs
diff --git a/tests/rustdoc/private/public-impl-mention-private-generic-46380-2.rs b/tests/rustdoc-html/private/public-impl-mention-private-generic-46380-2.rs
similarity index 100%
rename from tests/rustdoc/private/public-impl-mention-private-generic-46380-2.rs
rename to tests/rustdoc-html/private/public-impl-mention-private-generic-46380-2.rs
diff --git a/tests/rustdoc/private/traits-in-bodies-private.rs b/tests/rustdoc-html/private/traits-in-bodies-private.rs
similarity index 100%
rename from tests/rustdoc/private/traits-in-bodies-private.rs
rename to tests/rustdoc-html/private/traits-in-bodies-private.rs
diff --git a/tests/rustdoc/process-termination.rs b/tests/rustdoc-html/process-termination.rs
similarity index 100%
rename from tests/rustdoc/process-termination.rs
rename to tests/rustdoc-html/process-termination.rs
diff --git a/tests/rustdoc/pub-method.rs b/tests/rustdoc-html/pub-method.rs
similarity index 100%
rename from tests/rustdoc/pub-method.rs
rename to tests/rustdoc-html/pub-method.rs
diff --git a/tests/rustdoc/pub-use-loop-107350.rs b/tests/rustdoc-html/pub-use-loop-107350.rs
similarity index 100%
rename from tests/rustdoc/pub-use-loop-107350.rs
rename to tests/rustdoc-html/pub-use-loop-107350.rs
diff --git a/tests/rustdoc/pub-use-root-path-95873.rs b/tests/rustdoc-html/pub-use-root-path-95873.rs
similarity index 100%
rename from tests/rustdoc/pub-use-root-path-95873.rs
rename to tests/rustdoc-html/pub-use-root-path-95873.rs
diff --git a/tests/rustdoc/range-arg-pattern.rs b/tests/rustdoc-html/range-arg-pattern.rs
similarity index 100%
rename from tests/rustdoc/range-arg-pattern.rs
rename to tests/rustdoc-html/range-arg-pattern.rs
diff --git a/tests/rustdoc/raw-ident-eliminate-r-hashtag.rs b/tests/rustdoc-html/raw-ident-eliminate-r-hashtag.rs
similarity index 100%
rename from tests/rustdoc/raw-ident-eliminate-r-hashtag.rs
rename to tests/rustdoc-html/raw-ident-eliminate-r-hashtag.rs
diff --git a/tests/rustdoc/read-more-unneeded.rs b/tests/rustdoc-html/read-more-unneeded.rs
similarity index 100%
rename from tests/rustdoc/read-more-unneeded.rs
rename to tests/rustdoc-html/read-more-unneeded.rs
diff --git a/tests/rustdoc/recursion1.rs b/tests/rustdoc-html/recursion1.rs
similarity index 100%
rename from tests/rustdoc/recursion1.rs
rename to tests/rustdoc-html/recursion1.rs
diff --git a/tests/rustdoc/recursion2.rs b/tests/rustdoc-html/recursion2.rs
similarity index 100%
rename from tests/rustdoc/recursion2.rs
rename to tests/rustdoc-html/recursion2.rs
diff --git a/tests/rustdoc/recursion3.rs b/tests/rustdoc-html/recursion3.rs
similarity index 100%
rename from tests/rustdoc/recursion3.rs
rename to tests/rustdoc-html/recursion3.rs
diff --git a/tests/rustdoc/redirect-map-empty.rs b/tests/rustdoc-html/redirect-map-empty.rs
similarity index 100%
rename from tests/rustdoc/redirect-map-empty.rs
rename to tests/rustdoc-html/redirect-map-empty.rs
diff --git a/tests/rustdoc/redirect-map.rs b/tests/rustdoc-html/redirect-map.rs
similarity index 100%
rename from tests/rustdoc/redirect-map.rs
rename to tests/rustdoc-html/redirect-map.rs
diff --git a/tests/rustdoc/redirect-rename.rs b/tests/rustdoc-html/redirect-rename.rs
similarity index 100%
rename from tests/rustdoc/redirect-rename.rs
rename to tests/rustdoc-html/redirect-rename.rs
diff --git a/tests/rustdoc/redirect.rs b/tests/rustdoc-html/redirect.rs
similarity index 100%
rename from tests/rustdoc/redirect.rs
rename to tests/rustdoc-html/redirect.rs
diff --git a/tests/rustdoc/reexport/alias-reexport.rs b/tests/rustdoc-html/reexport/alias-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/alias-reexport.rs
rename to tests/rustdoc-html/reexport/alias-reexport.rs
diff --git a/tests/rustdoc/reexport/alias-reexport2.rs b/tests/rustdoc-html/reexport/alias-reexport2.rs
similarity index 100%
rename from tests/rustdoc/reexport/alias-reexport2.rs
rename to tests/rustdoc-html/reexport/alias-reexport2.rs
diff --git a/tests/rustdoc/reexport/anonymous-reexport-108931.rs b/tests/rustdoc-html/reexport/anonymous-reexport-108931.rs
similarity index 100%
rename from tests/rustdoc/reexport/anonymous-reexport-108931.rs
rename to tests/rustdoc-html/reexport/anonymous-reexport-108931.rs
diff --git a/tests/rustdoc/reexport/anonymous-reexport.rs b/tests/rustdoc-html/reexport/anonymous-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/anonymous-reexport.rs
rename to tests/rustdoc-html/reexport/anonymous-reexport.rs
diff --git a/tests/rustdoc/reexport/auxiliary/alias-reexport.rs b/tests/rustdoc-html/reexport/auxiliary/alias-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/alias-reexport.rs
rename to tests/rustdoc-html/reexport/auxiliary/alias-reexport.rs
diff --git a/tests/rustdoc/reexport/auxiliary/alias-reexport2.rs b/tests/rustdoc-html/reexport/auxiliary/alias-reexport2.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/alias-reexport2.rs
rename to tests/rustdoc-html/reexport/auxiliary/alias-reexport2.rs
diff --git a/tests/rustdoc/reexport/auxiliary/all-item-types.rs b/tests/rustdoc-html/reexport/auxiliary/all-item-types.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/all-item-types.rs
rename to tests/rustdoc-html/reexport/auxiliary/all-item-types.rs
diff --git a/tests/rustdoc/reexport/auxiliary/issue-28927-1.rs b/tests/rustdoc-html/reexport/auxiliary/issue-28927-1.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/issue-28927-1.rs
rename to tests/rustdoc-html/reexport/auxiliary/issue-28927-1.rs
diff --git a/tests/rustdoc/reexport/auxiliary/issue-28927-2.rs b/tests/rustdoc-html/reexport/auxiliary/issue-28927-2.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/issue-28927-2.rs
rename to tests/rustdoc-html/reexport/auxiliary/issue-28927-2.rs
diff --git a/tests/rustdoc/reexport/auxiliary/primitive-reexport.rs b/tests/rustdoc-html/reexport/auxiliary/primitive-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/primitive-reexport.rs
rename to tests/rustdoc-html/reexport/auxiliary/primitive-reexport.rs
diff --git a/tests/rustdoc/reexport/auxiliary/reexport-check.rs b/tests/rustdoc-html/reexport/auxiliary/reexport-check.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/reexport-check.rs
rename to tests/rustdoc-html/reexport/auxiliary/reexport-check.rs
diff --git a/tests/rustdoc/reexport/auxiliary/reexport-doc-aux.rs b/tests/rustdoc-html/reexport/auxiliary/reexport-doc-aux.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/reexport-doc-aux.rs
rename to tests/rustdoc-html/reexport/auxiliary/reexport-doc-aux.rs
diff --git a/tests/rustdoc/reexport/auxiliary/reexports.rs b/tests/rustdoc-html/reexport/auxiliary/reexports.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/reexports.rs
rename to tests/rustdoc-html/reexport/auxiliary/reexports.rs
diff --git a/tests/rustdoc/reexport/auxiliary/wrap-unnamable-type.rs b/tests/rustdoc-html/reexport/auxiliary/wrap-unnamable-type.rs
similarity index 100%
rename from tests/rustdoc/reexport/auxiliary/wrap-unnamable-type.rs
rename to tests/rustdoc-html/reexport/auxiliary/wrap-unnamable-type.rs
diff --git a/tests/rustdoc/reexport/blanket-reexport-item.rs b/tests/rustdoc-html/reexport/blanket-reexport-item.rs
similarity index 100%
rename from tests/rustdoc/reexport/blanket-reexport-item.rs
rename to tests/rustdoc-html/reexport/blanket-reexport-item.rs
diff --git a/tests/rustdoc/reexport/cfg_doc_reexport.rs b/tests/rustdoc-html/reexport/cfg_doc_reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/cfg_doc_reexport.rs
rename to tests/rustdoc-html/reexport/cfg_doc_reexport.rs
diff --git a/tests/rustdoc/reexport/doc-hidden-reexports-109449.rs b/tests/rustdoc-html/reexport/doc-hidden-reexports-109449.rs
similarity index 100%
rename from tests/rustdoc/reexport/doc-hidden-reexports-109449.rs
rename to tests/rustdoc-html/reexport/doc-hidden-reexports-109449.rs
diff --git a/tests/rustdoc/reexport/duplicated-glob-reexport-60522.rs b/tests/rustdoc-html/reexport/duplicated-glob-reexport-60522.rs
similarity index 100%
rename from tests/rustdoc/reexport/duplicated-glob-reexport-60522.rs
rename to tests/rustdoc-html/reexport/duplicated-glob-reexport-60522.rs
diff --git a/tests/rustdoc/reexport/enum-variant-reexport-35488.rs b/tests/rustdoc-html/reexport/enum-variant-reexport-35488.rs
similarity index 100%
rename from tests/rustdoc/reexport/enum-variant-reexport-35488.rs
rename to tests/rustdoc-html/reexport/enum-variant-reexport-35488.rs
diff --git a/tests/rustdoc/reexport/enum-variant.rs b/tests/rustdoc-html/reexport/enum-variant.rs
similarity index 100%
rename from tests/rustdoc/reexport/enum-variant.rs
rename to tests/rustdoc-html/reexport/enum-variant.rs
diff --git a/tests/rustdoc/reexport/extern-135092.rs b/tests/rustdoc-html/reexport/extern-135092.rs
similarity index 100%
rename from tests/rustdoc/reexport/extern-135092.rs
rename to tests/rustdoc-html/reexport/extern-135092.rs
diff --git a/tests/rustdoc/reexport/foreigntype-reexport.rs b/tests/rustdoc-html/reexport/foreigntype-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/foreigntype-reexport.rs
rename to tests/rustdoc-html/reexport/foreigntype-reexport.rs
diff --git a/tests/rustdoc/reexport/glob-reexport-attribute-merge-120487.rs b/tests/rustdoc-html/reexport/glob-reexport-attribute-merge-120487.rs
similarity index 100%
rename from tests/rustdoc/reexport/glob-reexport-attribute-merge-120487.rs
rename to tests/rustdoc-html/reexport/glob-reexport-attribute-merge-120487.rs
diff --git a/tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs b/tests/rustdoc-html/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
similarity index 100%
rename from tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
rename to tests/rustdoc-html/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
diff --git a/tests/rustdoc/reexport/ice-reexport-crate-root-28927.rs b/tests/rustdoc-html/reexport/ice-reexport-crate-root-28927.rs
similarity index 100%
rename from tests/rustdoc/reexport/ice-reexport-crate-root-28927.rs
rename to tests/rustdoc-html/reexport/ice-reexport-crate-root-28927.rs
diff --git a/tests/rustdoc/reexport/import_trait_associated_functions.rs b/tests/rustdoc-html/reexport/import_trait_associated_functions.rs
similarity index 100%
rename from tests/rustdoc/reexport/import_trait_associated_functions.rs
rename to tests/rustdoc-html/reexport/import_trait_associated_functions.rs
diff --git a/tests/rustdoc/reexport/local-reexport-doc.rs b/tests/rustdoc-html/reexport/local-reexport-doc.rs
similarity index 100%
rename from tests/rustdoc/reexport/local-reexport-doc.rs
rename to tests/rustdoc-html/reexport/local-reexport-doc.rs
diff --git a/tests/rustdoc/reexport/merge-glob-and-non-glob.rs b/tests/rustdoc-html/reexport/merge-glob-and-non-glob.rs
similarity index 100%
rename from tests/rustdoc/reexport/merge-glob-and-non-glob.rs
rename to tests/rustdoc-html/reexport/merge-glob-and-non-glob.rs
diff --git a/tests/rustdoc/reexport/no-compiler-reexport.rs b/tests/rustdoc-html/reexport/no-compiler-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/no-compiler-reexport.rs
rename to tests/rustdoc-html/reexport/no-compiler-reexport.rs
diff --git a/tests/rustdoc/reexport/overlapping-reexport-105735-2.rs b/tests/rustdoc-html/reexport/overlapping-reexport-105735-2.rs
similarity index 100%
rename from tests/rustdoc/reexport/overlapping-reexport-105735-2.rs
rename to tests/rustdoc-html/reexport/overlapping-reexport-105735-2.rs
diff --git a/tests/rustdoc/reexport/overlapping-reexport-105735.rs b/tests/rustdoc-html/reexport/overlapping-reexport-105735.rs
similarity index 100%
rename from tests/rustdoc/reexport/overlapping-reexport-105735.rs
rename to tests/rustdoc-html/reexport/overlapping-reexport-105735.rs
diff --git a/tests/rustdoc/reexport/primitive-reexport.rs b/tests/rustdoc-html/reexport/primitive-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/primitive-reexport.rs
rename to tests/rustdoc-html/reexport/primitive-reexport.rs
diff --git a/tests/rustdoc/reexport/private-mod-override-reexport.rs b/tests/rustdoc-html/reexport/private-mod-override-reexport.rs
similarity index 100%
rename from tests/rustdoc/reexport/private-mod-override-reexport.rs
rename to tests/rustdoc-html/reexport/private-mod-override-reexport.rs
diff --git a/tests/rustdoc/reexport/pub-reexport-of-pub-reexport-46506.rs b/tests/rustdoc-html/reexport/pub-reexport-of-pub-reexport-46506.rs
similarity index 100%
rename from tests/rustdoc/reexport/pub-reexport-of-pub-reexport-46506.rs
rename to tests/rustdoc-html/reexport/pub-reexport-of-pub-reexport-46506.rs
diff --git a/tests/rustdoc/reexport/reexport-attr-merge.rs b/tests/rustdoc-html/reexport/reexport-attr-merge.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-attr-merge.rs
rename to tests/rustdoc-html/reexport/reexport-attr-merge.rs
diff --git a/tests/rustdoc/reexport/reexport-cfg.rs b/tests/rustdoc-html/reexport/reexport-cfg.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-cfg.rs
rename to tests/rustdoc-html/reexport/reexport-cfg.rs
diff --git a/tests/rustdoc/reexport/reexport-check.rs b/tests/rustdoc-html/reexport/reexport-check.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-check.rs
rename to tests/rustdoc-html/reexport/reexport-check.rs
diff --git a/tests/rustdoc/reexport/reexport-dep-foreign-fn.rs b/tests/rustdoc-html/reexport/reexport-dep-foreign-fn.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-dep-foreign-fn.rs
rename to tests/rustdoc-html/reexport/reexport-dep-foreign-fn.rs
diff --git a/tests/rustdoc/reexport/reexport-doc-hidden-inside-private.rs b/tests/rustdoc-html/reexport/reexport-doc-hidden-inside-private.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-doc-hidden-inside-private.rs
rename to tests/rustdoc-html/reexport/reexport-doc-hidden-inside-private.rs
diff --git a/tests/rustdoc/reexport/reexport-doc-hidden.rs b/tests/rustdoc-html/reexport/reexport-doc-hidden.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-doc-hidden.rs
rename to tests/rustdoc-html/reexport/reexport-doc-hidden.rs
diff --git a/tests/rustdoc/reexport/reexport-doc.rs b/tests/rustdoc-html/reexport/reexport-doc.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-doc.rs
rename to tests/rustdoc-html/reexport/reexport-doc.rs
diff --git a/tests/rustdoc/reexport/reexport-hidden-macro.rs b/tests/rustdoc-html/reexport/reexport-hidden-macro.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-hidden-macro.rs
rename to tests/rustdoc-html/reexport/reexport-hidden-macro.rs
diff --git a/tests/rustdoc/reexport/reexport-macro.rs b/tests/rustdoc-html/reexport/reexport-macro.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-macro.rs
rename to tests/rustdoc-html/reexport/reexport-macro.rs
diff --git a/tests/rustdoc/reexport/reexport-of-doc-hidden.rs b/tests/rustdoc-html/reexport/reexport-of-doc-hidden.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-of-doc-hidden.rs
rename to tests/rustdoc-html/reexport/reexport-of-doc-hidden.rs
diff --git a/tests/rustdoc/reexport/reexport-of-reexport-108679.rs b/tests/rustdoc-html/reexport/reexport-of-reexport-108679.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-of-reexport-108679.rs
rename to tests/rustdoc-html/reexport/reexport-of-reexport-108679.rs
diff --git a/tests/rustdoc/reexport/reexport-stability-tags-deprecated-and-portability.rs b/tests/rustdoc-html/reexport/reexport-stability-tags-deprecated-and-portability.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-stability-tags-deprecated-and-portability.rs
rename to tests/rustdoc-html/reexport/reexport-stability-tags-deprecated-and-portability.rs
diff --git a/tests/rustdoc/reexport/reexport-stability-tags-unstable-and-portability.rs b/tests/rustdoc-html/reexport/reexport-stability-tags-unstable-and-portability.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-stability-tags-unstable-and-portability.rs
rename to tests/rustdoc-html/reexport/reexport-stability-tags-unstable-and-portability.rs
diff --git a/tests/rustdoc/reexport/reexport-trait-from-hidden-111064-2.rs b/tests/rustdoc-html/reexport/reexport-trait-from-hidden-111064-2.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-trait-from-hidden-111064-2.rs
rename to tests/rustdoc-html/reexport/reexport-trait-from-hidden-111064-2.rs
diff --git a/tests/rustdoc/reexport/reexport-trait-from-hidden-111064.rs b/tests/rustdoc-html/reexport/reexport-trait-from-hidden-111064.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexport-trait-from-hidden-111064.rs
rename to tests/rustdoc-html/reexport/reexport-trait-from-hidden-111064.rs
diff --git a/tests/rustdoc/reexport/reexports-of-same-name.rs b/tests/rustdoc-html/reexport/reexports-of-same-name.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexports-of-same-name.rs
rename to tests/rustdoc-html/reexport/reexports-of-same-name.rs
diff --git a/tests/rustdoc/reexport/reexports-priv.rs b/tests/rustdoc-html/reexport/reexports-priv.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexports-priv.rs
rename to tests/rustdoc-html/reexport/reexports-priv.rs
diff --git a/tests/rustdoc/reexport/reexports.rs b/tests/rustdoc-html/reexport/reexports.rs
similarity index 100%
rename from tests/rustdoc/reexport/reexports.rs
rename to tests/rustdoc-html/reexport/reexports.rs
diff --git a/tests/rustdoc/reexport/wrapped-unnamble-type-143222.rs b/tests/rustdoc-html/reexport/wrapped-unnamble-type-143222.rs
similarity index 100%
rename from tests/rustdoc/reexport/wrapped-unnamble-type-143222.rs
rename to tests/rustdoc-html/reexport/wrapped-unnamble-type-143222.rs
diff --git a/tests/rustdoc/remove-duplicates.rs b/tests/rustdoc-html/remove-duplicates.rs
similarity index 100%
rename from tests/rustdoc/remove-duplicates.rs
rename to tests/rustdoc-html/remove-duplicates.rs
diff --git a/tests/rustdoc/remove-url-from-headings.rs b/tests/rustdoc-html/remove-url-from-headings.rs
similarity index 100%
rename from tests/rustdoc/remove-url-from-headings.rs
rename to tests/rustdoc-html/remove-url-from-headings.rs
diff --git a/tests/rustdoc/repr.rs b/tests/rustdoc-html/repr.rs
similarity index 100%
rename from tests/rustdoc/repr.rs
rename to tests/rustdoc-html/repr.rs
diff --git a/tests/rustdoc/resolve-ice-124363.rs b/tests/rustdoc-html/resolve-ice-124363.rs
similarity index 100%
rename from tests/rustdoc/resolve-ice-124363.rs
rename to tests/rustdoc-html/resolve-ice-124363.rs
diff --git a/tests/rustdoc/return-type-notation.rs b/tests/rustdoc-html/return-type-notation.rs
similarity index 100%
rename from tests/rustdoc/return-type-notation.rs
rename to tests/rustdoc-html/return-type-notation.rs
diff --git a/tests/rustdoc/safe-intrinsic.rs b/tests/rustdoc-html/safe-intrinsic.rs
similarity index 100%
rename from tests/rustdoc/safe-intrinsic.rs
rename to tests/rustdoc-html/safe-intrinsic.rs
diff --git a/tests/rustdoc/sanitizer-option.rs b/tests/rustdoc-html/sanitizer-option.rs
similarity index 100%
rename from tests/rustdoc/sanitizer-option.rs
rename to tests/rustdoc-html/sanitizer-option.rs
diff --git a/tests/rustdoc/search-index-summaries.rs b/tests/rustdoc-html/search-index-summaries.rs
similarity index 100%
rename from tests/rustdoc/search-index-summaries.rs
rename to tests/rustdoc-html/search-index-summaries.rs
diff --git a/tests/rustdoc/search-index.rs b/tests/rustdoc-html/search-index.rs
similarity index 100%
rename from tests/rustdoc/search-index.rs
rename to tests/rustdoc-html/search-index.rs
diff --git a/tests/rustdoc/short-docblock-codeblock.rs b/tests/rustdoc-html/short-docblock-codeblock.rs
similarity index 100%
rename from tests/rustdoc/short-docblock-codeblock.rs
rename to tests/rustdoc-html/short-docblock-codeblock.rs
diff --git a/tests/rustdoc/short-docblock.rs b/tests/rustdoc-html/short-docblock.rs
similarity index 100%
rename from tests/rustdoc/short-docblock.rs
rename to tests/rustdoc-html/short-docblock.rs
diff --git a/tests/rustdoc/short-line.md b/tests/rustdoc-html/short-line.md
similarity index 100%
rename from tests/rustdoc/short-line.md
rename to tests/rustdoc-html/short-line.md
diff --git a/tests/rustdoc/sidebar/module.rs b/tests/rustdoc-html/sidebar/module.rs
similarity index 100%
rename from tests/rustdoc/sidebar/module.rs
rename to tests/rustdoc-html/sidebar/module.rs
diff --git a/tests/rustdoc/sidebar/sidebar-all-page.rs b/tests/rustdoc-html/sidebar/sidebar-all-page.rs
similarity index 100%
rename from tests/rustdoc/sidebar/sidebar-all-page.rs
rename to tests/rustdoc-html/sidebar/sidebar-all-page.rs
diff --git a/tests/rustdoc/sidebar/sidebar-items.rs b/tests/rustdoc-html/sidebar/sidebar-items.rs
similarity index 100%
rename from tests/rustdoc/sidebar/sidebar-items.rs
rename to tests/rustdoc-html/sidebar/sidebar-items.rs
diff --git a/tests/rustdoc/sidebar/sidebar-link-generation.rs b/tests/rustdoc-html/sidebar/sidebar-link-generation.rs
similarity index 100%
rename from tests/rustdoc/sidebar/sidebar-link-generation.rs
rename to tests/rustdoc-html/sidebar/sidebar-link-generation.rs
diff --git a/tests/rustdoc/sidebar/sidebar-links-to-foreign-impl.rs b/tests/rustdoc-html/sidebar/sidebar-links-to-foreign-impl.rs
similarity index 100%
rename from tests/rustdoc/sidebar/sidebar-links-to-foreign-impl.rs
rename to tests/rustdoc-html/sidebar/sidebar-links-to-foreign-impl.rs
diff --git a/tests/rustdoc/sidebar/top-toc-html.rs b/tests/rustdoc-html/sidebar/top-toc-html.rs
similarity index 100%
rename from tests/rustdoc/sidebar/top-toc-html.rs
rename to tests/rustdoc-html/sidebar/top-toc-html.rs
diff --git a/tests/rustdoc/sidebar/top-toc-idmap.rs b/tests/rustdoc-html/sidebar/top-toc-idmap.rs
similarity index 100%
rename from tests/rustdoc/sidebar/top-toc-idmap.rs
rename to tests/rustdoc-html/sidebar/top-toc-idmap.rs
diff --git a/tests/rustdoc/sidebar/top-toc-nil.rs b/tests/rustdoc-html/sidebar/top-toc-nil.rs
similarity index 100%
rename from tests/rustdoc/sidebar/top-toc-nil.rs
rename to tests/rustdoc-html/sidebar/top-toc-nil.rs
diff --git a/tests/rustdoc/sized_trait.rs b/tests/rustdoc-html/sized_trait.rs
similarity index 100%
rename from tests/rustdoc/sized_trait.rs
rename to tests/rustdoc-html/sized_trait.rs
diff --git a/tests/rustdoc/slice-links.link_box_generic.html b/tests/rustdoc-html/slice-links.link_box_generic.html
similarity index 100%
rename from tests/rustdoc/slice-links.link_box_generic.html
rename to tests/rustdoc-html/slice-links.link_box_generic.html
diff --git a/tests/rustdoc/slice-links.link_box_u32.html b/tests/rustdoc-html/slice-links.link_box_u32.html
similarity index 100%
rename from tests/rustdoc/slice-links.link_box_u32.html
rename to tests/rustdoc-html/slice-links.link_box_u32.html
diff --git a/tests/rustdoc/slice-links.link_slice_generic.html b/tests/rustdoc-html/slice-links.link_slice_generic.html
similarity index 100%
rename from tests/rustdoc/slice-links.link_slice_generic.html
rename to tests/rustdoc-html/slice-links.link_slice_generic.html
diff --git a/tests/rustdoc/slice-links.link_slice_u32.html b/tests/rustdoc-html/slice-links.link_slice_u32.html
similarity index 100%
rename from tests/rustdoc/slice-links.link_slice_u32.html
rename to tests/rustdoc-html/slice-links.link_slice_u32.html
diff --git a/tests/rustdoc/slice-links.rs b/tests/rustdoc-html/slice-links.rs
similarity index 100%
rename from tests/rustdoc/slice-links.rs
rename to tests/rustdoc-html/slice-links.rs
diff --git a/tests/rustdoc/smart-punct.rs b/tests/rustdoc-html/smart-punct.rs
similarity index 100%
rename from tests/rustdoc/smart-punct.rs
rename to tests/rustdoc-html/smart-punct.rs
diff --git a/tests/rustdoc/smoke.rs b/tests/rustdoc-html/smoke.rs
similarity index 100%
rename from tests/rustdoc/smoke.rs
rename to tests/rustdoc-html/smoke.rs
diff --git a/tests/rustdoc/sort-53812.rs b/tests/rustdoc-html/sort-53812.rs
similarity index 100%
rename from tests/rustdoc/sort-53812.rs
rename to tests/rustdoc-html/sort-53812.rs
diff --git a/tests/rustdoc/sort-modules-by-appearance.rs b/tests/rustdoc-html/sort-modules-by-appearance.rs
similarity index 100%
rename from tests/rustdoc/sort-modules-by-appearance.rs
rename to tests/rustdoc-html/sort-modules-by-appearance.rs
diff --git a/tests/rustdoc/source-code-pages/assoc-type-source-link.rs b/tests/rustdoc-html/source-code-pages/assoc-type-source-link.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/assoc-type-source-link.rs
rename to tests/rustdoc-html/source-code-pages/assoc-type-source-link.rs
diff --git a/tests/rustdoc/source-code-pages/auxiliary/issue-26606-macro.rs b/tests/rustdoc-html/source-code-pages/auxiliary/issue-26606-macro.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/auxiliary/issue-26606-macro.rs
rename to tests/rustdoc-html/source-code-pages/auxiliary/issue-26606-macro.rs
diff --git a/tests/rustdoc/source-code-pages/auxiliary/issue-34274.rs b/tests/rustdoc-html/source-code-pages/auxiliary/issue-34274.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/auxiliary/issue-34274.rs
rename to tests/rustdoc-html/source-code-pages/auxiliary/issue-34274.rs
diff --git a/tests/rustdoc/source-code-pages/auxiliary/source-code-bar.rs b/tests/rustdoc-html/source-code-pages/auxiliary/source-code-bar.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/auxiliary/source-code-bar.rs
rename to tests/rustdoc-html/source-code-pages/auxiliary/source-code-bar.rs
diff --git a/tests/rustdoc/source-code-pages/auxiliary/source_code.rs b/tests/rustdoc-html/source-code-pages/auxiliary/source_code.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/auxiliary/source_code.rs
rename to tests/rustdoc-html/source-code-pages/auxiliary/source_code.rs
diff --git a/tests/rustdoc/source-code-pages/auxiliary/src-links-external.rs b/tests/rustdoc-html/source-code-pages/auxiliary/src-links-external.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/auxiliary/src-links-external.rs
rename to tests/rustdoc-html/source-code-pages/auxiliary/src-links-external.rs
diff --git a/tests/rustdoc/source-code-pages/check-source-code-urls-to-def-std.rs b/tests/rustdoc-html/source-code-pages/check-source-code-urls-to-def-std.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/check-source-code-urls-to-def-std.rs
rename to tests/rustdoc-html/source-code-pages/check-source-code-urls-to-def-std.rs
diff --git a/tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs b/tests/rustdoc-html/source-code-pages/check-source-code-urls-to-def.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs
rename to tests/rustdoc-html/source-code-pages/check-source-code-urls-to-def.rs
diff --git a/tests/rustdoc/source-code-pages/doc-hidden-source.rs b/tests/rustdoc-html/source-code-pages/doc-hidden-source.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/doc-hidden-source.rs
rename to tests/rustdoc-html/source-code-pages/doc-hidden-source.rs
diff --git a/tests/rustdoc/source-code-pages/failing-expansion-on-wrong-macro.rs b/tests/rustdoc-html/source-code-pages/failing-expansion-on-wrong-macro.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/failing-expansion-on-wrong-macro.rs
rename to tests/rustdoc-html/source-code-pages/failing-expansion-on-wrong-macro.rs
diff --git a/tests/rustdoc/source-code-pages/frontmatter.rs b/tests/rustdoc-html/source-code-pages/frontmatter.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/frontmatter.rs
rename to tests/rustdoc-html/source-code-pages/frontmatter.rs
diff --git a/tests/rustdoc/source-code-pages/html-no-source.rs b/tests/rustdoc-html/source-code-pages/html-no-source.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/html-no-source.rs
rename to tests/rustdoc-html/source-code-pages/html-no-source.rs
diff --git a/tests/rustdoc/source-code-pages/keyword-macros.rs b/tests/rustdoc-html/source-code-pages/keyword-macros.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/keyword-macros.rs
rename to tests/rustdoc-html/source-code-pages/keyword-macros.rs
diff --git a/tests/rustdoc/source-code-pages/shebang.rs b/tests/rustdoc-html/source-code-pages/shebang.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/shebang.rs
rename to tests/rustdoc-html/source-code-pages/shebang.rs
diff --git a/tests/rustdoc/source-code-pages/source-code-highlight.rs b/tests/rustdoc-html/source-code-pages/source-code-highlight.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/source-code-highlight.rs
rename to tests/rustdoc-html/source-code-pages/source-code-highlight.rs
diff --git a/tests/rustdoc/source-code-pages/source-file.rs b/tests/rustdoc-html/source-code-pages/source-file.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/source-file.rs
rename to tests/rustdoc-html/source-code-pages/source-file.rs
diff --git a/tests/rustdoc/source-code-pages/source-line-numbers.rs b/tests/rustdoc-html/source-code-pages/source-line-numbers.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/source-line-numbers.rs
rename to tests/rustdoc-html/source-code-pages/source-line-numbers.rs
diff --git a/tests/rustdoc/source-code-pages/source-version-separator.rs b/tests/rustdoc-html/source-code-pages/source-version-separator.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/source-version-separator.rs
rename to tests/rustdoc-html/source-code-pages/source-version-separator.rs
diff --git a/tests/rustdoc/source-code-pages/src-link-external-macro-26606.rs b/tests/rustdoc-html/source-code-pages/src-link-external-macro-26606.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-link-external-macro-26606.rs
rename to tests/rustdoc-html/source-code-pages/src-link-external-macro-26606.rs
diff --git a/tests/rustdoc/source-code-pages/src-links-auto-impls.rs b/tests/rustdoc-html/source-code-pages/src-links-auto-impls.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links-auto-impls.rs
rename to tests/rustdoc-html/source-code-pages/src-links-auto-impls.rs
diff --git a/tests/rustdoc/source-code-pages/src-links-external.rs b/tests/rustdoc-html/source-code-pages/src-links-external.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links-external.rs
rename to tests/rustdoc-html/source-code-pages/src-links-external.rs
diff --git a/tests/rustdoc/source-code-pages/src-links-implementor-43893.rs b/tests/rustdoc-html/source-code-pages/src-links-implementor-43893.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links-implementor-43893.rs
rename to tests/rustdoc-html/source-code-pages/src-links-implementor-43893.rs
diff --git a/tests/rustdoc/source-code-pages/src-links-inlined-34274.rs b/tests/rustdoc-html/source-code-pages/src-links-inlined-34274.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links-inlined-34274.rs
rename to tests/rustdoc-html/source-code-pages/src-links-inlined-34274.rs
diff --git a/tests/rustdoc/source-code-pages/src-links.rs b/tests/rustdoc-html/source-code-pages/src-links.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links.rs
rename to tests/rustdoc-html/source-code-pages/src-links.rs
diff --git a/tests/rustdoc/source-code-pages/src-links/compiletest-ignore-dir b/tests/rustdoc-html/source-code-pages/src-links/compiletest-ignore-dir
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links/compiletest-ignore-dir
rename to tests/rustdoc-html/source-code-pages/src-links/compiletest-ignore-dir
diff --git a/tests/rustdoc/source-code-pages/src-links/fizz.rs b/tests/rustdoc-html/source-code-pages/src-links/fizz.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links/fizz.rs
rename to tests/rustdoc-html/source-code-pages/src-links/fizz.rs
diff --git a/tests/rustdoc/source-code-pages/src-links/mod.rs b/tests/rustdoc-html/source-code-pages/src-links/mod.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-links/mod.rs
rename to tests/rustdoc-html/source-code-pages/src-links/mod.rs
diff --git a/tests/rustdoc/source-code-pages/src-mod-path-absolute-26995.rs b/tests/rustdoc-html/source-code-pages/src-mod-path-absolute-26995.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/src-mod-path-absolute-26995.rs
rename to tests/rustdoc-html/source-code-pages/src-mod-path-absolute-26995.rs
diff --git a/tests/rustdoc/source-code-pages/version-separator-without-source.rs b/tests/rustdoc-html/source-code-pages/version-separator-without-source.rs
similarity index 100%
rename from tests/rustdoc/source-code-pages/version-separator-without-source.rs
rename to tests/rustdoc-html/source-code-pages/version-separator-without-source.rs
diff --git a/tests/rustdoc/stability.rs b/tests/rustdoc-html/stability.rs
similarity index 100%
rename from tests/rustdoc/stability.rs
rename to tests/rustdoc-html/stability.rs
diff --git a/tests/rustdoc/staged-api-deprecated-unstable-32374.rs b/tests/rustdoc-html/staged-api-deprecated-unstable-32374.rs
similarity index 100%
rename from tests/rustdoc/staged-api-deprecated-unstable-32374.rs
rename to tests/rustdoc-html/staged-api-deprecated-unstable-32374.rs
diff --git a/tests/rustdoc/staged-api-feature-issue-27759.rs b/tests/rustdoc-html/staged-api-feature-issue-27759.rs
similarity index 100%
rename from tests/rustdoc/staged-api-feature-issue-27759.rs
rename to tests/rustdoc-html/staged-api-feature-issue-27759.rs
diff --git a/tests/rustdoc/static-root-path.rs b/tests/rustdoc-html/static-root-path.rs
similarity index 100%
rename from tests/rustdoc/static-root-path.rs
rename to tests/rustdoc-html/static-root-path.rs
diff --git a/tests/rustdoc/static.rs b/tests/rustdoc-html/static.rs
similarity index 100%
rename from tests/rustdoc/static.rs
rename to tests/rustdoc-html/static.rs
diff --git a/tests/rustdoc/strip-block-doc-comments-stars.docblock.html b/tests/rustdoc-html/strip-block-doc-comments-stars.docblock.html
similarity index 100%
rename from tests/rustdoc/strip-block-doc-comments-stars.docblock.html
rename to tests/rustdoc-html/strip-block-doc-comments-stars.docblock.html
diff --git a/tests/rustdoc/strip-block-doc-comments-stars.rs b/tests/rustdoc-html/strip-block-doc-comments-stars.rs
similarity index 100%
rename from tests/rustdoc/strip-block-doc-comments-stars.rs
rename to tests/rustdoc-html/strip-block-doc-comments-stars.rs
diff --git a/tests/rustdoc/strip-priv-imports-pass-27104.rs b/tests/rustdoc-html/strip-priv-imports-pass-27104.rs
similarity index 100%
rename from tests/rustdoc/strip-priv-imports-pass-27104.rs
rename to tests/rustdoc-html/strip-priv-imports-pass-27104.rs
diff --git a/tests/rustdoc/struct-arg-pattern.rs b/tests/rustdoc-html/struct-arg-pattern.rs
similarity index 100%
rename from tests/rustdoc/struct-arg-pattern.rs
rename to tests/rustdoc-html/struct-arg-pattern.rs
diff --git a/tests/rustdoc/struct-field.rs b/tests/rustdoc-html/struct-field.rs
similarity index 100%
rename from tests/rustdoc/struct-field.rs
rename to tests/rustdoc-html/struct-field.rs
diff --git a/tests/rustdoc/structfields.rs b/tests/rustdoc-html/structfields.rs
similarity index 100%
rename from tests/rustdoc/structfields.rs
rename to tests/rustdoc-html/structfields.rs
diff --git a/tests/rustdoc/summary-codeblock-31899.rs b/tests/rustdoc-html/summary-codeblock-31899.rs
similarity index 100%
rename from tests/rustdoc/summary-codeblock-31899.rs
rename to tests/rustdoc-html/summary-codeblock-31899.rs
diff --git a/tests/rustdoc/summary-header-46377.rs b/tests/rustdoc-html/summary-header-46377.rs
similarity index 100%
rename from tests/rustdoc/summary-header-46377.rs
rename to tests/rustdoc-html/summary-header-46377.rs
diff --git a/tests/rustdoc/summary-reference-link-30366.rs b/tests/rustdoc-html/summary-reference-link-30366.rs
similarity index 100%
rename from tests/rustdoc/summary-reference-link-30366.rs
rename to tests/rustdoc-html/summary-reference-link-30366.rs
diff --git a/tests/rustdoc/synthetic_auto/auto-trait-lifetimes-56822.rs b/tests/rustdoc-html/synthetic_auto/auto-trait-lifetimes-56822.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/auto-trait-lifetimes-56822.rs
rename to tests/rustdoc-html/synthetic_auto/auto-trait-lifetimes-56822.rs
diff --git a/tests/rustdoc/synthetic_auto/basic.rs b/tests/rustdoc-html/synthetic_auto/basic.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/basic.rs
rename to tests/rustdoc-html/synthetic_auto/basic.rs
diff --git a/tests/rustdoc/synthetic_auto/bounds.rs b/tests/rustdoc-html/synthetic_auto/bounds.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/bounds.rs
rename to tests/rustdoc-html/synthetic_auto/bounds.rs
diff --git a/tests/rustdoc/synthetic_auto/complex.rs b/tests/rustdoc-html/synthetic_auto/complex.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/complex.rs
rename to tests/rustdoc-html/synthetic_auto/complex.rs
diff --git a/tests/rustdoc/synthetic_auto/crate-local.rs b/tests/rustdoc-html/synthetic_auto/crate-local.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/crate-local.rs
rename to tests/rustdoc-html/synthetic_auto/crate-local.rs
diff --git a/tests/rustdoc/synthetic_auto/issue-72213-projection-lifetime.rs b/tests/rustdoc-html/synthetic_auto/issue-72213-projection-lifetime.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/issue-72213-projection-lifetime.rs
rename to tests/rustdoc-html/synthetic_auto/issue-72213-projection-lifetime.rs
diff --git a/tests/rustdoc/synthetic_auto/lifetimes.rs b/tests/rustdoc-html/synthetic_auto/lifetimes.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/lifetimes.rs
rename to tests/rustdoc-html/synthetic_auto/lifetimes.rs
diff --git a/tests/rustdoc/synthetic_auto/manual.rs b/tests/rustdoc-html/synthetic_auto/manual.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/manual.rs
rename to tests/rustdoc-html/synthetic_auto/manual.rs
diff --git a/tests/rustdoc/synthetic_auto/negative.rs b/tests/rustdoc-html/synthetic_auto/negative.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/negative.rs
rename to tests/rustdoc-html/synthetic_auto/negative.rs
diff --git a/tests/rustdoc/synthetic_auto/nested.rs b/tests/rustdoc-html/synthetic_auto/nested.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/nested.rs
rename to tests/rustdoc-html/synthetic_auto/nested.rs
diff --git a/tests/rustdoc/synthetic_auto/no-redundancy.rs b/tests/rustdoc-html/synthetic_auto/no-redundancy.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/no-redundancy.rs
rename to tests/rustdoc-html/synthetic_auto/no-redundancy.rs
diff --git a/tests/rustdoc/synthetic_auto/normalize-auto-trait-80233.rs b/tests/rustdoc-html/synthetic_auto/normalize-auto-trait-80233.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/normalize-auto-trait-80233.rs
rename to tests/rustdoc-html/synthetic_auto/normalize-auto-trait-80233.rs
diff --git a/tests/rustdoc/synthetic_auto/overflow.rs b/tests/rustdoc-html/synthetic_auto/overflow.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/overflow.rs
rename to tests/rustdoc-html/synthetic_auto/overflow.rs
diff --git a/tests/rustdoc/synthetic_auto/project.rs b/tests/rustdoc-html/synthetic_auto/project.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/project.rs
rename to tests/rustdoc-html/synthetic_auto/project.rs
diff --git a/tests/rustdoc/synthetic_auto/self-referential.rs b/tests/rustdoc-html/synthetic_auto/self-referential.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/self-referential.rs
rename to tests/rustdoc-html/synthetic_auto/self-referential.rs
diff --git a/tests/rustdoc/synthetic_auto/send-impl-conditional-60726.rs b/tests/rustdoc-html/synthetic_auto/send-impl-conditional-60726.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/send-impl-conditional-60726.rs
rename to tests/rustdoc-html/synthetic_auto/send-impl-conditional-60726.rs
diff --git a/tests/rustdoc/synthetic_auto/static-region.rs b/tests/rustdoc-html/synthetic_auto/static-region.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/static-region.rs
rename to tests/rustdoc-html/synthetic_auto/static-region.rs
diff --git a/tests/rustdoc/synthetic_auto/supertrait-bounds.rs b/tests/rustdoc-html/synthetic_auto/supertrait-bounds.rs
similarity index 100%
rename from tests/rustdoc/synthetic_auto/supertrait-bounds.rs
rename to tests/rustdoc-html/synthetic_auto/supertrait-bounds.rs
diff --git a/tests/rustdoc/tab_title.rs b/tests/rustdoc-html/tab_title.rs
similarity index 100%
rename from tests/rustdoc/tab_title.rs
rename to tests/rustdoc-html/tab_title.rs
diff --git a/tests/rustdoc/table-in-docblock.rs b/tests/rustdoc-html/table-in-docblock.rs
similarity index 100%
rename from tests/rustdoc/table-in-docblock.rs
rename to tests/rustdoc-html/table-in-docblock.rs
diff --git a/tests/rustdoc/target-feature.rs b/tests/rustdoc-html/target-feature.rs
similarity index 100%
rename from tests/rustdoc/target-feature.rs
rename to tests/rustdoc-html/target-feature.rs
diff --git a/tests/rustdoc/task-lists.rs b/tests/rustdoc-html/task-lists.rs
similarity index 100%
rename from tests/rustdoc/task-lists.rs
rename to tests/rustdoc-html/task-lists.rs
diff --git a/tests/rustdoc/test-lists.rs b/tests/rustdoc-html/test-lists.rs
similarity index 100%
rename from tests/rustdoc/test-lists.rs
rename to tests/rustdoc-html/test-lists.rs
diff --git a/tests/rustdoc/test-parens.rs b/tests/rustdoc-html/test-parens.rs
similarity index 100%
rename from tests/rustdoc/test-parens.rs
rename to tests/rustdoc-html/test-parens.rs
diff --git a/tests/rustdoc/test-strikethrough.rs b/tests/rustdoc-html/test-strikethrough.rs
similarity index 100%
rename from tests/rustdoc/test-strikethrough.rs
rename to tests/rustdoc-html/test-strikethrough.rs
diff --git a/tests/rustdoc/test_option_check/bar.rs b/tests/rustdoc-html/test_option_check/bar.rs
similarity index 100%
rename from tests/rustdoc/test_option_check/bar.rs
rename to tests/rustdoc-html/test_option_check/bar.rs
diff --git a/tests/rustdoc/test_option_check/test.rs b/tests/rustdoc-html/test_option_check/test.rs
similarity index 100%
rename from tests/rustdoc/test_option_check/test.rs
rename to tests/rustdoc-html/test_option_check/test.rs
diff --git a/tests/rustdoc/thread-local-src.rs b/tests/rustdoc-html/thread-local-src.rs
similarity index 100%
rename from tests/rustdoc/thread-local-src.rs
rename to tests/rustdoc-html/thread-local-src.rs
diff --git a/tests/rustdoc/titles.rs b/tests/rustdoc-html/titles.rs
similarity index 100%
rename from tests/rustdoc/titles.rs
rename to tests/rustdoc-html/titles.rs
diff --git a/tests/rustdoc/toggle-item-contents.rs b/tests/rustdoc-html/toggle-item-contents.rs
similarity index 100%
rename from tests/rustdoc/toggle-item-contents.rs
rename to tests/rustdoc-html/toggle-item-contents.rs
diff --git a/tests/rustdoc/toggle-method.rs b/tests/rustdoc-html/toggle-method.rs
similarity index 100%
rename from tests/rustdoc/toggle-method.rs
rename to tests/rustdoc-html/toggle-method.rs
diff --git a/tests/rustdoc/toggle-trait-fn.rs b/tests/rustdoc-html/toggle-trait-fn.rs
similarity index 100%
rename from tests/rustdoc/toggle-trait-fn.rs
rename to tests/rustdoc-html/toggle-trait-fn.rs
diff --git a/tests/rustdoc/trait-aliases.rs b/tests/rustdoc-html/trait-aliases.rs
similarity index 100%
rename from tests/rustdoc/trait-aliases.rs
rename to tests/rustdoc-html/trait-aliases.rs
diff --git a/tests/rustdoc/trait-item-info.rs b/tests/rustdoc-html/trait-item-info.rs
similarity index 100%
rename from tests/rustdoc/trait-item-info.rs
rename to tests/rustdoc-html/trait-item-info.rs
diff --git a/tests/rustdoc/trait-self-link.rs b/tests/rustdoc-html/trait-self-link.rs
similarity index 100%
rename from tests/rustdoc/trait-self-link.rs
rename to tests/rustdoc-html/trait-self-link.rs
diff --git a/tests/rustdoc/trait-src-link.rs b/tests/rustdoc-html/trait-src-link.rs
similarity index 100%
rename from tests/rustdoc/trait-src-link.rs
rename to tests/rustdoc-html/trait-src-link.rs
diff --git a/tests/rustdoc/trait-visibility.rs b/tests/rustdoc-html/trait-visibility.rs
similarity index 100%
rename from tests/rustdoc/trait-visibility.rs
rename to tests/rustdoc-html/trait-visibility.rs
diff --git a/tests/rustdoc/traits-in-bodies.rs b/tests/rustdoc-html/traits-in-bodies.rs
similarity index 100%
rename from tests/rustdoc/traits-in-bodies.rs
rename to tests/rustdoc-html/traits-in-bodies.rs
diff --git a/tests/rustdoc/tuple-struct-fields-doc.rs b/tests/rustdoc-html/tuple-struct-fields-doc.rs
similarity index 100%
rename from tests/rustdoc/tuple-struct-fields-doc.rs
rename to tests/rustdoc-html/tuple-struct-fields-doc.rs
diff --git a/tests/rustdoc/tuple-struct-where-clause-34928.rs b/tests/rustdoc-html/tuple-struct-where-clause-34928.rs
similarity index 100%
rename from tests/rustdoc/tuple-struct-where-clause-34928.rs
rename to tests/rustdoc-html/tuple-struct-where-clause-34928.rs
diff --git a/tests/rustdoc/tuples.link1_i32.html b/tests/rustdoc-html/tuples.link1_i32.html
similarity index 100%
rename from tests/rustdoc/tuples.link1_i32.html
rename to tests/rustdoc-html/tuples.link1_i32.html
diff --git a/tests/rustdoc/tuples.link1_t.html b/tests/rustdoc-html/tuples.link1_t.html
similarity index 100%
rename from tests/rustdoc/tuples.link1_t.html
rename to tests/rustdoc-html/tuples.link1_t.html
diff --git a/tests/rustdoc/tuples.link2_i32.html b/tests/rustdoc-html/tuples.link2_i32.html
similarity index 100%
rename from tests/rustdoc/tuples.link2_i32.html
rename to tests/rustdoc-html/tuples.link2_i32.html
diff --git a/tests/rustdoc/tuples.link2_t.html b/tests/rustdoc-html/tuples.link2_t.html
similarity index 100%
rename from tests/rustdoc/tuples.link2_t.html
rename to tests/rustdoc-html/tuples.link2_t.html
diff --git a/tests/rustdoc/tuples.link2_tu.html b/tests/rustdoc-html/tuples.link2_tu.html
similarity index 100%
rename from tests/rustdoc/tuples.link2_tu.html
rename to tests/rustdoc-html/tuples.link2_tu.html
diff --git a/tests/rustdoc/tuples.link_unit.html b/tests/rustdoc-html/tuples.link_unit.html
similarity index 100%
rename from tests/rustdoc/tuples.link_unit.html
rename to tests/rustdoc-html/tuples.link_unit.html
diff --git a/tests/rustdoc/tuples.rs b/tests/rustdoc-html/tuples.rs
similarity index 100%
rename from tests/rustdoc/tuples.rs
rename to tests/rustdoc-html/tuples.rs
diff --git a/tests/rustdoc/type-alias/auxiliary/parent-crate-115718.rs b/tests/rustdoc-html/type-alias/auxiliary/parent-crate-115718.rs
similarity index 100%
rename from tests/rustdoc/type-alias/auxiliary/parent-crate-115718.rs
rename to tests/rustdoc-html/type-alias/auxiliary/parent-crate-115718.rs
diff --git a/tests/rustdoc/type-alias/cross-crate-115718.rs b/tests/rustdoc-html/type-alias/cross-crate-115718.rs
similarity index 100%
rename from tests/rustdoc/type-alias/cross-crate-115718.rs
rename to tests/rustdoc-html/type-alias/cross-crate-115718.rs
diff --git a/tests/rustdoc/type-alias/deeply-nested-112515.rs b/tests/rustdoc-html/type-alias/deeply-nested-112515.rs
similarity index 100%
rename from tests/rustdoc/type-alias/deeply-nested-112515.rs
rename to tests/rustdoc-html/type-alias/deeply-nested-112515.rs
diff --git a/tests/rustdoc/type-alias/deref-32077.rs b/tests/rustdoc-html/type-alias/deref-32077.rs
similarity index 100%
rename from tests/rustdoc/type-alias/deref-32077.rs
rename to tests/rustdoc-html/type-alias/deref-32077.rs
diff --git a/tests/rustdoc/type-alias/impl_trait_in_assoc_type.rs b/tests/rustdoc-html/type-alias/impl_trait_in_assoc_type.rs
similarity index 100%
rename from tests/rustdoc/type-alias/impl_trait_in_assoc_type.rs
rename to tests/rustdoc-html/type-alias/impl_trait_in_assoc_type.rs
diff --git a/tests/rustdoc/type-alias/primitive-local-link-121106.rs b/tests/rustdoc-html/type-alias/primitive-local-link-121106.rs
similarity index 100%
rename from tests/rustdoc/type-alias/primitive-local-link-121106.rs
rename to tests/rustdoc-html/type-alias/primitive-local-link-121106.rs
diff --git a/tests/rustdoc/type-alias/repr.rs b/tests/rustdoc-html/type-alias/repr.rs
similarity index 100%
rename from tests/rustdoc/type-alias/repr.rs
rename to tests/rustdoc-html/type-alias/repr.rs
diff --git a/tests/rustdoc/type-alias/same-crate-115718.rs b/tests/rustdoc-html/type-alias/same-crate-115718.rs
similarity index 100%
rename from tests/rustdoc/type-alias/same-crate-115718.rs
rename to tests/rustdoc-html/type-alias/same-crate-115718.rs
diff --git a/tests/rustdoc/type-layout-flag-required.rs b/tests/rustdoc-html/type-layout-flag-required.rs
similarity index 100%
rename from tests/rustdoc/type-layout-flag-required.rs
rename to tests/rustdoc-html/type-layout-flag-required.rs
diff --git a/tests/rustdoc/type-layout.rs b/tests/rustdoc-html/type-layout.rs
similarity index 100%
rename from tests/rustdoc/type-layout.rs
rename to tests/rustdoc-html/type-layout.rs
diff --git a/tests/rustdoc/typedef-inner-variants-lazy_type_alias.rs b/tests/rustdoc-html/typedef-inner-variants-lazy_type_alias.rs
similarity index 100%
rename from tests/rustdoc/typedef-inner-variants-lazy_type_alias.rs
rename to tests/rustdoc-html/typedef-inner-variants-lazy_type_alias.rs
diff --git a/tests/rustdoc/typedef-inner-variants.rs b/tests/rustdoc-html/typedef-inner-variants.rs
similarity index 100%
rename from tests/rustdoc/typedef-inner-variants.rs
rename to tests/rustdoc-html/typedef-inner-variants.rs
diff --git a/tests/rustdoc/typedef.rs b/tests/rustdoc-html/typedef.rs
similarity index 100%
rename from tests/rustdoc/typedef.rs
rename to tests/rustdoc-html/typedef.rs
diff --git a/tests/rustdoc/underscore-import-61592.rs b/tests/rustdoc-html/underscore-import-61592.rs
similarity index 100%
rename from tests/rustdoc/underscore-import-61592.rs
rename to tests/rustdoc-html/underscore-import-61592.rs
diff --git a/tests/rustdoc/unindent.md b/tests/rustdoc-html/unindent.md
similarity index 100%
rename from tests/rustdoc/unindent.md
rename to tests/rustdoc-html/unindent.md
diff --git a/tests/rustdoc/unindent.rs b/tests/rustdoc-html/unindent.rs
similarity index 100%
rename from tests/rustdoc/unindent.rs
rename to tests/rustdoc-html/unindent.rs
diff --git a/tests/rustdoc/union-fields-html.rs b/tests/rustdoc-html/union-fields-html.rs
similarity index 100%
rename from tests/rustdoc/union-fields-html.rs
rename to tests/rustdoc-html/union-fields-html.rs
diff --git a/tests/rustdoc/union.rs b/tests/rustdoc-html/union.rs
similarity index 100%
rename from tests/rustdoc/union.rs
rename to tests/rustdoc-html/union.rs
diff --git a/tests/rustdoc/unit-return.rs b/tests/rustdoc-html/unit-return.rs
similarity index 100%
rename from tests/rustdoc/unit-return.rs
rename to tests/rustdoc-html/unit-return.rs
diff --git a/tests/rustdoc/unsafe-binder.rs b/tests/rustdoc-html/unsafe-binder.rs
similarity index 100%
rename from tests/rustdoc/unsafe-binder.rs
rename to tests/rustdoc-html/unsafe-binder.rs
diff --git a/tests/rustdoc/use-attr.rs b/tests/rustdoc-html/use-attr.rs
similarity index 100%
rename from tests/rustdoc/use-attr.rs
rename to tests/rustdoc-html/use-attr.rs
diff --git a/tests/rustdoc/useless_lifetime_bound.rs b/tests/rustdoc-html/useless_lifetime_bound.rs
similarity index 100%
rename from tests/rustdoc/useless_lifetime_bound.rs
rename to tests/rustdoc-html/useless_lifetime_bound.rs
diff --git a/tests/rustdoc/variadic.rs b/tests/rustdoc-html/variadic.rs
similarity index 100%
rename from tests/rustdoc/variadic.rs
rename to tests/rustdoc-html/variadic.rs
diff --git a/tests/rustdoc/viewpath-rename.rs b/tests/rustdoc-html/viewpath-rename.rs
similarity index 100%
rename from tests/rustdoc/viewpath-rename.rs
rename to tests/rustdoc-html/viewpath-rename.rs
diff --git a/tests/rustdoc/viewpath-self.rs b/tests/rustdoc-html/viewpath-self.rs
similarity index 100%
rename from tests/rustdoc/viewpath-self.rs
rename to tests/rustdoc-html/viewpath-self.rs
diff --git a/tests/rustdoc/visibility.rs b/tests/rustdoc-html/visibility.rs
similarity index 100%
rename from tests/rustdoc/visibility.rs
rename to tests/rustdoc-html/visibility.rs
diff --git a/tests/rustdoc/where-clause-order.rs b/tests/rustdoc-html/where-clause-order.rs
similarity index 100%
rename from tests/rustdoc/where-clause-order.rs
rename to tests/rustdoc-html/where-clause-order.rs
diff --git a/tests/rustdoc/where-sized.rs b/tests/rustdoc-html/where-sized.rs
similarity index 100%
rename from tests/rustdoc/where-sized.rs
rename to tests/rustdoc-html/where-sized.rs
diff --git a/tests/rustdoc/where.SWhere_Echo_impl.html b/tests/rustdoc-html/where.SWhere_Echo_impl.html
similarity index 100%
rename from tests/rustdoc/where.SWhere_Echo_impl.html
rename to tests/rustdoc-html/where.SWhere_Echo_impl.html
diff --git a/tests/rustdoc/where.SWhere_Simd_item-decl.html b/tests/rustdoc-html/where.SWhere_Simd_item-decl.html
similarity index 100%
rename from tests/rustdoc/where.SWhere_Simd_item-decl.html
rename to tests/rustdoc-html/where.SWhere_Simd_item-decl.html
diff --git a/tests/rustdoc/where.SWhere_TraitWhere_item-decl.html b/tests/rustdoc-html/where.SWhere_TraitWhere_item-decl.html
similarity index 100%
rename from tests/rustdoc/where.SWhere_TraitWhere_item-decl.html
rename to tests/rustdoc-html/where.SWhere_TraitWhere_item-decl.html
diff --git a/tests/rustdoc/where.alpha_trait_decl.html b/tests/rustdoc-html/where.alpha_trait_decl.html
similarity index 100%
rename from tests/rustdoc/where.alpha_trait_decl.html
rename to tests/rustdoc-html/where.alpha_trait_decl.html
diff --git a/tests/rustdoc/where.bravo_trait_decl.html b/tests/rustdoc-html/where.bravo_trait_decl.html
similarity index 100%
rename from tests/rustdoc/where.bravo_trait_decl.html
rename to tests/rustdoc-html/where.bravo_trait_decl.html
diff --git a/tests/rustdoc/where.charlie_fn_decl.html b/tests/rustdoc-html/where.charlie_fn_decl.html
similarity index 100%
rename from tests/rustdoc/where.charlie_fn_decl.html
rename to tests/rustdoc-html/where.charlie_fn_decl.html
diff --git a/tests/rustdoc/where.golf_type_alias_decl.html b/tests/rustdoc-html/where.golf_type_alias_decl.html
similarity index 100%
rename from tests/rustdoc/where.golf_type_alias_decl.html
rename to tests/rustdoc-html/where.golf_type_alias_decl.html
diff --git a/tests/rustdoc/where.rs b/tests/rustdoc-html/where.rs
similarity index 100%
rename from tests/rustdoc/where.rs
rename to tests/rustdoc-html/where.rs
diff --git a/tests/rustdoc/whitespace-after-where-clause.enum.html b/tests/rustdoc-html/whitespace-after-where-clause.enum.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.enum.html
rename to tests/rustdoc-html/whitespace-after-where-clause.enum.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.enum2.html b/tests/rustdoc-html/whitespace-after-where-clause.enum2.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.enum2.html
rename to tests/rustdoc-html/whitespace-after-where-clause.enum2.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.rs b/tests/rustdoc-html/whitespace-after-where-clause.rs
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.rs
rename to tests/rustdoc-html/whitespace-after-where-clause.rs
diff --git a/tests/rustdoc/whitespace-after-where-clause.struct.html b/tests/rustdoc-html/whitespace-after-where-clause.struct.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.struct.html
rename to tests/rustdoc-html/whitespace-after-where-clause.struct.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.struct2.html b/tests/rustdoc-html/whitespace-after-where-clause.struct2.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.struct2.html
rename to tests/rustdoc-html/whitespace-after-where-clause.struct2.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.trait.html b/tests/rustdoc-html/whitespace-after-where-clause.trait.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.trait.html
rename to tests/rustdoc-html/whitespace-after-where-clause.trait.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.trait2.html b/tests/rustdoc-html/whitespace-after-where-clause.trait2.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.trait2.html
rename to tests/rustdoc-html/whitespace-after-where-clause.trait2.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.union.html b/tests/rustdoc-html/whitespace-after-where-clause.union.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.union.html
rename to tests/rustdoc-html/whitespace-after-where-clause.union.html
diff --git a/tests/rustdoc/whitespace-after-where-clause.union2.html b/tests/rustdoc-html/whitespace-after-where-clause.union2.html
similarity index 100%
rename from tests/rustdoc/whitespace-after-where-clause.union2.html
rename to tests/rustdoc-html/whitespace-after-where-clause.union2.html
diff --git a/tests/rustdoc/without-redirect.rs b/tests/rustdoc-html/without-redirect.rs
similarity index 100%
rename from tests/rustdoc/without-redirect.rs
rename to tests/rustdoc-html/without-redirect.rs
diff --git a/tests/rustdoc/wrapping.rs b/tests/rustdoc-html/wrapping.rs
similarity index 100%
rename from tests/rustdoc/wrapping.rs
rename to tests/rustdoc-html/wrapping.rs
diff --git a/tests/rustdoc-ui/associated-constant-not-allowed-102467.rs b/tests/rustdoc-ui/associated-constant-not-allowed-102467.rs
index c4bbcfc2b077..5b8a90d64121 100644
--- a/tests/rustdoc-ui/associated-constant-not-allowed-102467.rs
+++ b/tests/rustdoc-ui/associated-constant-not-allowed-102467.rs
@@ -2,7 +2,7 @@
 // It ensures that the expected error is displayed.
 
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait T {
     type A: S<C<X = 0i32> = 34>;
diff --git a/tests/rustdoc-ui/intra-doc/deprecated.rs b/tests/rustdoc-ui/intra-doc/deprecated.rs
new file mode 100644
index 000000000000..37c27dcde598
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/deprecated.rs
@@ -0,0 +1,10 @@
+#![deny(rustdoc::broken_intra_doc_links)]
+
+#[deprecated = "[broken cross-reference](TypeAlias::hoge)"] //~ ERROR
+pub struct A;
+
+#[deprecated(since = "0.0.0", note = "[broken cross-reference](TypeAlias::hoge)")] //~ ERROR
+pub struct B1;
+
+#[deprecated(note = "[broken cross-reference](TypeAlias::hoge)", since = "0.0.0")] //~ ERROR
+pub struct B2;
diff --git a/tests/rustdoc-ui/intra-doc/deprecated.stderr b/tests/rustdoc-ui/intra-doc/deprecated.stderr
new file mode 100644
index 000000000000..9bd64544eef8
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/deprecated.stderr
@@ -0,0 +1,43 @@
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:3:1
+   |
+LL | #[deprecated = "[broken cross-reference](TypeAlias::hoge)"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+note: the lint level is defined here
+  --> $DIR/deprecated.rs:1:9
+   |
+LL | #![deny(rustdoc::broken_intra_doc_links)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:6:1
+   |
+LL | #[deprecated(since = "0.0.0", note = "[broken cross-reference](TypeAlias::hoge)")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:9:1
+   |
+LL | #[deprecated(note = "[broken cross-reference](TypeAlias::hoge)", since = "0.0.0")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/abi/cannot-be-called.amdgpu.stderr b/tests/ui/abi/cannot-be-called.amdgpu.stderr
new file mode 100644
index 000000000000..039e2d7b4f00
--- /dev/null
+++ b/tests/ui/abi/cannot-be-called.amdgpu.stderr
@@ -0,0 +1,87 @@
+error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:43:8
+   |
+LL | extern "msp430-interrupt" fn msp430() {}
+   |        ^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "avr-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:45:8
+   |
+LL | extern "avr-interrupt" fn avr() {}
+   |        ^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:47:8
+   |
+LL | extern "riscv-interrupt-m" fn riscv_m() {}
+   |        ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:49:8
+   |
+LL | extern "riscv-interrupt-s" fn riscv_s() {}
+   |        ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "x86-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:51:8
+   |
+LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
+   |        ^^^^^^^^^^^^^^^
+
+error[E0570]: "avr-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:76:22
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |                      ^^^^^^^^^^^^^^^
+
+error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:82:25
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                         ^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:88:26
+   |
+LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                          ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:94:26
+   |
+LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
+   |                          ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "x86-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:100:22
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |                      ^^^^^^^^^^^^^^^
+
+error: functions with the "gpu-kernel" ABI cannot be called
+  --> $DIR/cannot-be-called.rs:70:5
+   |
+LL |     gpu_kernel();
+   |     ^^^^^^^^^^^^
+   |
+note: an `extern "gpu-kernel"` function must be launched on the GPU by the runtime
+  --> $DIR/cannot-be-called.rs:70:5
+   |
+LL |     gpu_kernel();
+   |     ^^^^^^^^^^^^
+
+error: functions with the "gpu-kernel" ABI cannot be called
+  --> $DIR/cannot-be-called.rs:108:5
+   |
+LL |     f()
+   |     ^^^
+   |
+note: an `extern "gpu-kernel"` function must be launched on the GPU by the runtime
+  --> $DIR/cannot-be-called.rs:108:5
+   |
+LL |     f()
+   |     ^^^
+
+error: aborting due to 12 previous errors
+
+For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.avr.stderr b/tests/ui/abi/cannot-be-called.avr.stderr
index 2128991d83cd..752292a58705 100644
--- a/tests/ui/abi/cannot-be-called.avr.stderr
+++ b/tests/ui/abi/cannot-be-called.avr.stderr
@@ -1,75 +1,87 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:42:8
+  --> $DIR/cannot-be-called.rs:47:8
    |
 LL | extern "riscv-interrupt-m" fn riscv_m() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:44:8
+  --> $DIR/cannot-be-called.rs:49:8
    |
 LL | extern "riscv-interrupt-s" fn riscv_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:46:8
+  --> $DIR/cannot-be-called.rs:51:8
    |
 LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
    |        ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:79:26
+  --> $DIR/cannot-be-called.rs:88:26
    |
 LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:85:26
+  --> $DIR/cannot-be-called.rs:94:26
    |
 LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:91:22
+  --> $DIR/cannot-be-called.rs:100:22
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "avr-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:53:5
+  --> $DIR/cannot-be-called.rs:60:5
    |
 LL |     avr();
    |     ^^^^^
    |
 note: an `extern "avr-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:53:5
+  --> $DIR/cannot-be-called.rs:60:5
    |
 LL |     avr();
    |     ^^^^^
 
 error: functions with the "avr-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:69:5
+  --> $DIR/cannot-be-called.rs:78:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "avr-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:69:5
+  --> $DIR/cannot-be-called.rs:78:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.i686.stderr b/tests/ui/abi/cannot-be-called.i686.stderr
index 9b1755921aea..30e294ad61ec 100644
--- a/tests/ui/abi/cannot-be-called.i686.stderr
+++ b/tests/ui/abi/cannot-be-called.i686.stderr
@@ -1,75 +1,87 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:42:8
+  --> $DIR/cannot-be-called.rs:47:8
    |
 LL | extern "riscv-interrupt-m" fn riscv_m() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:44:8
+  --> $DIR/cannot-be-called.rs:49:8
    |
 LL | extern "riscv-interrupt-s" fn riscv_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:79:26
+  --> $DIR/cannot-be-called.rs:88:26
    |
 LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:85:26
+  --> $DIR/cannot-be-called.rs:94:26
    |
 LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.msp430.stderr b/tests/ui/abi/cannot-be-called.msp430.stderr
index 9a047b11cf79..12ab88bc858b 100644
--- a/tests/ui/abi/cannot-be-called.msp430.stderr
+++ b/tests/ui/abi/cannot-be-called.msp430.stderr
@@ -1,75 +1,87 @@
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:42:8
+  --> $DIR/cannot-be-called.rs:47:8
    |
 LL | extern "riscv-interrupt-m" fn riscv_m() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:44:8
+  --> $DIR/cannot-be-called.rs:49:8
    |
 LL | extern "riscv-interrupt-s" fn riscv_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:46:8
+  --> $DIR/cannot-be-called.rs:51:8
    |
 LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
    |        ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:79:26
+  --> $DIR/cannot-be-called.rs:88:26
    |
 LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:85:26
+  --> $DIR/cannot-be-called.rs:94:26
    |
 LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:91:22
+  --> $DIR/cannot-be-called.rs:100:22
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "msp430-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:55:5
+  --> $DIR/cannot-be-called.rs:62:5
    |
 LL |     msp430();
    |     ^^^^^^^^
    |
 note: an `extern "msp430-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:55:5
+  --> $DIR/cannot-be-called.rs:62:5
    |
 LL |     msp430();
    |     ^^^^^^^^
 
 error: functions with the "msp430-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:75:5
+  --> $DIR/cannot-be-called.rs:84:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "msp430-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:75:5
+  --> $DIR/cannot-be-called.rs:84:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.nvptx.stderr b/tests/ui/abi/cannot-be-called.nvptx.stderr
new file mode 100644
index 000000000000..039e2d7b4f00
--- /dev/null
+++ b/tests/ui/abi/cannot-be-called.nvptx.stderr
@@ -0,0 +1,87 @@
+error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:43:8
+   |
+LL | extern "msp430-interrupt" fn msp430() {}
+   |        ^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "avr-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:45:8
+   |
+LL | extern "avr-interrupt" fn avr() {}
+   |        ^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:47:8
+   |
+LL | extern "riscv-interrupt-m" fn riscv_m() {}
+   |        ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:49:8
+   |
+LL | extern "riscv-interrupt-s" fn riscv_s() {}
+   |        ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "x86-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:51:8
+   |
+LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
+   |        ^^^^^^^^^^^^^^^
+
+error[E0570]: "avr-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:76:22
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |                      ^^^^^^^^^^^^^^^
+
+error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:82:25
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                         ^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:88:26
+   |
+LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                          ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:94:26
+   |
+LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
+   |                          ^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: "x86-interrupt" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:100:22
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |                      ^^^^^^^^^^^^^^^
+
+error: functions with the "gpu-kernel" ABI cannot be called
+  --> $DIR/cannot-be-called.rs:70:5
+   |
+LL |     gpu_kernel();
+   |     ^^^^^^^^^^^^
+   |
+note: an `extern "gpu-kernel"` function must be launched on the GPU by the runtime
+  --> $DIR/cannot-be-called.rs:70:5
+   |
+LL |     gpu_kernel();
+   |     ^^^^^^^^^^^^
+
+error: functions with the "gpu-kernel" ABI cannot be called
+  --> $DIR/cannot-be-called.rs:108:5
+   |
+LL |     f()
+   |     ^^^
+   |
+note: an `extern "gpu-kernel"` function must be launched on the GPU by the runtime
+  --> $DIR/cannot-be-called.rs:108:5
+   |
+LL |     f()
+   |     ^^^
+
+error: aborting due to 12 previous errors
+
+For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.riscv32.stderr b/tests/ui/abi/cannot-be-called.riscv32.stderr
index 135b20c50d58..b1897b74ebbe 100644
--- a/tests/ui/abi/cannot-be-called.riscv32.stderr
+++ b/tests/ui/abi/cannot-be-called.riscv32.stderr
@@ -1,87 +1,99 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:46:8
+  --> $DIR/cannot-be-called.rs:51:8
    |
 LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
    |        ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:91:22
+  --> $DIR/cannot-be-called.rs:100:22
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "riscv-interrupt-m" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:57:5
+  --> $DIR/cannot-be-called.rs:64:5
    |
 LL |     riscv_m();
    |     ^^^^^^^^^
    |
 note: an `extern "riscv-interrupt-m"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:57:5
+  --> $DIR/cannot-be-called.rs:64:5
    |
 LL |     riscv_m();
    |     ^^^^^^^^^
 
 error: functions with the "riscv-interrupt-s" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:59:5
+  --> $DIR/cannot-be-called.rs:66:5
    |
 LL |     riscv_s();
    |     ^^^^^^^^^
    |
 note: an `extern "riscv-interrupt-s"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:59:5
+  --> $DIR/cannot-be-called.rs:66:5
    |
 LL |     riscv_s();
    |     ^^^^^^^^^
 
 error: functions with the "riscv-interrupt-m" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:81:5
+  --> $DIR/cannot-be-called.rs:90:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "riscv-interrupt-m"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:81:5
+  --> $DIR/cannot-be-called.rs:90:5
    |
 LL |     f()
    |     ^^^
 
 error: functions with the "riscv-interrupt-s" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:87:5
+  --> $DIR/cannot-be-called.rs:96:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "riscv-interrupt-s"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:87:5
+  --> $DIR/cannot-be-called.rs:96:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.riscv64.stderr b/tests/ui/abi/cannot-be-called.riscv64.stderr
index 135b20c50d58..b1897b74ebbe 100644
--- a/tests/ui/abi/cannot-be-called.riscv64.stderr
+++ b/tests/ui/abi/cannot-be-called.riscv64.stderr
@@ -1,87 +1,99 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:46:8
+  --> $DIR/cannot-be-called.rs:51:8
    |
 LL | extern "x86-interrupt" fn x86(_x: *const u8) {}
    |        ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "x86-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:91:22
+  --> $DIR/cannot-be-called.rs:100:22
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "riscv-interrupt-m" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:57:5
+  --> $DIR/cannot-be-called.rs:64:5
    |
 LL |     riscv_m();
    |     ^^^^^^^^^
    |
 note: an `extern "riscv-interrupt-m"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:57:5
+  --> $DIR/cannot-be-called.rs:64:5
    |
 LL |     riscv_m();
    |     ^^^^^^^^^
 
 error: functions with the "riscv-interrupt-s" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:59:5
+  --> $DIR/cannot-be-called.rs:66:5
    |
 LL |     riscv_s();
    |     ^^^^^^^^^
    |
 note: an `extern "riscv-interrupt-s"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:59:5
+  --> $DIR/cannot-be-called.rs:66:5
    |
 LL |     riscv_s();
    |     ^^^^^^^^^
 
 error: functions with the "riscv-interrupt-m" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:81:5
+  --> $DIR/cannot-be-called.rs:90:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "riscv-interrupt-m"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:81:5
+  --> $DIR/cannot-be-called.rs:90:5
    |
 LL |     f()
    |     ^^^
 
 error: functions with the "riscv-interrupt-s" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:87:5
+  --> $DIR/cannot-be-called.rs:96:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "riscv-interrupt-s"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:87:5
+  --> $DIR/cannot-be-called.rs:96:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.rs b/tests/ui/abi/cannot-be-called.rs
index 315ea1601633..8d1a4ae0b557 100644
--- a/tests/ui/abi/cannot-be-called.rs
+++ b/tests/ui/abi/cannot-be-called.rs
@@ -4,7 +4,7 @@ Interrupt ABIs share similar semantics, in that they are special entry-points un
 So we test that they error in essentially all of the same places.
 */
 //@ add-minicore
-//@ revisions: x64 x64_win i686 riscv32 riscv64 avr msp430
+//@ revisions: x64 x64_win i686 riscv32 riscv64 avr msp430 amdgpu nvptx
 //
 //@ [x64] needs-llvm-components: x86
 //@ [x64] compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib
@@ -20,6 +20,10 @@ So we test that they error in essentially all of the same places.
 //@ [avr] compile-flags: --target=avr-none -C target-cpu=atmega328p --crate-type=rlib
 //@ [msp430] needs-llvm-components: msp430
 //@ [msp430] compile-flags: --target=msp430-none-elf --crate-type=rlib
+//@ [amdgpu] needs-llvm-components: amdgpu
+//@ [amdgpu] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900 --crate-type=rlib
+//@ [nvptx] needs-llvm-components: nvptx
+//@ [nvptx] compile-flags: --target nvptx64-nvidia-cuda --crate-type=rlib
 //@ ignore-backends: gcc
 #![no_core]
 #![feature(
@@ -27,7 +31,8 @@ So we test that they error in essentially all of the same places.
     abi_msp430_interrupt,
     abi_avr_interrupt,
     abi_x86_interrupt,
-    abi_riscv_interrupt
+    abi_riscv_interrupt,
+    abi_gpu_kernel
 )]
 
 extern crate minicore;
@@ -36,15 +41,17 @@ use minicore::*;
 /* extern "interrupt" definition */
 
 extern "msp430-interrupt" fn msp430() {}
-//[x64,x64_win,i686,riscv32,riscv64,avr]~^ ERROR is not a supported ABI
+//[x64,x64_win,i686,riscv32,riscv64,avr,amdgpu,nvptx]~^ ERROR is not a supported ABI
 extern "avr-interrupt" fn avr() {}
-//[x64,x64_win,i686,riscv32,riscv64,msp430]~^ ERROR is not a supported ABI
+//[x64,x64_win,i686,riscv32,riscv64,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
 extern "riscv-interrupt-m" fn riscv_m() {}
-//[x64,x64_win,i686,avr,msp430]~^ ERROR is not a supported ABI
+//[x64,x64_win,i686,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
 extern "riscv-interrupt-s" fn riscv_s() {}
-//[x64,x64_win,i686,avr,msp430]~^ ERROR is not a supported ABI
+//[x64,x64_win,i686,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
 extern "x86-interrupt" fn x86(_x: *const u8) {}
-//[riscv32,riscv64,avr,msp430]~^ ERROR is not a supported ABI
+//[riscv32,riscv64,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
+extern "gpu-kernel" fn gpu_kernel() {}
+//[x64,x64_win,i686,riscv32,riscv64,avr,msp430]~^ ERROR is not a supported ABI
 
 static BYTE: u8 = 0;
 
@@ -60,36 +67,44 @@ fn call_the_interrupts() {
     //[riscv32,riscv64]~^ ERROR functions with the "riscv-interrupt-s" ABI cannot be called
     x86(&raw const BYTE);
     //[x64,x64_win,i686]~^ ERROR functions with the "x86-interrupt" ABI cannot be called
+    gpu_kernel();
+    //[amdgpu,nvptx]~^ ERROR functions with the "gpu-kernel" ABI cannot be called
 }
 
 /* extern "interrupt" fnptr calls */
 
 fn avr_ptr(f: extern "avr-interrupt" fn()) {
-    //[x64,x64_win,i686,riscv32,riscv64,msp430]~^ ERROR is not a supported ABI
+    //[x64,x64_win,i686,riscv32,riscv64,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
     f()
     //[avr]~^ ERROR functions with the "avr-interrupt" ABI cannot be called
 }
 
 fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
-    //[x64,x64_win,i686,riscv32,riscv64,avr]~^ ERROR is not a supported ABI
+    //[x64,x64_win,i686,riscv32,riscv64,avr,amdgpu,nvptx]~^ ERROR is not a supported ABI
     f()
     //[msp430]~^ ERROR functions with the "msp430-interrupt" ABI cannot be called
 }
 
 fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
-    //[x64,x64_win,i686,avr,msp430]~^ ERROR is not a supported ABI
+    //[x64,x64_win,i686,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
     f()
     //[riscv32,riscv64]~^ ERROR functions with the "riscv-interrupt-m" ABI cannot be called
 }
 
 fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
-    //[x64,x64_win,i686,avr,msp430]~^ ERROR is not a supported ABI
+    //[x64,x64_win,i686,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
     f()
     //[riscv32,riscv64]~^ ERROR functions with the "riscv-interrupt-s" ABI cannot be called
 }
 
 fn x86_ptr(f: extern "x86-interrupt" fn()) {
-    //[riscv32,riscv64,avr,msp430]~^ ERROR is not a supported ABI
+    //[riscv32,riscv64,avr,msp430,amdgpu,nvptx]~^ ERROR is not a supported ABI
     f()
     //[x64,x64_win,i686]~^ ERROR functions with the "x86-interrupt" ABI cannot be called
 }
+
+fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+    //[x64,x64_win,i686,riscv32,riscv64,avr,msp430]~^ ERROR is not a supported ABI
+    f()
+    //[amdgpu,nvptx]~^ ERROR functions with the "gpu-kernel" ABI cannot be called
+}
diff --git a/tests/ui/abi/cannot-be-called.x64.stderr b/tests/ui/abi/cannot-be-called.x64.stderr
index 9b1755921aea..30e294ad61ec 100644
--- a/tests/ui/abi/cannot-be-called.x64.stderr
+++ b/tests/ui/abi/cannot-be-called.x64.stderr
@@ -1,75 +1,87 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:42:8
+  --> $DIR/cannot-be-called.rs:47:8
    |
 LL | extern "riscv-interrupt-m" fn riscv_m() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:44:8
+  --> $DIR/cannot-be-called.rs:49:8
    |
 LL | extern "riscv-interrupt-s" fn riscv_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:79:26
+  --> $DIR/cannot-be-called.rs:88:26
    |
 LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:85:26
+  --> $DIR/cannot-be-called.rs:94:26
    |
 LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-called.x64_win.stderr b/tests/ui/abi/cannot-be-called.x64_win.stderr
index 9b1755921aea..30e294ad61ec 100644
--- a/tests/ui/abi/cannot-be-called.x64_win.stderr
+++ b/tests/ui/abi/cannot-be-called.x64_win.stderr
@@ -1,75 +1,87 @@
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:38:8
+  --> $DIR/cannot-be-called.rs:43:8
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:40:8
+  --> $DIR/cannot-be-called.rs:45:8
    |
 LL | extern "avr-interrupt" fn avr() {}
    |        ^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:42:8
+  --> $DIR/cannot-be-called.rs:47:8
    |
 LL | extern "riscv-interrupt-m" fn riscv_m() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:44:8
+  --> $DIR/cannot-be-called.rs:49:8
    |
 LL | extern "riscv-interrupt-s" fn riscv_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:53:8
+   |
+LL | extern "gpu-kernel" fn gpu_kernel() {}
+   |        ^^^^^^^^^^^^
+
 error[E0570]: "avr-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:67:22
+  --> $DIR/cannot-be-called.rs:76:22
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |                      ^^^^^^^^^^^^^^^
 
 error[E0570]: "msp430-interrupt" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:73:25
+  --> $DIR/cannot-be-called.rs:82:25
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                         ^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-m" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:79:26
+  --> $DIR/cannot-be-called.rs:88:26
    |
 LL | fn riscv_m_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: "riscv-interrupt-s" is not a supported ABI for the current target
-  --> $DIR/cannot-be-called.rs:85:26
+  --> $DIR/cannot-be-called.rs:94:26
    |
 LL | fn riscv_s_ptr(f: extern "riscv-interrupt-s" fn()) {
    |                          ^^^^^^^^^^^^^^^^^^^
 
+error[E0570]: "gpu-kernel" is not a supported ABI for the current target
+  --> $DIR/cannot-be-called.rs:106:29
+   |
+LL | fn gpu_kernel_ptr(f: extern "gpu-kernel" fn()) {
+   |                             ^^^^^^^^^^^^
+
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:61:5
+  --> $DIR/cannot-be-called.rs:68:5
    |
 LL |     x86(&raw const BYTE);
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: functions with the "x86-interrupt" ABI cannot be called
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
    |
 note: an `extern "x86-interrupt"` function can only be called using inline assembly
-  --> $DIR/cannot-be-called.rs:93:5
+  --> $DIR/cannot-be-called.rs:102:5
    |
 LL |     f()
    |     ^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0570`.
diff --git a/tests/ui/abi/cannot-be-coroutine.amdgpu.stderr b/tests/ui/abi/cannot-be-coroutine.amdgpu.stderr
new file mode 100644
index 000000000000..a36ea0caa19e
--- /dev/null
+++ b/tests/ui/abi/cannot-be-coroutine.amdgpu.stderr
@@ -0,0 +1,23 @@
+error: functions with the "gpu-kernel" ABI cannot be `async`
+  --> $DIR/cannot-be-coroutine.rs:62:1
+   |
+LL | async extern "gpu-kernel" fn async_kernel() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `async` keyword from this definition
+   |
+LL - async extern "gpu-kernel" fn async_kernel() {
+LL + extern "gpu-kernel" fn async_kernel() {
+   |
+
+error: requires `ResumeTy` lang_item
+  --> $DIR/cannot-be-coroutine.rs:38:19
+   |
+LL |   async fn vanilla(){
+   |  ___________________^
+LL | |
+LL | | }
+   | |_^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/abi/cannot-be-coroutine.avr.stderr b/tests/ui/abi/cannot-be-coroutine.avr.stderr
index 11bc93b1eef1..643a575bece1 100644
--- a/tests/ui/abi/cannot-be-coroutine.avr.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.avr.stderr
@@ -1,5 +1,5 @@
 error: functions with the "avr-interrupt" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:37:1
+  --> $DIR/cannot-be-coroutine.rs:42:1
    |
 LL | async extern "avr-interrupt" fn avr() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "avr-interrupt" fn avr() {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.i686.stderr b/tests/ui/abi/cannot-be-coroutine.i686.stderr
index 4a344bb09020..f618507df47d 100644
--- a/tests/ui/abi/cannot-be-coroutine.i686.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.i686.stderr
@@ -1,5 +1,5 @@
 error: functions with the "x86-interrupt" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:53:1
+  --> $DIR/cannot-be-coroutine.rs:58:1
    |
 LL | async extern "x86-interrupt" fn x86(_p: *mut ()) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "x86-interrupt" fn x86(_p: *mut ()) {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.msp430.stderr b/tests/ui/abi/cannot-be-coroutine.msp430.stderr
index c2867705df78..f2586c8cd975 100644
--- a/tests/ui/abi/cannot-be-coroutine.msp430.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.msp430.stderr
@@ -1,5 +1,5 @@
 error: functions with the "msp430-interrupt" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:41:1
+  --> $DIR/cannot-be-coroutine.rs:46:1
    |
 LL | async extern "msp430-interrupt" fn msp430() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "msp430-interrupt" fn msp430() {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.nvptx.stderr b/tests/ui/abi/cannot-be-coroutine.nvptx.stderr
new file mode 100644
index 000000000000..a36ea0caa19e
--- /dev/null
+++ b/tests/ui/abi/cannot-be-coroutine.nvptx.stderr
@@ -0,0 +1,23 @@
+error: functions with the "gpu-kernel" ABI cannot be `async`
+  --> $DIR/cannot-be-coroutine.rs:62:1
+   |
+LL | async extern "gpu-kernel" fn async_kernel() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `async` keyword from this definition
+   |
+LL - async extern "gpu-kernel" fn async_kernel() {
+LL + extern "gpu-kernel" fn async_kernel() {
+   |
+
+error: requires `ResumeTy` lang_item
+  --> $DIR/cannot-be-coroutine.rs:38:19
+   |
+LL |   async fn vanilla(){
+   |  ___________________^
+LL | |
+LL | | }
+   | |_^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/abi/cannot-be-coroutine.riscv32.stderr b/tests/ui/abi/cannot-be-coroutine.riscv32.stderr
index 398f888205df..c5a8c3f60a38 100644
--- a/tests/ui/abi/cannot-be-coroutine.riscv32.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.riscv32.stderr
@@ -1,5 +1,5 @@
 error: functions with the "riscv-interrupt-m" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:45:1
+  --> $DIR/cannot-be-coroutine.rs:50:1
    |
 LL | async extern "riscv-interrupt-m" fn riscv_m() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "riscv-interrupt-m" fn riscv_m() {
    |
 
 error: functions with the "riscv-interrupt-s" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:49:1
+  --> $DIR/cannot-be-coroutine.rs:54:1
    |
 LL | async extern "riscv-interrupt-s" fn riscv_s() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL + extern "riscv-interrupt-s" fn riscv_s() {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.riscv64.stderr b/tests/ui/abi/cannot-be-coroutine.riscv64.stderr
index 398f888205df..c5a8c3f60a38 100644
--- a/tests/ui/abi/cannot-be-coroutine.riscv64.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.riscv64.stderr
@@ -1,5 +1,5 @@
 error: functions with the "riscv-interrupt-m" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:45:1
+  --> $DIR/cannot-be-coroutine.rs:50:1
    |
 LL | async extern "riscv-interrupt-m" fn riscv_m() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "riscv-interrupt-m" fn riscv_m() {
    |
 
 error: functions with the "riscv-interrupt-s" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:49:1
+  --> $DIR/cannot-be-coroutine.rs:54:1
    |
 LL | async extern "riscv-interrupt-s" fn riscv_s() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL + extern "riscv-interrupt-s" fn riscv_s() {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.rs b/tests/ui/abi/cannot-be-coroutine.rs
index c070e8032e1a..239f5aa5c31f 100644
--- a/tests/ui/abi/cannot-be-coroutine.rs
+++ b/tests/ui/abi/cannot-be-coroutine.rs
@@ -1,6 +1,6 @@
 //@ add-minicore
 //@ edition: 2021
-//@ revisions: x64 x64_win i686 riscv32 riscv64 avr msp430
+//@ revisions: x64 x64_win i686 riscv32 riscv64 avr msp430 amdgpu nvptx
 //
 //@ [x64] needs-llvm-components: x86
 //@ [x64] compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib
@@ -16,6 +16,10 @@
 //@ [avr] compile-flags: --target=avr-none -C target-cpu=atmega328p --crate-type=rlib
 //@ [msp430] needs-llvm-components: msp430
 //@ [msp430] compile-flags: --target=msp430-none-elf --crate-type=rlib
+//@ [amdgpu] needs-llvm-components: amdgpu
+//@ [amdgpu] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900 --crate-type=rlib
+//@ [nvptx] needs-llvm-components: nvptx
+//@ [nvptx] compile-flags: --target nvptx64-nvidia-cuda --crate-type=rlib
 //@ ignore-backends: gcc
 #![no_core]
 #![feature(
@@ -23,7 +27,8 @@
     abi_msp430_interrupt,
     abi_avr_interrupt,
     abi_x86_interrupt,
-    abi_riscv_interrupt
+    abi_riscv_interrupt,
+    abi_gpu_kernel
 )]
 
 extern crate minicore;
@@ -53,3 +58,7 @@ async extern "riscv-interrupt-s" fn riscv_s() {
 async extern "x86-interrupt" fn x86(_p: *mut ()) {
     //[x64,x64_win,i686]~^ ERROR functions with the "x86-interrupt" ABI cannot be `async`
 }
+
+async extern "gpu-kernel" fn async_kernel() {
+    //[amdgpu,nvptx]~^ ERROR functions with the "gpu-kernel" ABI cannot be `async`
+}
diff --git a/tests/ui/abi/cannot-be-coroutine.x64.stderr b/tests/ui/abi/cannot-be-coroutine.x64.stderr
index 4a344bb09020..f618507df47d 100644
--- a/tests/ui/abi/cannot-be-coroutine.x64.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.x64.stderr
@@ -1,5 +1,5 @@
 error: functions with the "x86-interrupt" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:53:1
+  --> $DIR/cannot-be-coroutine.rs:58:1
    |
 LL | async extern "x86-interrupt" fn x86(_p: *mut ()) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "x86-interrupt" fn x86(_p: *mut ()) {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-be-coroutine.x64_win.stderr b/tests/ui/abi/cannot-be-coroutine.x64_win.stderr
index 4a344bb09020..f618507df47d 100644
--- a/tests/ui/abi/cannot-be-coroutine.x64_win.stderr
+++ b/tests/ui/abi/cannot-be-coroutine.x64_win.stderr
@@ -1,5 +1,5 @@
 error: functions with the "x86-interrupt" ABI cannot be `async`
-  --> $DIR/cannot-be-coroutine.rs:53:1
+  --> $DIR/cannot-be-coroutine.rs:58:1
    |
 LL | async extern "x86-interrupt" fn x86(_p: *mut ()) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL + extern "x86-interrupt" fn x86(_p: *mut ()) {
    |
 
 error: requires `ResumeTy` lang_item
-  --> $DIR/cannot-be-coroutine.rs:33:19
+  --> $DIR/cannot-be-coroutine.rs:38:19
    |
 LL |   async fn vanilla(){
    |  ___________________^
diff --git a/tests/ui/abi/cannot-return.amdgpu.stderr b/tests/ui/abi/cannot-return.amdgpu.stderr
new file mode 100644
index 000000000000..f264907d00ec
--- /dev/null
+++ b/tests/ui/abi/cannot-return.amdgpu.stderr
@@ -0,0 +1,15 @@
+error: invalid signature for `extern "gpu-kernel"` function
+  --> $DIR/cannot-return.rs:17:37
+   |
+LL | extern "gpu-kernel" fn ret_i32() -> i32 { 0 }
+   |                                     ^^^
+   |
+   = note: functions with the "gpu-kernel" ABI cannot have a return type
+help: remove the return type
+  --> $DIR/cannot-return.rs:17:37
+   |
+LL | extern "gpu-kernel" fn ret_i32() -> i32 { 0 }
+   |                                     ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/cannot-return.nvptx.stderr b/tests/ui/abi/cannot-return.nvptx.stderr
new file mode 100644
index 000000000000..f264907d00ec
--- /dev/null
+++ b/tests/ui/abi/cannot-return.nvptx.stderr
@@ -0,0 +1,15 @@
+error: invalid signature for `extern "gpu-kernel"` function
+  --> $DIR/cannot-return.rs:17:37
+   |
+LL | extern "gpu-kernel" fn ret_i32() -> i32 { 0 }
+   |                                     ^^^
+   |
+   = note: functions with the "gpu-kernel" ABI cannot have a return type
+help: remove the return type
+  --> $DIR/cannot-return.rs:17:37
+   |
+LL | extern "gpu-kernel" fn ret_i32() -> i32 { 0 }
+   |                                     ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/cannot-return.rs b/tests/ui/abi/cannot-return.rs
new file mode 100644
index 000000000000..9a5db30431b9
--- /dev/null
+++ b/tests/ui/abi/cannot-return.rs
@@ -0,0 +1,18 @@
+//@ add-minicore
+//@ ignore-backends: gcc
+//@ edition: 2024
+//@ revisions: amdgpu nvptx
+//
+//@ [amdgpu] needs-llvm-components: amdgpu
+//@ [amdgpu] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900 --crate-type=rlib
+//@ [nvptx] needs-llvm-components: nvptx
+//@ [nvptx] compile-flags: --target nvptx64-nvidia-cuda --crate-type=rlib
+#![no_core]
+#![feature(no_core, abi_gpu_kernel)]
+
+extern crate minicore;
+use minicore::*;
+
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn ret_i32() -> i32 { 0 }
+//~^ ERROR invalid signature for `extern "gpu-kernel"` function
diff --git a/tests/ui/abi/issues/issue-22565-rust-call.stderr b/tests/ui/abi/issues/issue-22565-rust-call.stderr
index 0fd3285cd3a5..3e296bdaea41 100644
--- a/tests/ui/abi/issues/issue-22565-rust-call.stderr
+++ b/tests/ui/abi/issues/issue-22565-rust-call.stderr
@@ -2,7 +2,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/issue-22565-rust-call.rs:3:1
    |
 LL | extern "rust-call" fn b(_i: i32) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/issue-22565-rust-call.rs:17:5
@@ -32,7 +32,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/issue-22565-rust-call.rs:27:7
    |
 LL |     b(10);
-   |       ^^ the trait `Tuple` is not implemented for `i32`
+   |       ^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/issue-22565-rust-call.rs:29:5
diff --git a/tests/ui/associated-consts/assoc-const-eq-ambiguity.rs b/tests/ui/associated-consts/assoc-const-eq-ambiguity.rs
index 27261a4806eb..6bc2a6d5d153 100644
--- a/tests/ui/associated-consts/assoc-const-eq-ambiguity.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-ambiguity.rs
@@ -1,7 +1,7 @@
 // We used to say "ambiguous associated type" on ambiguous associated consts.
 // Ensure that we now use the correct label.
 
-#![feature(associated_const_equality, min_generic_const_args, unsized_const_params)]
+#![feature(min_generic_const_args, unsized_const_params)]
 #![allow(incomplete_features)]
 
 trait Trait0: Parent0<i32> + Parent0<u32> {}
diff --git a/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs b/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs
index 7f8b3036c3e8..803cc59cc93d 100644
--- a/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs
@@ -1,10 +1,10 @@
 // Check that we eventually catch types of assoc const bounds
 // (containing late-bound vars) that are ill-formed.
 #![feature(
-    associated_const_equality,
     min_generic_const_args,
     adt_const_params,
     unsized_const_params,
+    generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty.rs b/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty.rs
index d3975bc19ad3..e6fd5bdad002 100644
--- a/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty.rs
@@ -4,10 +4,10 @@
 //@ check-pass
 
 #![feature(
-    associated_const_equality,
     min_generic_const_args,
     adt_const_params,
     unsized_const_params,
+    generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/associated-consts/assoc-const-eq-const_evaluatable_unchecked.rs b/tests/ui/associated-consts/assoc-const-eq-const_evaluatable_unchecked.rs
index 22a03e47b2f7..161eef63d36f 100644
--- a/tests/ui/associated-consts/assoc-const-eq-const_evaluatable_unchecked.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-const_evaluatable_unchecked.rs
@@ -4,7 +4,7 @@
 //
 // issue: <https://github.com/rust-lang/rust/issues/108220>
 //@ check-pass
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
 pub trait TraitA<T> {
diff --git a/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.rs b/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.rs
index 2571af57e66b..d32737fcb62f 100644
--- a/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.rs
@@ -1,6 +1,10 @@
 // Detect and reject escaping late-bound generic params in
 // the type of assoc consts used in an equality bound.
-#![feature(associated_const_equality, min_generic_const_args, unsized_const_params)]
+#![feature(
+    min_generic_const_args,
+    unsized_const_params,
+    generic_const_parameter_types,
+)]
 #![allow(incomplete_features)]
 
 trait Trait<'a> {
diff --git a/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.stderr b/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.stderr
index 44304443ac54..ef861cb7f49a 100644
--- a/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.stderr
+++ b/tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.stderr
@@ -1,5 +1,5 @@
 error: the type of the associated constant `K` cannot capture late-bound generic parameters
-  --> $DIR/assoc-const-eq-esc-bound-var-in-ty.rs:11:35
+  --> $DIR/assoc-const-eq-esc-bound-var-in-ty.rs:15:35
    |
 LL | fn take(_: impl for<'r> Trait<'r, K = const { &() }>) {}
    |                     --            ^ its type cannot capture the late-bound lifetime parameter `'r`
diff --git a/tests/ui/associated-consts/assoc-const-eq-missing.rs b/tests/ui/associated-consts/assoc-const-eq-missing.rs
index f384927e4a34..22b565cb27d2 100644
--- a/tests/ui/associated-consts/assoc-const-eq-missing.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-missing.rs
@@ -1,5 +1,5 @@
-#![feature(associated_const_equality)]
-#![allow(unused)]
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features, unused)]
 
 pub trait Foo {
   const N: usize;
diff --git a/tests/ui/associated-consts/assoc-const-eq-param-in-ty.rs b/tests/ui/associated-consts/assoc-const-eq-param-in-ty.rs
index 242ad385947a..44e7e3f19ef2 100644
--- a/tests/ui/associated-consts/assoc-const-eq-param-in-ty.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-param-in-ty.rs
@@ -1,10 +1,10 @@
 // Regression test for issue #108271.
 // Detect and reject generic params in the type of assoc consts used in an equality bound.
 #![feature(
-    associated_const_equality,
     min_generic_const_args,
     adt_const_params,
     unsized_const_params,
+    generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/associated-consts/assoc-const-eq-supertraits.rs b/tests/ui/associated-consts/assoc-const-eq-supertraits.rs
index d9b8a8cd43d7..a5f8859c92bd 100644
--- a/tests/ui/associated-consts/assoc-const-eq-supertraits.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-supertraits.rs
@@ -4,10 +4,10 @@
 //@ check-pass
 
 #![feature(
-    associated_const_equality,
     min_generic_const_args,
     adt_const_params,
     unsized_const_params,
+    generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/associated-consts/assoc-const-eq-ty-alias-noninteracting.rs b/tests/ui/associated-consts/assoc-const-eq-ty-alias-noninteracting.rs
index 41857eca87de..004215986711 100644
--- a/tests/ui/associated-consts/assoc-const-eq-ty-alias-noninteracting.rs
+++ b/tests/ui/associated-consts/assoc-const-eq-ty-alias-noninteracting.rs
@@ -5,7 +5,7 @@
 
 //@ check-pass
 
-#![feature(associated_const_equality, min_generic_const_args, unsized_const_params)]
+#![feature(min_generic_const_args, unsized_const_params)]
 #![allow(incomplete_features)]
 
 trait Trait: SuperTrait {
diff --git a/tests/ui/associated-consts/assoc-const-ty-mismatch.rs b/tests/ui/associated-consts/assoc-const-ty-mismatch.rs
index 7211637659bd..1092733a8e2e 100644
--- a/tests/ui/associated-consts/assoc-const-ty-mismatch.rs
+++ b/tests/ui/associated-consts/assoc-const-ty-mismatch.rs
@@ -1,5 +1,5 @@
-#![feature(associated_const_equality)]
-#![allow(unused)]
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features, unused)]
 
 pub trait Foo {
     const N: usize;
diff --git a/tests/ui/associated-consts/assoc-const.rs b/tests/ui/associated-consts/assoc-const.rs
index 6295fd50b8ff..ac9f7e53b3cb 100644
--- a/tests/ui/associated-consts/assoc-const.rs
+++ b/tests/ui/associated-consts/assoc-const.rs
@@ -1,5 +1,5 @@
 //@ run-pass
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(unused, incomplete_features)]
 
 pub trait Foo {
diff --git a/tests/ui/associated-consts/equality-unused-issue-126729.rs b/tests/ui/associated-consts/equality-unused-issue-126729.rs
index 35b49314b5f5..614ed8c803d4 100644
--- a/tests/ui/associated-consts/equality-unused-issue-126729.rs
+++ b/tests/ui/associated-consts/equality-unused-issue-126729.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 #![deny(dead_code)]
 
diff --git a/tests/ui/associated-consts/issue-102335-const.rs b/tests/ui/associated-consts/issue-102335-const.rs
index f9b816fd3bc9..a88a3abf0a12 100644
--- a/tests/ui/associated-consts/issue-102335-const.rs
+++ b/tests/ui/associated-consts/issue-102335-const.rs
@@ -1,4 +1,4 @@
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
 trait T {
diff --git a/tests/ui/associated-consts/issue-105330.stderr b/tests/ui/associated-consts/issue-105330.stderr
index 5d6dc48e36c0..06900404ec34 100644
--- a/tests/ui/associated-consts/issue-105330.stderr
+++ b/tests/ui/associated-consts/issue-105330.stderr
@@ -21,8 +21,8 @@ error[E0658]: associated const equality is incomplete
 LL | fn foo<A: TraitWAssocConst<A=32>>() {
    |                            ^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -31,8 +31,8 @@ error[E0658]: associated const equality is incomplete
 LL | fn main<A: TraitWAssocConst<A=32>>() {
    |                             ^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in impl headers
diff --git a/tests/ui/associated-consts/issue-110933.rs b/tests/ui/associated-consts/issue-110933.rs
index 731ff1564ce2..9a013ee71274 100644
--- a/tests/ui/associated-consts/issue-110933.rs
+++ b/tests/ui/associated-consts/issue-110933.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
 pub trait Trait {
diff --git a/tests/ui/associated-consts/issue-93835.rs b/tests/ui/associated-consts/issue-93835.rs
index d6c2acaa9edc..26d0bbe3a40f 100644
--- a/tests/ui/associated-consts/issue-93835.rs
+++ b/tests/ui/associated-consts/issue-93835.rs
@@ -4,9 +4,9 @@ fn e() {
     type_ascribe!(p, a<p:p<e=6>>);
     //~^ ERROR cannot find type `a` in this scope
     //~| ERROR cannot find value
-    //~| ERROR associated const equality
+    //~| ERROR associated const equality is incomplete
     //~| ERROR cannot find trait `p` in this scope
-    //~| ERROR associated const equality
+    //~| ERROR associated const equality is incomplete
 }
 
 fn main() {}
diff --git a/tests/ui/associated-consts/issue-93835.stderr b/tests/ui/associated-consts/issue-93835.stderr
index 3f1679890130..990d22bba4de 100644
--- a/tests/ui/associated-consts/issue-93835.stderr
+++ b/tests/ui/associated-consts/issue-93835.stderr
@@ -22,8 +22,8 @@ error[E0658]: associated const equality is incomplete
 LL |     type_ascribe!(p, a<p:p<e=6>>);
    |                            ^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -32,8 +32,8 @@ error[E0658]: associated const equality is incomplete
 LL |     type_ascribe!(p, a<p:p<e=6>>);
    |                            ^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
diff --git a/tests/ui/associated-consts/projection-unspecified-but-bounded.rs b/tests/ui/associated-consts/projection-unspecified-but-bounded.rs
index 7f3304f07656..8a78b26dbc5d 100644
--- a/tests/ui/associated-consts/projection-unspecified-but-bounded.rs
+++ b/tests/ui/associated-consts/projection-unspecified-but-bounded.rs
@@ -1,4 +1,4 @@
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
 // Issue 110549
diff --git a/tests/ui/associated-type-bounds/const-projection-err.rs b/tests/ui/associated-type-bounds/const-projection-err.rs
index b230ea77f5fe..d485316ce371 100644
--- a/tests/ui/associated-type-bounds/const-projection-err.rs
+++ b/tests/ui/associated-type-bounds/const-projection-err.rs
@@ -1,4 +1,4 @@
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 
 trait TraitWAssocConst {
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.rs b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
index 7e86148eb811..1587be7200e7 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound-err.rs
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
@@ -1,7 +1,6 @@
 //@ edition: 2024
 
 #![feature(
-    associated_const_equality,
     min_generic_const_args,
     type_alias_impl_trait,
     return_type_notation
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
index 6484880392d6..ec864c1dd96e 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
@@ -1,5 +1,5 @@
 error[E0282]: type annotations needed
-  --> $DIR/duplicate-bound-err.rs:15:5
+  --> $DIR/duplicate-bound-err.rs:14:5
    |
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
@@ -10,7 +10,7 @@ LL |     iter::empty::<T>()
    |                +++++
 
 error[E0282]: type annotations needed
-  --> $DIR/duplicate-bound-err.rs:19:5
+  --> $DIR/duplicate-bound-err.rs:18:5
    |
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
@@ -21,7 +21,7 @@ LL |     iter::empty::<T>()
    |                +++++
 
 error[E0282]: type annotations needed
-  --> $DIR/duplicate-bound-err.rs:23:5
+  --> $DIR/duplicate-bound-err.rs:22:5
    |
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
@@ -32,7 +32,7 @@ LL |     iter::empty::<T>()
    |                +++++
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:27:51
+  --> $DIR/duplicate-bound-err.rs:26:51
    |
 LL | type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
    |                                                   ^^^^^^^^^
@@ -40,7 +40,7 @@ LL | type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
    = note: `Tait1` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:29:51
+  --> $DIR/duplicate-bound-err.rs:28:51
    |
 LL | type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
    |                                                   ^^^^^^^^^
@@ -48,7 +48,7 @@ LL | type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
    = note: `Tait2` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:31:57
+  --> $DIR/duplicate-bound-err.rs:30:57
    |
 LL | type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
    |                                                         ^^^^^^^^^
@@ -56,7 +56,7 @@ LL | type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
    = note: `Tait3` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:34:14
+  --> $DIR/duplicate-bound-err.rs:33:14
    |
 LL | type Tait4 = impl Iterator<Item: Copy, Item: Send>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | type Tait4 = impl Iterator<Item: Copy, Item: Send>;
    = note: `Tait4` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:36:14
+  --> $DIR/duplicate-bound-err.rs:35:14
    |
 LL | type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL | type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
    = note: `Tait5` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
-  --> $DIR/duplicate-bound-err.rs:38:14
+  --> $DIR/duplicate-bound-err.rs:37:14
    |
 LL | type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL | type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
    = note: `Tait6` must be used in combination with a concrete type within the same crate
 
 error[E0277]: `*const ()` cannot be sent between threads safely
-  --> $DIR/duplicate-bound-err.rs:41:18
+  --> $DIR/duplicate-bound-err.rs:40:18
    |
 LL | fn mismatch() -> impl Iterator<Item: Copy, Item: Send> {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const ()` cannot be sent between threads safely
@@ -91,7 +91,7 @@ LL |     iter::empty::<*const ()>()
    = help: the trait `Send` is not implemented for `*const ()`
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
-  --> $DIR/duplicate-bound-err.rs:46:20
+  --> $DIR/duplicate-bound-err.rs:45:20
    |
 LL | fn mismatch_2() -> impl Iterator<Item: Copy, Item: Send> {
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `String`
@@ -100,7 +100,7 @@ LL |     iter::empty::<String>()
    |     ----------------------- return type was inferred to be `std::iter::Empty<String>` here
 
 error[E0271]: expected `IntoIter<u32, 1>` to be an iterator that yields `i32`, but it yields `u32`
-  --> $DIR/duplicate-bound-err.rs:112:17
+  --> $DIR/duplicate-bound-err.rs:111:17
    |
 LL |     fn foo() -> impl Iterator<Item = i32, Item = u32> {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
@@ -109,7 +109,7 @@ LL |         [2u32].into_iter()
    |         ------------------ return type was inferred to be `std::array::IntoIter<u32, 1>` here
 
 error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate-bound-err.rs:88:42
+  --> $DIR/duplicate-bound-err.rs:87:42
    |
 LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
    |                              ----------  ^^^^^^^^^^ re-bound here
@@ -117,7 +117,7 @@ LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
    |                              `Item` bound here first
 
 error: conflicting associated type bounds for `Item`
-  --> $DIR/duplicate-bound-err.rs:88:17
+  --> $DIR/duplicate-bound-err.rs:87:17
    |
 LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
    |                 ^^^^^^^^^^^^^----------^^----------^
@@ -126,7 +126,7 @@ LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
    |                              `Item` is specified to be `i32` here
 
 error[E0719]: the value of the associated type `ASSOC` in trait `Trait2` is already specified
-  --> $DIR/duplicate-bound-err.rs:97:43
+  --> $DIR/duplicate-bound-err.rs:96:43
    |
 LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
    |                             ------------  ^^^^^^^^^^^^ re-bound here
@@ -134,7 +134,7 @@ LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
    |                             `ASSOC` bound here first
 
 error: conflicting associated type bounds for `ASSOC`
-  --> $DIR/duplicate-bound-err.rs:97:18
+  --> $DIR/duplicate-bound-err.rs:96:18
    |
 LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
    |                  ^^^^^^^^^^^------------^^------------^
@@ -143,7 +143,7 @@ LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
    |                             `ASSOC` is specified to be `3` here
 
 error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate-bound-err.rs:101:43
+  --> $DIR/duplicate-bound-err.rs:100:43
    |
 LL | type MustFail3 = dyn Iterator<Item = i32, Item = i32>;
    |                               ----------  ^^^^^^^^^^ re-bound here
@@ -151,7 +151,7 @@ LL | type MustFail3 = dyn Iterator<Item = i32, Item = i32>;
    |                               `Item` bound here first
 
 error[E0719]: the value of the associated type `ASSOC` in trait `Trait2` is already specified
-  --> $DIR/duplicate-bound-err.rs:104:43
+  --> $DIR/duplicate-bound-err.rs:103:43
    |
 LL | type MustFail4 = dyn Trait2<ASSOC = 3u32, ASSOC = 3u32>;
    |                             ------------  ^^^^^^^^^^^^ re-bound here
@@ -159,19 +159,19 @@ LL | type MustFail4 = dyn Trait2<ASSOC = 3u32, ASSOC = 3u32>;
    |                             `ASSOC` bound here first
 
 error[E0271]: expected `impl Iterator<Item = u32>` to be an iterator that yields `i32`, but it yields `u32`
-  --> $DIR/duplicate-bound-err.rs:112:17
+  --> $DIR/duplicate-bound-err.rs:111:17
    |
 LL |     fn foo() -> impl Iterator<Item = i32, Item = u32> {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
    |
 note: required by a bound in `Trait3::foo::{anon_assoc#0}`
-  --> $DIR/duplicate-bound-err.rs:108:31
+  --> $DIR/duplicate-bound-err.rs:107:31
    |
 LL |     fn foo() -> impl Iterator<Item = i32, Item = u32>;
    |                               ^^^^^^^^^^ required by this bound in `Trait3::foo::{anon_assoc#0}`
 
 error[E0271]: expected `Empty<u32>` to be an iterator that yields `i32`, but it yields `u32`
-  --> $DIR/duplicate-bound-err.rs:120:16
+  --> $DIR/duplicate-bound-err.rs:119:16
    |
 LL |     uncallable(iter::empty::<u32>());
    |     ---------- ^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
@@ -179,13 +179,13 @@ LL |     uncallable(iter::empty::<u32>());
    |     required by a bound introduced by this call
    |
 note: required by a bound in `uncallable`
-  --> $DIR/duplicate-bound-err.rs:80:32
+  --> $DIR/duplicate-bound-err.rs:79:32
    |
 LL | fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
    |                                ^^^^^^^^^^ required by this bound in `uncallable`
 
 error[E0271]: expected `Empty<i32>` to be an iterator that yields `u32`, but it yields `i32`
-  --> $DIR/duplicate-bound-err.rs:121:16
+  --> $DIR/duplicate-bound-err.rs:120:16
    |
 LL |     uncallable(iter::empty::<i32>());
    |     ---------- ^^^^^^^^^^^^^^^^^^^^ expected `u32`, found `i32`
@@ -193,13 +193,13 @@ LL |     uncallable(iter::empty::<i32>());
    |     required by a bound introduced by this call
    |
 note: required by a bound in `uncallable`
-  --> $DIR/duplicate-bound-err.rs:80:44
+  --> $DIR/duplicate-bound-err.rs:79:44
    |
 LL | fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
    |                                            ^^^^^^^^^^ required by this bound in `uncallable`
 
 error[E0271]: type mismatch resolving `<() as Trait>::ASSOC == 4`
-  --> $DIR/duplicate-bound-err.rs:122:22
+  --> $DIR/duplicate-bound-err.rs:121:22
    |
 LL |     uncallable_const(());
    |     ---------------- ^^ expected `4`, found `3`
@@ -209,13 +209,13 @@ LL |     uncallable_const(());
    = note: expected constant `4`
               found constant `3`
 note: required by a bound in `uncallable_const`
-  --> $DIR/duplicate-bound-err.rs:82:46
+  --> $DIR/duplicate-bound-err.rs:81:46
    |
 LL | fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
    |                                              ^^^^^^^^^ required by this bound in `uncallable_const`
 
 error[E0271]: type mismatch resolving `<u32 as Trait>::ASSOC == 3`
-  --> $DIR/duplicate-bound-err.rs:123:22
+  --> $DIR/duplicate-bound-err.rs:122:22
    |
 LL |     uncallable_const(4u32);
    |     ---------------- ^^^^ expected `3`, found `4`
@@ -225,13 +225,13 @@ LL |     uncallable_const(4u32);
    = note: expected constant `3`
               found constant `4`
 note: required by a bound in `uncallable_const`
-  --> $DIR/duplicate-bound-err.rs:82:35
+  --> $DIR/duplicate-bound-err.rs:81:35
    |
 LL | fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
    |                                   ^^^^^^^^^ required by this bound in `uncallable_const`
 
 error[E0271]: type mismatch resolving `<() as Trait>::ASSOC == 4`
-  --> $DIR/duplicate-bound-err.rs:124:20
+  --> $DIR/duplicate-bound-err.rs:123:20
    |
 LL |     uncallable_rtn(());
    |     -------------- ^^ expected `4`, found `3`
@@ -241,7 +241,7 @@ LL |     uncallable_rtn(());
    = note: expected constant `4`
               found constant `3`
 note: required by a bound in `uncallable_rtn`
-  --> $DIR/duplicate-bound-err.rs:85:61
+  --> $DIR/duplicate-bound-err.rs:84:61
    |
 LL | fn uncallable_rtn(
    |    -------------- required by a bound in this function
@@ -249,7 +249,7 @@ LL |     _: impl Trait<foo(..): Trait<ASSOC = 3>, foo(..): Trait<ASSOC = 4>>
    |                                                             ^^^^^^^^^ required by this bound in `uncallable_rtn`
 
 error[E0271]: type mismatch resolving `<u32 as Trait>::ASSOC == 3`
-  --> $DIR/duplicate-bound-err.rs:125:20
+  --> $DIR/duplicate-bound-err.rs:124:20
    |
 LL |     uncallable_rtn(17u32);
    |     -------------- ^^^^^ expected `3`, found `4`
@@ -259,7 +259,7 @@ LL |     uncallable_rtn(17u32);
    = note: expected constant `3`
               found constant `4`
 note: required by a bound in `uncallable_rtn`
-  --> $DIR/duplicate-bound-err.rs:85:34
+  --> $DIR/duplicate-bound-err.rs:84:34
    |
 LL | fn uncallable_rtn(
    |    -------------- required by a bound in this function
diff --git a/tests/ui/associated-type-bounds/duplicate-bound.rs b/tests/ui/associated-type-bounds/duplicate-bound.rs
index 6ea0daeca2c4..1aeb0022a04f 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound.rs
+++ b/tests/ui/associated-type-bounds/duplicate-bound.rs
@@ -1,7 +1,7 @@
 //@ edition: 2024
 //@ run-pass
 
-#![feature(associated_const_equality, min_generic_const_args, return_type_notation)]
+#![feature(min_generic_const_args, return_type_notation)]
 #![expect(incomplete_features)]
 #![allow(dead_code, refining_impl_trait_internal, type_alias_bounds)]
 
diff --git a/tests/ui/associated-type-bounds/issue-99828.stderr b/tests/ui/associated-type-bounds/issue-99828.stderr
index 132d5251987b..e1dc1f07d9cb 100644
--- a/tests/ui/associated-type-bounds/issue-99828.stderr
+++ b/tests/ui/associated-type-bounds/issue-99828.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | fn get_iter(vec: &[i32]) -> impl Iterator<Item = {}> + '_ {
    |                                           ^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: expected type, found constant
diff --git a/tests/ui/issues/issue-26614.rs b/tests/ui/associated-types/associated-type-const-nomalization.rs
similarity index 71%
rename from tests/ui/issues/issue-26614.rs
rename to tests/ui/associated-types/associated-type-const-nomalization.rs
index 576c7545924b..b7951ba9a435 100644
--- a/tests/ui/issues/issue-26614.rs
+++ b/tests/ui/associated-types/associated-type-const-nomalization.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/26614>
 //@ check-pass
 
 trait Mirror {
diff --git a/tests/ui/associated-types/associated-types-eq-2.stderr b/tests/ui/associated-types/associated-types-eq-2.stderr
index 19c34241e5f2..9be346516c89 100644
--- a/tests/ui/associated-types/associated-types-eq-2.stderr
+++ b/tests/ui/associated-types/associated-types-eq-2.stderr
@@ -7,8 +7,8 @@ LL |   impl Tr3<N
 LL | | = 42, T2 = Qux, T3 = usize> for Bar {
    | |____^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -17,8 +17,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl Tr3<n = 42, T2 = Qux, T3 = usize> for Qux {
    |          ^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -27,8 +27,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl Tr3<42, T2 = 42, T3 = usize> for Bar {
    |              ^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -37,8 +37,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl Tr3<X = 42, Y = Qux, Z = usize> for Bar {
    |          ^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0229]: associated item constraints are not allowed here
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 7027328bc27b..fd6f34fb45e2 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -223,8 +223,8 @@ help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[rustc_macro_transparency = "opaque"]
    |                            ++++++++++
-LL | #[rustc_macro_transparency = "semitransparent"]
-   |                            +++++++++++++++++++
+LL | #[rustc_macro_transparency = "semiopaque"]
+   |                            ++++++++++++++
 LL | #[rustc_macro_transparency = "transparent"]
    |                            +++++++++++++++
 
diff --git a/tests/ui/binop/can-have-side-effects-consider-operands.rs b/tests/ui/binop/can-have-side-effects-consider-operands.rs
new file mode 100644
index 000000000000..34eeb11c6add
--- /dev/null
+++ b/tests/ui/binop/can-have-side-effects-consider-operands.rs
@@ -0,0 +1,23 @@
+//@ check-pass
+
+#![allow(unused)]
+
+// Test if `Expr::can_have_side_effects` considers operands of binary operators.
+
+fn drop_repeat_in_arm_body() {
+    // Built-in lint `dropping_copy_types` relies on `Expr::can_have_side_effects`
+    // (See rust-clippy#9482 and rust#113231)
+
+    match () {
+        () => drop(5 % 3), // No side effects
+        //~^ WARNING calls to `std::mem::drop` with a value that implements `Copy` does nothing
+    }
+    match () {
+        () => drop(5 % calls_are_considered_side_effects()), // Definitely has side effects
+    }
+}
+fn calls_are_considered_side_effects() -> i32 {
+    3
+}
+
+fn main() {}
diff --git a/tests/ui/binop/can-have-side-effects-consider-operands.stderr b/tests/ui/binop/can-have-side-effects-consider-operands.stderr
new file mode 100644
index 000000000000..ef3fc6b4be7e
--- /dev/null
+++ b/tests/ui/binop/can-have-side-effects-consider-operands.stderr
@@ -0,0 +1,13 @@
+warning: calls to `std::mem::drop` with a value that implements `Copy` does nothing
+  --> $DIR/can-have-side-effects-consider-operands.rs:12:15
+   |
+LL |         () => drop(5 % 3), // No side effects
+   |               ^^^^^-----^
+   |                    |
+   |                    argument has type `i32`
+   |
+   = note: use `let _ = ...` to ignore the expression or result
+   = note: `#[warn(dropping_copy_types)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/block-result/block-must-not-have-result-while.stderr b/tests/ui/block-result/block-must-not-have-result-while.stderr
index 0b9941ea96ef..d8e854c9b9ba 100644
--- a/tests/ui/block-result/block-must-not-have-result-while.stderr
+++ b/tests/ui/block-result/block-must-not-have-result-while.stderr
@@ -9,12 +9,8 @@ LL |     while true {
 error[E0308]: mismatched types
   --> $DIR/block-must-not-have-result-while.rs:5:9
    |
-LL | /     while true {
-LL | |         true
-   | |         ^^^^ expected `()`, found `bool`
-LL | |
-LL | |     }
-   | |_____- expected this to be `()`
+LL |         true
+   |         ^^^^ expected `()`, found `bool`
 
 error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/borrowck/issue-92157.rs b/tests/ui/borrowck/issue-92157.rs
deleted file mode 100644
index 3dbcb4ad8b7f..000000000000
--- a/tests/ui/borrowck/issue-92157.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ add-minicore
-#![feature(no_core)]
-#![feature(lang_items)]
-
-#![no_core]
-
-#[cfg(target_os = "linux")]
-#[link(name = "c")]
-extern "C" {}
-
-#[lang = "start"]
-fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isize {
-    //~^ ERROR lang item `start` function has wrong type [E0308]
-    40+2
-}
-
-extern crate minicore;
-use minicore::*;
-
-fn main() {}
diff --git a/tests/ui/borrowck/issue-92157.stderr b/tests/ui/borrowck/issue-92157.stderr
deleted file mode 100644
index 248d700ab4b9..000000000000
--- a/tests/ui/borrowck/issue-92157.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error[E0308]: lang item `start` function has wrong type
-  --> $DIR/issue-92157.rs:12:1
-   |
-LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isize {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ incorrect number of function parameters
-   |
-   = note: expected signature `fn(fn() -> T, isize, *const *const u8, u8) -> _`
-              found signature `fn(fn() -> T, isize, *const *const u8) -> _`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/cast/cast-enum-const.rs b/tests/ui/cast/cast-enum-const.rs
new file mode 100644
index 000000000000..cfad40c07b0e
--- /dev/null
+++ b/tests/ui/cast/cast-enum-const.rs
@@ -0,0 +1,12 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/2428>
+//@ run-pass
+
+fn main() {
+    const QUUX: isize = 5;
+
+    enum Stuff {
+        Bar = QUUX,
+    }
+
+    assert_eq!(Stuff::Bar as isize, QUUX);
+}
diff --git a/tests/ui/issues/issue-22403.rs b/tests/ui/cast/cast-to-box-arr.rs
similarity index 61%
rename from tests/ui/issues/issue-22403.rs
rename to tests/ui/cast/cast-to-box-arr.rs
index 89c956913f93..1a9004cd074e 100644
--- a/tests/ui/issues/issue-22403.rs
+++ b/tests/ui/cast/cast-to-box-arr.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/22403>
 //@ run-pass
 fn main() {
     let x = Box::new([1, 2, 3]);
diff --git a/tests/ui/issues/issue-41998.rs b/tests/ui/cast/cast-to-char-compare.rs
similarity index 64%
rename from tests/ui/issues/issue-41998.rs
rename to tests/ui/cast/cast-to-char-compare.rs
index 303bf7a57513..159b8ee04e02 100644
--- a/tests/ui/issues/issue-41998.rs
+++ b/tests/ui/cast/cast-to-char-compare.rs
@@ -1,6 +1,6 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/41998>
 //@ check-pass
 
-
 fn main() {
     if ('x' as char) < ('y' as char) {
         print!("x");
diff --git a/tests/ui/cast/ptr-to-ptr-unsized-adt-tail-with-static-region.rs b/tests/ui/cast/ptr-to-ptr-unsized-adt-tail-with-static-region.rs
new file mode 100644
index 000000000000..7319a670c881
--- /dev/null
+++ b/tests/ui/cast/ptr-to-ptr-unsized-adt-tail-with-static-region.rs
@@ -0,0 +1,15 @@
+//@ check-pass
+
+// During MIR typeck when casting `*mut dyn Sync + '?x` to
+// `*mut Wrap` we compute the tail of `Wrap` as `dyn Sync + 'static`.
+//
+// This test ensures that we first convert the `'static` lifetime to
+// the nll var `'?0` before introducing the region constraint `'?x: 'static`.
+
+struct Wrap(dyn Sync + 'static);
+
+fn cast(x: *mut (dyn Sync + 'static)) {
+    x as *mut Wrap;
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/invalid-cli-cfg-pred.rs b/tests/ui/cfg/invalid-cli-cfg-pred.rs
new file mode 100644
index 000000000000..fdfb6b18d96b
--- /dev/null
+++ b/tests/ui/cfg/invalid-cli-cfg-pred.rs
@@ -0,0 +1,5 @@
+//@ compile-flags: --cfg foo=1x
+
+fn main() {}
+
+//~? ERROR invalid `--cfg` argument
diff --git a/tests/ui/cfg/invalid-cli-cfg-pred.stderr b/tests/ui/cfg/invalid-cli-cfg-pred.stderr
new file mode 100644
index 000000000000..2f5ed55a6423
--- /dev/null
+++ b/tests/ui/cfg/invalid-cli-cfg-pred.stderr
@@ -0,0 +1,7 @@
+error: invalid suffix `x` for number literal
+  |
+  = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+  = note: this occurred on the command line: `--cfg=foo=1x`
+
+error: invalid `--cfg` argument: `foo=1x` (expected `key` or `key="value"`, ensure escaping is appropriate for your shell, try 'key="value"' or key=\"value\")
+
diff --git a/tests/ui/cfg/invalid-cli-check-cfg-pred.rs b/tests/ui/cfg/invalid-cli-check-cfg-pred.rs
new file mode 100644
index 000000000000..30417a912bfc
--- /dev/null
+++ b/tests/ui/cfg/invalid-cli-check-cfg-pred.rs
@@ -0,0 +1,5 @@
+//@ compile-flags: --check-cfg 'foo=1x'
+
+fn main() {}
+
+//~? ERROR invalid `--check-cfg` argument
diff --git a/tests/ui/cfg/invalid-cli-check-cfg-pred.stderr b/tests/ui/cfg/invalid-cli-check-cfg-pred.stderr
new file mode 100644
index 000000000000..be8299aa9edf
--- /dev/null
+++ b/tests/ui/cfg/invalid-cli-check-cfg-pred.stderr
@@ -0,0 +1,10 @@
+error: invalid suffix `x` for number literal
+  |
+  = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+  = note: this occurred on the command line: `--check-cfg=foo=1x`
+
+error: invalid `--check-cfg` argument: `foo=1x`
+   |
+   = note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
+   = note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
+
diff --git a/tests/ui/const-generics/assoc_const_eq_diagnostic.rs b/tests/ui/const-generics/assoc_const_eq_diagnostic.rs
index 6ab82f45e684..f2b581412a72 100644
--- a/tests/ui/const-generics/assoc_const_eq_diagnostic.rs
+++ b/tests/ui/const-generics/assoc_const_eq_diagnostic.rs
@@ -1,5 +1,6 @@
 //@ edition:2015
-#![feature(associated_const_equality)]
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
 
 pub enum Mode {
     Cool,
diff --git a/tests/ui/const-generics/assoc_const_eq_diagnostic.stderr b/tests/ui/const-generics/assoc_const_eq_diagnostic.stderr
index bcfad9d1538c..05e0ec93d494 100644
--- a/tests/ui/const-generics/assoc_const_eq_diagnostic.stderr
+++ b/tests/ui/const-generics/assoc_const_eq_diagnostic.stderr
@@ -1,5 +1,5 @@
 error[E0573]: expected type, found variant `Mode::Cool`
-  --> $DIR/assoc_const_eq_diagnostic.rs:12:35
+  --> $DIR/assoc_const_eq_diagnostic.rs:13:35
    |
 LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                                   ^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                                   help: try using the variant's enum: `Mode`
 
 error[E0573]: expected type, found variant `Mode::Cool`
-  --> $DIR/assoc_const_eq_diagnostic.rs:18:17
+  --> $DIR/assoc_const_eq_diagnostic.rs:19:17
    |
 LL | fn no_help() -> Mode::Cool {}
    |                 ^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | fn no_help() -> Mode::Cool {}
    |                 help: try using the variant's enum: `Mode`
 
 error: expected constant, found type
-  --> $DIR/assoc_const_eq_diagnostic.rs:12:35
+  --> $DIR/assoc_const_eq_diagnostic.rs:13:35
    |
 LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            ----   ^^^^^^^^^^ unexpected type
@@ -25,7 +25,7 @@ LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            expected a constant because of this associated constant
    |
 note: the associated constant is defined here
-  --> $DIR/assoc_const_eq_diagnostic.rs:9:5
+  --> $DIR/assoc_const_eq_diagnostic.rs:10:5
    |
 LL |     const MODE: Mode;
    |     ^^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL | pub trait CoolStuff: Parse<MODE = { Mode::Cool }> {}
    |                                   +            +
 
 error: expected constant, found type
-  --> $DIR/assoc_const_eq_diagnostic.rs:12:35
+  --> $DIR/assoc_const_eq_diagnostic.rs:13:35
    |
 LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            ----   ^^^^^^^^^^ unexpected type
@@ -43,7 +43,7 @@ LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            expected a constant because of this associated constant
    |
 note: the associated constant is defined here
-  --> $DIR/assoc_const_eq_diagnostic.rs:9:5
+  --> $DIR/assoc_const_eq_diagnostic.rs:10:5
    |
 LL |     const MODE: Mode;
    |     ^^^^^^^^^^^^^^^^
@@ -54,7 +54,7 @@ LL | pub trait CoolStuff: Parse<MODE = { Mode::Cool }> {}
    |                                   +            +
 
 error: expected constant, found type
-  --> $DIR/assoc_const_eq_diagnostic.rs:12:35
+  --> $DIR/assoc_const_eq_diagnostic.rs:13:35
    |
 LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            ----   ^^^^^^^^^^ unexpected type
@@ -62,7 +62,7 @@ LL | pub trait CoolStuff: Parse<MODE = Mode::Cool> {}
    |                            expected a constant because of this associated constant
    |
 note: the associated constant is defined here
-  --> $DIR/assoc_const_eq_diagnostic.rs:9:5
+  --> $DIR/assoc_const_eq_diagnostic.rs:10:5
    |
 LL |     const MODE: Mode;
    |     ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/const-generics/associated_const_equality/coherence.rs b/tests/ui/const-generics/associated_const_equality/coherence.rs
index fb5f255c1dc4..f4081fae6144 100644
--- a/tests/ui/const-generics/associated_const_equality/coherence.rs
+++ b/tests/ui/const-generics/associated_const_equality/coherence.rs
@@ -1,4 +1,4 @@
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 #![expect(incomplete_features)]
 
 pub trait IsVoid {
diff --git a/tests/ui/const-generics/associated_const_equality/equality_bound_with_infer.rs b/tests/ui/const-generics/associated_const_equality/equality_bound_with_infer.rs
index 3973c7af15b4..b7ed8ee39f87 100644
--- a/tests/ui/const-generics/associated_const_equality/equality_bound_with_infer.rs
+++ b/tests/ui/const-generics/associated_const_equality/equality_bound_with_infer.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(associated_const_equality, min_generic_const_args, generic_const_items)]
+#![feature(min_generic_const_args, generic_const_items)]
 #![expect(incomplete_features)]
 
 // Regression test for #133066 where we would try to evaluate `<() as Foo>::ASSOC<_>` even
diff --git a/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace-no-feature-gate.stderr b/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace-no-feature-gate.stderr
index 0b487b6a7aa0..d2f28a62e04e 100644
--- a/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace-no-feature-gate.stderr
+++ b/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace-no-feature-gate.stderr
@@ -1,13 +1,3 @@
-error[E0658]: associated const equality is incomplete
-  --> $DIR/mismatched-types-with-generic-in-ace-no-feature-gate.rs:7:38
-   |
-LL | fn take0<const N: u64>(_: impl Owner<C<N> = { N }>) {}
-   |                                      ^^^^^^^^^^^^
-   |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
 error[E0658]: generic const items are experimental
   --> $DIR/mismatched-types-with-generic-in-ace-no-feature-gate.rs:2:12
    |
@@ -18,6 +8,16 @@ LL |     const C<const N: u32>: u32 = N;
    = help: add `#![feature(generic_const_items)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
+error[E0658]: associated const equality is incomplete
+  --> $DIR/mismatched-types-with-generic-in-ace-no-feature-gate.rs:7:38
+   |
+LL | fn take0<const N: u64>(_: impl Owner<C<N> = { N }>) {}
+   |                                      ^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace.rs b/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace.rs
index 33afa7e3228e..77f0f06f8040 100644
--- a/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace.rs
+++ b/tests/ui/const-generics/associated_const_equality/mismatched-types-with-generic-in-ace.rs
@@ -1,4 +1,4 @@
-#![feature(generic_const_items, associated_const_equality, min_generic_const_args)]
+#![feature(generic_const_items, min_generic_const_args)]
 #![expect(incomplete_features)]
 
 trait Foo {
diff --git a/tests/ui/const-generics/associated_const_equality/unconstrained_impl_param.stderr b/tests/ui/const-generics/associated_const_equality/unconstrained_impl_param.stderr
index 092faff93511..c34674604b51 100644
--- a/tests/ui/const-generics/associated_const_equality/unconstrained_impl_param.stderr
+++ b/tests/ui/const-generics/associated_const_equality/unconstrained_impl_param.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl<U> Trait for () where (U,): AssocConst<A = 0> {}
    |                                             ^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
diff --git a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
index 6cf4e881adae..62bebd53b14a 100644
--- a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
@@ -1,8 +1,8 @@
 error: unconstrained generic constant
-  --> $DIR/doesnt_unify_evaluatable.rs:9:11
+  --> $DIR/doesnt_unify_evaluatable.rs:9:13
    |
 LL |     bar::<{ T::ASSOC }>();
-   |           ^^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 help: try adding a `where` bound
    |
diff --git a/tests/ui/const-generics/invalid-attributes-on-const-params-78957.stderr b/tests/ui/const-generics/invalid-attributes-on-const-params-78957.stderr
index f8010b4ea687..5fc7e7fef75d 100644
--- a/tests/ui/const-generics/invalid-attributes-on-const-params-78957.stderr
+++ b/tests/ui/const-generics/invalid-attributes-on-const-params-78957.stderr
@@ -1,4 +1,4 @@
-error: `#[inline]` attribute cannot be used on function params
+error: `#[inline]` attribute cannot be used on const parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:6:16
    |
 LL | pub struct Foo<#[inline] const N: usize>;
@@ -6,7 +6,7 @@ LL | pub struct Foo<#[inline] const N: usize>;
    |
    = help: `#[inline]` can only be applied to functions
 
-error: `#[inline]` attribute cannot be used on function params
+error: `#[inline]` attribute cannot be used on lifetime parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:14:17
    |
 LL | pub struct Foo2<#[inline] 'a>(PhantomData<&'a ()>);
@@ -14,7 +14,7 @@ LL | pub struct Foo2<#[inline] 'a>(PhantomData<&'a ()>);
    |
    = help: `#[inline]` can only be applied to functions
 
-error: `#[inline]` attribute cannot be used on function params
+error: `#[inline]` attribute cannot be used on type parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:22:17
    |
 LL | pub struct Foo3<#[inline] T>(PhantomData<T>);
@@ -40,7 +40,7 @@ error[E0517]: attribute should be applied to a struct, enum, or union
 LL | pub struct Baz3<#[repr(C)] T>(PhantomData<T>);
    |                        ^   - not a struct, enum, or union
 
-error: `#[cold]` attribute cannot be used on function params
+error: `#[cold]` attribute cannot be used on const parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:8:16
    |
 LL | pub struct Bar<#[cold] const N: usize>;
@@ -54,7 +54,7 @@ note: the lint level is defined here
 LL | #![deny(unused_attributes)]
    |         ^^^^^^^^^^^^^^^^^
 
-error: `#[cold]` attribute cannot be used on function params
+error: `#[cold]` attribute cannot be used on lifetime parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:16:17
    |
 LL | pub struct Bar2<#[cold] 'a>(PhantomData<&'a ()>);
@@ -63,7 +63,7 @@ LL | pub struct Bar2<#[cold] 'a>(PhantomData<&'a ()>);
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[cold]` can only be applied to functions
 
-error: `#[cold]` attribute cannot be used on function params
+error: `#[cold]` attribute cannot be used on type parameters
   --> $DIR/invalid-attributes-on-const-params-78957.rs:24:17
    |
 LL | pub struct Bar3<#[cold] T>(PhantomData<T>);
diff --git a/tests/ui/const-generics/issues/issue-88119.rs b/tests/ui/const-generics/issues/issue-88119.rs
index d44b5ab985b0..fb279dd824f8 100644
--- a/tests/ui/const-generics/issues/issue-88119.rs
+++ b/tests/ui/const-generics/issues/issue-88119.rs
@@ -1,5 +1,4 @@
-//@ known-bug: #110395
-//@ compile-flags: -Znext-solver
+//@ check-pass
 #![allow(incomplete_features)]
 #![feature(const_trait_impl, generic_const_exprs)]
 
diff --git a/tests/ui/const-generics/issues/issue-88119.stderr b/tests/ui/const-generics/issues/issue-88119.stderr
deleted file mode 100644
index 0bdf153468bc..000000000000
--- a/tests/ui/const-generics/issues/issue-88119.stderr
+++ /dev/null
@@ -1,95 +0,0 @@
-error: `-Znext-solver=globally` and `generic_const_exprs` are incompatible, using them at the same time is not allowed
-  --> $DIR/issue-88119.rs:4:30
-   |
-LL | #![feature(const_trait_impl, generic_const_exprs)]
-   |                              ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: remove one of these features
-
-error[E0275]: overflow evaluating the requirement `&T: [const] ConstName`
-  --> $DIR/issue-88119.rs:18:49
-   |
-LL | impl<T: ?Sized + ConstName> const ConstName for &T
-   |                                                 ^^
-
-error[E0275]: overflow evaluating the requirement `&T: ConstName`
-  --> $DIR/issue-88119.rs:18:49
-   |
-LL | impl<T: ?Sized + ConstName> const ConstName for &T
-   |                                                 ^^
-
-error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
-  --> $DIR/issue-88119.rs:20:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-note: required by a bound in `<&T as ConstName>`
-  --> $DIR/issue-88119.rs:20:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&T as ConstName>`
-
-error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
-  --> $DIR/issue-88119.rs:20:10
-   |
-LL |     [(); name_len::<T>()]:,
-   |          ^^^^^^^^^^^^^^^
-   |
-note: required by a bound in `<&T as ConstName>`
-  --> $DIR/issue-88119.rs:20:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&T as ConstName>`
-
-error[E0275]: overflow evaluating the requirement `&mut T: [const] ConstName`
-  --> $DIR/issue-88119.rs:25:49
-   |
-LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
-   |                                                 ^^^^^^
-
-error[E0275]: overflow evaluating the requirement `&mut T: ConstName`
-  --> $DIR/issue-88119.rs:25:49
-   |
-LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
-   |                                                 ^^^^^^
-
-error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
-  --> $DIR/issue-88119.rs:27:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-note: required by a bound in `<&mut T as ConstName>`
-  --> $DIR/issue-88119.rs:27:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&mut T as ConstName>`
-
-error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
-  --> $DIR/issue-88119.rs:27:10
-   |
-LL |     [(); name_len::<T>()]:,
-   |          ^^^^^^^^^^^^^^^
-   |
-note: required by a bound in `<&mut T as ConstName>`
-  --> $DIR/issue-88119.rs:27:5
-   |
-LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&mut T as ConstName>`
-
-error[E0275]: overflow evaluating the requirement `&&mut u8: ConstName`
-  --> $DIR/issue-88119.rs:32:35
-   |
-LL | pub const ICE_1: &'static [u8] = <&&mut u8 as ConstName>::NAME_BYTES;
-   |                                   ^^^^^^^^
-
-error[E0275]: overflow evaluating the requirement `&mut &u8: ConstName`
-  --> $DIR/issue-88119.rs:33:35
-   |
-LL | pub const ICE_2: &'static [u8] = <&mut &u8 as ConstName>::NAME_BYTES;
-   |                                   ^^^^^^^^
-
-error: aborting due to 11 previous errors
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs b/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
index ffb763da325c..16479ba3f64f 100644
--- a/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
@@ -12,7 +12,7 @@ fn foo<const N: Option<u32>>() {}
 
 trait Trait {
     #[type_const]
-    const ASSOC: usize;
+    const ASSOC: u32;
 }
 
 fn bar<T: Trait, const N: u32>() {
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.rs b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.rs
new file mode 100644
index 000000000000..e47052523fa3
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.rs
@@ -0,0 +1,20 @@
+#![feature(min_generic_const_args, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    #[type_const]
+    const ASSOC: usize;
+}
+
+fn takes_tuple<const A: (u32, u32)>() {}
+fn takes_nested_tuple<const A: (u32, (u32, u32))>() {}
+
+fn generic_caller<T: Trait, const N: u32, const N2: u32>() {
+    takes_tuple::<{ (N, N + 1) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_tuple::<{ (N, T::ASSOC + 1) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+
+    takes_nested_tuple::<{ (N, (N, N + 1)) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_nested_tuple::<{ (N, (N, const { N + 1 })) }>(); //~ ERROR generic parameters may not be used in const operations
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.stderr b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.stderr
new file mode 100644
index 000000000000..dbc64a1bf59d
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_complex.stderr
@@ -0,0 +1,26 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/adt_expr_arg_tuple_expr_complex.rs:13:25
+   |
+LL |     takes_tuple::<{ (N, N + 1) }>();
+   |                         ^^^^^
+
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/adt_expr_arg_tuple_expr_complex.rs:14:25
+   |
+LL |     takes_tuple::<{ (N, T::ASSOC + 1) }>();
+   |                         ^^^^^^^^^^^^
+
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/adt_expr_arg_tuple_expr_complex.rs:16:36
+   |
+LL |     takes_nested_tuple::<{ (N, (N, N + 1)) }>();
+   |                                    ^^^^^
+
+error: generic parameters may not be used in const operations
+  --> $DIR/adt_expr_arg_tuple_expr_complex.rs:17:44
+   |
+LL |     takes_nested_tuple::<{ (N, (N, const { N + 1 })) }>();
+   |                                            ^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.rs b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.rs
new file mode 100644
index 000000000000..5f0d6c924bd1
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.rs
@@ -0,0 +1,26 @@
+#![feature(min_generic_const_args, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    #[type_const]
+    const ASSOC: usize;
+}
+
+fn takes_tuple<const A: (u32, u32)>() {}
+fn takes_nested_tuple<const A: (u32, (u32, u32))>() {}
+
+fn generic_caller<T: Trait, const N: usize, const N2: u32>() {
+    takes_tuple::<{ (N, N2) }>();
+    //~^ ERROR the constant `N` is not of type `u32`
+    takes_tuple::<{ (N, T::ASSOC) }>();
+    //~^ ERROR the constant `N` is not of type `u32`
+    //~| ERROR the constant `<T as Trait>::ASSOC` is not of type `u32`
+
+    takes_nested_tuple::<{ (N, (N, N2)) }>();
+    //~^ ERROR the constant `N` is not of type `u32`
+    takes_nested_tuple::<{ (N, (N, T::ASSOC)) }>();
+    //~^ ERROR the constant `N` is not of type `u32`
+    //~| ERROR the constant `<T as Trait>::ASSOC` is not of type `u32`
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.stderr b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.stderr
new file mode 100644
index 000000000000..9d80ebeaa680
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_fail.stderr
@@ -0,0 +1,38 @@
+error: the constant `N` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:13:21
+   |
+LL |     takes_tuple::<{ (N, N2) }>();
+   |                     ^^^^^^^ expected `u32`, found `usize`
+
+error: the constant `N` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:15:21
+   |
+LL |     takes_tuple::<{ (N, T::ASSOC) }>();
+   |                     ^^^^^^^^^^^^^ expected `u32`, found `usize`
+
+error: the constant `<T as Trait>::ASSOC` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:15:21
+   |
+LL |     takes_tuple::<{ (N, T::ASSOC) }>();
+   |                     ^^^^^^^^^^^^^ expected `u32`, found `usize`
+
+error: the constant `N` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:19:28
+   |
+LL |     takes_nested_tuple::<{ (N, (N, N2)) }>();
+   |                            ^^^^^^^^^^^^ expected `u32`, found `usize`
+
+error: the constant `N` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:21:28
+   |
+LL |     takes_nested_tuple::<{ (N, (N, T::ASSOC)) }>();
+   |                            ^^^^^^^^^^^^^^^^^^ expected `u32`, found `usize`
+
+error: the constant `<T as Trait>::ASSOC` is not of type `u32`
+  --> $DIR/adt_expr_arg_tuple_expr_fail.rs:21:28
+   |
+LL |     takes_nested_tuple::<{ (N, (N, T::ASSOC)) }>();
+   |                            ^^^^^^^^^^^^^^^^^^ expected `u32`, found `usize`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_simple.rs b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_simple.rs
new file mode 100644
index 000000000000..3fde431e27e2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_tuple_expr_simple.rs
@@ -0,0 +1,22 @@
+//@ check-pass
+
+#![feature(min_generic_const_args, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    #[type_const]
+    const ASSOC: u32;
+}
+
+fn takes_tuple<const A: (u32, u32)>() {}
+fn takes_nested_tuple<const A: (u32, (u32, u32))>() {}
+
+fn generic_caller<T: Trait, const N: u32, const N2: u32>() {
+    takes_tuple::<{ (N, N2) }>();
+    takes_tuple::<{ (N, T::ASSOC) }>();
+
+    takes_nested_tuple::<{ (N, (N, N2)) }>();
+    takes_nested_tuple::<{ (N, (N, T::ASSOC)) }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.stderr b/tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.stderr
index 49d3f67003dc..72e0e94ff625 100644
--- a/tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.stderr
+++ b/tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.stderr
@@ -23,7 +23,7 @@ error: struct expression with missing field initialiser for `field`
   --> $DIR/adt_expr_erroneuous_inits.rs:16:17
    |
 LL |     accepts::<{ Foo::<u8> { }}>();
-   |                 ^^^^^^^^^
+   |                 ^^^^^^^^^^^^^
 
 error: struct expression with multiple initialisers for `field`
   --> $DIR/adt_expr_erroneuous_inits.rs:18:49
@@ -35,13 +35,13 @@ error: struct expression with invalid base path
   --> $DIR/adt_expr_erroneuous_inits.rs:20:17
    |
 LL |     accepts::<{ Fooo::<u8> { field: const { 1 } }}>();
-   |                 ^^^^^^^^^^
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: struct expression with invalid base path
   --> $DIR/adt_expr_erroneuous_inits.rs:23:17
    |
 LL |     accepts::<{ NonStruct { }}>();
-   |                 ^^^^^^^^^
+   |                 ^^^^^^^^^^^^^
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs b/tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs
index eafc8382966b..496a424bac65 100644
--- a/tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs
+++ b/tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs
@@ -1,17 +1,38 @@
-//@ check-pass
-// FIXME(mgca): This should error
-
 #![feature(min_generic_const_args, adt_const_params)]
 #![expect(incomplete_features)]
 
 #[derive(Eq, PartialEq, std::marker::ConstParamTy)]
-struct Foo<T> { field: T }
+struct S1<T> {
+    f1: T,
+    f2: isize,
+}
 
-fn accepts<const N: Foo<u8>>() {}
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+struct S2<T>(T, isize);
+
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+enum En<T> {
+    Var1(bool, T),
+    Var2 { field: i64 },
+}
+
+fn accepts_1<const N: S1<u8>>() {}
+fn accepts_2<const N: S2<u8>>() {}
+fn accepts_3<const N: En<u8>>() {}
 
 fn bar<const N: bool>() {
-    // `N` is not of type `u8` but we don't actually check this anywhere yet
-    accepts::<{ Foo::<u8> { field: N }}>();
+    accepts_1::<{ S1::<u8> { f1: N, f2: N } }>();
+    //~^ ERROR the constant `N` is not of type `u8`
+    //~| ERROR the constant `N` is not of type `isize`
+    accepts_2::<{ S2::<u8>(N, N) }>();
+    //~^ ERROR the constant `N` is not of type `u8`
+    //~| ERROR the constant `N` is not of type `isize`
+    accepts_3::<{ En::Var1::<u8>(N, N) }>();
+    //~^ ERROR the constant `N` is not of type `u8`
+    accepts_3::<{ En::Var2::<u8> { field: N } }>();
+    //~^ ERROR the constant `N` is not of type `i64`
+    accepts_3::<{ En::Var2::<u8> { field: const { false } } }>();
+    //~^ ERROR mismatched types
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/mgca/adt_expr_fields_type_check.stderr b/tests/ui/const-generics/mgca/adt_expr_fields_type_check.stderr
new file mode 100644
index 000000000000..81f7c5366b46
--- /dev/null
+++ b/tests/ui/const-generics/mgca/adt_expr_fields_type_check.stderr
@@ -0,0 +1,45 @@
+error: the constant `N` is not of type `u8`
+  --> $DIR/adt_expr_fields_type_check.rs:24:19
+   |
+LL |     accepts_1::<{ S1::<u8> { f1: N, f2: N } }>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `bool`
+
+error: the constant `N` is not of type `isize`
+  --> $DIR/adt_expr_fields_type_check.rs:24:19
+   |
+LL |     accepts_1::<{ S1::<u8> { f1: N, f2: N } }>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `bool`
+
+error: the constant `N` is not of type `u8`
+  --> $DIR/adt_expr_fields_type_check.rs:27:19
+   |
+LL |     accepts_2::<{ S2::<u8>(N, N) }>();
+   |                   ^^^^^^^^^^^^^^ expected `u8`, found `bool`
+
+error: the constant `N` is not of type `isize`
+  --> $DIR/adt_expr_fields_type_check.rs:27:19
+   |
+LL |     accepts_2::<{ S2::<u8>(N, N) }>();
+   |                   ^^^^^^^^^^^^^^ expected `isize`, found `bool`
+
+error: the constant `N` is not of type `u8`
+  --> $DIR/adt_expr_fields_type_check.rs:30:19
+   |
+LL |     accepts_3::<{ En::Var1::<u8>(N, N) }>();
+   |                   ^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `bool`
+
+error: the constant `N` is not of type `i64`
+  --> $DIR/adt_expr_fields_type_check.rs:32:19
+   |
+LL |     accepts_3::<{ En::Var2::<u8> { field: N } }>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i64`, found `bool`
+
+error[E0308]: mismatched types
+  --> $DIR/adt_expr_fields_type_check.rs:34:51
+   |
+LL |     accepts_3::<{ En::Var2::<u8> { field: const { false } } }>();
+   |                                                   ^^^^^ expected `i64`, found `bool`
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs
new file mode 100644
index 000000000000..6a4ee3ed1772
--- /dev/null
+++ b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs
@@ -0,0 +1,19 @@
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+use std::marker::ConstParamTy;
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+struct U;
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+//~^ ERROR overflow evaluating the requirement `S<U> well-formed`
+//~| ERROR overflow evaluating the requirement `S<U> well-formed`
+
+struct S<const N: U>()
+where
+    S<{ U }>:;
+//~^ ERROR overflow evaluating the requirement `S<U> well-formed`
+//~| ERROR overflow evaluating the requirement `S<U> well-formed`
+//~| ERROR overflow evaluating the requirement `S<U> well-formed`
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr
new file mode 100644
index 000000000000..4c5ad645bc45
--- /dev/null
+++ b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr
@@ -0,0 +1,80 @@
+error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL |     S<{ U }>:;
+   |     ^^^^^^^^
+   |
+note: required by a bound in `S`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL | struct S<const N: U>()
+   |        - required by a bound in this struct
+LL | where
+LL |     S<{ U }>:;
+   |     ^^^^^^^^ required by this bound in `S`
+
+error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL |     S<{ U }>:;
+   |     ^^^^^^^^
+   |
+note: required by a bound in `S`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL | struct S<const N: U>()
+   |        - required by a bound in this struct
+LL | where
+LL |     S<{ U }>:;
+   |     ^^^^^^^^ required by this bound in `S`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL |     S<{ U }>:;
+   |     ^^^^^^^^
+   |
+note: required by a bound in `S`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL | struct S<const N: U>()
+   |        - required by a bound in this struct
+LL | where
+LL |     S<{ U }>:;
+   |     ^^^^^^^^ required by this bound in `S`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+  --> $DIR/const-ctor-overflow-eval.rs:8:24
+   |
+LL | #[derive(ConstParamTy, PartialEq, Eq)]
+   |                        ^^^^^^^^^
+   |
+note: required by a bound in `S`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL | struct S<const N: U>()
+   |        - required by a bound in this struct
+LL | where
+LL |     S<{ U }>:;
+   |     ^^^^^^^^ required by this bound in `S`
+
+error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+  --> $DIR/const-ctor-overflow-eval.rs:8:35
+   |
+LL | #[derive(ConstParamTy, PartialEq, Eq)]
+   |                                   ^^
+   |
+note: required by a bound in `S`
+  --> $DIR/const-ctor-overflow-eval.rs:14:5
+   |
+LL | struct S<const N: U>()
+   |        - required by a bound in this struct
+LL | where
+LL |     S<{ U }>:;
+   |     ^^^^^^^^ required by this bound in `S`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/const-generics/mgca/const-ctor-with-error.rs b/tests/ui/const-generics/mgca/const-ctor-with-error.rs
new file mode 100644
index 000000000000..95a910e3dd2c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/const-ctor-with-error.rs
@@ -0,0 +1,19 @@
+// to ensure it does not ices like before
+
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+use std::marker::ConstParamTy;
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+enum Option<T> {
+    #[allow(dead_code)]
+    Some(T),
+    None,
+}
+
+fn pass_enum<const P: Option<u32>>() {}
+
+fn main() {
+    pass_enum::<{ None }>();
+    //~^ ERROR  missing generics for enum `std::option::Option`
+}
diff --git a/tests/ui/const-generics/mgca/const-ctor-with-error.stderr b/tests/ui/const-generics/mgca/const-ctor-with-error.stderr
new file mode 100644
index 000000000000..8684457a978b
--- /dev/null
+++ b/tests/ui/const-generics/mgca/const-ctor-with-error.stderr
@@ -0,0 +1,14 @@
+error[E0107]: missing generics for enum `std::option::Option`
+  --> $DIR/const-ctor-with-error.rs:17:19
+   |
+LL |     pass_enum::<{ None }>();
+   |                   ^^^^ expected 1 generic argument
+   |
+help: add missing generic argument
+   |
+LL |     pass_enum::<{ None<T> }>();
+   |                       +++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/const-generics/mgca/const-ctor.rs b/tests/ui/const-generics/mgca/const-ctor.rs
new file mode 100644
index 000000000000..19900b56a816
--- /dev/null
+++ b/tests/ui/const-generics/mgca/const-ctor.rs
@@ -0,0 +1,49 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/139596>
+//!                     <https://github.com/rust-lang/rust/issues/136138>
+//!                     <https://github.com/rust-lang/rust/issues/132985>
+
+//@ check-pass
+
+#![feature(
+    min_generic_const_args,
+    adt_const_params,
+    generic_const_parameter_types,
+    unsized_const_params
+)]
+#![expect(incomplete_features)]
+use std::marker::{ConstParamTy, ConstParamTy_};
+#[derive(ConstParamTy, PartialEq, Eq)]
+struct Colour;
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+enum A {
+    B,
+}
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+enum MyOption<T> {
+    #[allow(dead_code)]
+    Some(T),
+    None,
+}
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+struct Led<const C: Colour>;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct Foo<const N: usize>;
+
+fn pass_enum<const P: MyOption<u32>>() {}
+
+fn accepts_foo<const N: usize, const M: Foo<N>>() {}
+
+fn accepts_bar<T: ConstParamTy_, const B: MyOption<T>>() {}
+
+fn test<T: ConstParamTy_, const N: usize>() {
+    accepts_foo::<N, { Foo::<N> }>();
+    accepts_bar::<T, { MyOption::None::<T> }>();
+}
+
+fn main() {
+    Led::<{ Colour }>;
+}
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts.rs b/tests/ui/const-generics/mgca/explicit_anon_consts.rs
index f3edc0b3fbf3..bf825a44b1c0 100644
--- a/tests/ui/const-generics/mgca/explicit_anon_consts.rs
+++ b/tests/ui/const-generics/mgca/explicit_anon_consts.rs
@@ -1,4 +1,4 @@
-#![feature(associated_const_equality, generic_const_items, min_generic_const_args)]
+#![feature(generic_const_items, min_generic_const_args)]
 #![expect(incomplete_features)]
 // library crates exercise weirder code paths around
 // DefIds which were created for const args.
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
index 8c8c5c8e8f88..8131a5b72343 100644
--- a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
+++ b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
@@ -1,10 +1,6 @@
-// We allow for literals to implicitly be anon consts still regardless
-// of whether a const block is placed around them or not
-//
-// However, we don't allow so for const arguments in field init positions.
-// This is just harder to implement so we did not do so.
+//@ check-pass
 
-#![feature(min_generic_const_args, adt_const_params, associated_const_equality)]
+#![feature(min_generic_const_args, adt_const_params)]
 #![expect(incomplete_features)]
 
 trait Trait {
@@ -27,7 +23,7 @@ fn struct_expr() {
     fn takes_n<const N: ADT>() {}
 
     takes_n::<{ ADT { field: 1 } }>();
-    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+
     takes_n::<{ ADT { field: const { 1 } } }>();
 }
 
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr
deleted file mode 100644
index 02647fd808cc..000000000000
--- a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts_literals_hack.rs:29:30
-   |
-LL |     takes_n::<{ ADT { field: 1 } }>();
-   |                              ^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.rs b/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.rs
index fbe310f7de4c..819323d9cbec 100644
--- a/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.rs
+++ b/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.rs
@@ -9,7 +9,7 @@ struct Foo;
 
 trait Trait {
     #[type_const]
-    const ASSOC: usize;
+    const ASSOC: u32;
 }
 
 fn foo<const N: Foo>() {}
@@ -25,3 +25,14 @@ fn baz<T: Trait>() {
 }
 
 fn main() {}
+
+fn test_ice_missing_bound<T>() {
+    foo::<{ Option::Some::<u32> { 0: <T as Trait>::ASSOC } }>();
+    //~^ ERROR the trait bound `T: Trait` is not satisfied
+    //~| ERROR the constant `Option::<u32>::Some(_)` is not of type `Foo`
+}
+
+fn test_underscore_inference() {
+    foo::<{ Option::Some::<u32> { 0: _ } }>();
+    //~^ ERROR the constant `Option::<u32>::Some(_)` is not of type `Foo`
+}
diff --git a/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.stderr b/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.stderr
index 8b2871f2b6d3..0184aebf157a 100644
--- a/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.stderr
+++ b/tests/ui/const-generics/mgca/printing_valtrees_supports_non_values.stderr
@@ -2,7 +2,7 @@ error: the constant `Option::<u32>::Some(N)` is not of type `Foo`
   --> $DIR/printing_valtrees_supports_non_values.rs:18:13
    |
 LL |     foo::<{ Option::Some::<u32> { 0: N } }>;
-   |             ^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
    |
 note: required by a const generic parameter in `foo`
   --> $DIR/printing_valtrees_supports_non_values.rs:15:8
@@ -14,7 +14,7 @@ error: the constant `Option::<u32>::Some(<T as Trait>::ASSOC)` is not of type `F
   --> $DIR/printing_valtrees_supports_non_values.rs:23:13
    |
 LL |     foo::<{ Option::Some::<u32> { 0: <T as Trait>::ASSOC } }>();
-   |             ^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
    |
 note: required by a const generic parameter in `foo`
   --> $DIR/printing_valtrees_supports_non_values.rs:15:8
@@ -22,5 +22,41 @@ note: required by a const generic parameter in `foo`
 LL | fn foo<const N: Foo>() {}
    |        ^^^^^^^^^^^^ required by this const generic parameter in `foo`
 
-error: aborting due to 2 previous errors
+error[E0277]: the trait bound `T: Trait` is not satisfied
+  --> $DIR/printing_valtrees_supports_non_values.rs:30:5
+   |
+LL |     foo::<{ Option::Some::<u32> { 0: <T as Trait>::ASSOC } }>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T`
+   |
+help: consider restricting type parameter `T` with trait `Trait`
+   |
+LL | fn test_ice_missing_bound<T: Trait>() {
+   |                            +++++++
 
+error: the constant `Option::<u32>::Some(_)` is not of type `Foo`
+  --> $DIR/printing_valtrees_supports_non_values.rs:30:13
+   |
+LL |     foo::<{ Option::Some::<u32> { 0: <T as Trait>::ASSOC } }>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
+   |
+note: required by a const generic parameter in `foo`
+  --> $DIR/printing_valtrees_supports_non_values.rs:15:8
+   |
+LL | fn foo<const N: Foo>() {}
+   |        ^^^^^^^^^^^^ required by this const generic parameter in `foo`
+
+error: the constant `Option::<u32>::Some(_)` is not of type `Foo`
+  --> $DIR/printing_valtrees_supports_non_values.rs:36:13
+   |
+LL |     foo::<{ Option::Some::<u32> { 0: _ } }>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Foo`, found `Option<u32>`
+   |
+note: required by a const generic parameter in `foo`
+  --> $DIR/printing_valtrees_supports_non_values.rs:15:8
+   |
+LL | fn foo<const N: Foo>() {}
+   |        ^^^^^^^^^^^^ required by this const generic parameter in `foo`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_arg_simple.rs b/tests/ui/const-generics/mgca/tuple_ctor_arg_simple.rs
new file mode 100644
index 000000000000..a5b3d3d0d5b6
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_arg_simple.rs
@@ -0,0 +1,52 @@
+//@ run-pass
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+#![allow(dead_code)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+struct Point(u32, u32);
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+enum MyEnum<T> {
+    Variant(T),
+    Other,
+}
+
+trait Trait {
+    #[type_const]
+    const ASSOC: u32;
+}
+
+fn with_point<const P: Point>() -> Point {
+    P
+}
+
+fn with_enum<const E: MyEnum<u32>>() -> MyEnum<u32> {
+    E
+}
+
+fn test<T: Trait, const N: u32>() {
+    with_point::<{ Point(<T as Trait>::ASSOC, N) }>();
+}
+
+fn test_basic<const N: u32>() {
+    with_point::<{ Point(N, N) }>();
+    with_point::<{ Point(const { 5 }, const { 10 }) }>();
+
+    with_enum::<{ MyEnum::Variant::<u32>(N) }>();
+    with_enum::<{ MyEnum::Variant::<u32>(const { 42 }) }>();
+
+    with_enum::<{ <MyEnum<u32>>::Variant(N) }>();
+}
+
+fn main() {
+    test_basic::<5>();
+
+    let p = with_point::<{ Point(const { 1 }, const { 2 }) }>();
+    assert_eq!(p, Point(1, 2));
+
+    let e = with_enum::<{ MyEnum::Variant::<u32>(const { 10 }) }>();
+    assert_eq!(e, MyEnum::Variant(10));
+}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs
new file mode 100644
index 000000000000..2e39f8952b11
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs
@@ -0,0 +1,19 @@
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct Point(u32, u32);
+
+fn with_point<const P: Point>() {}
+
+fn test<const N: u32>() {
+    with_point::<{ Point(N + 1, N) }>();
+    //~^ ERROR complex const arguments must be placed inside of a `const` block
+
+    with_point::<{ Point(const { N + 1 }, N) }>();
+    //~^ ERROR generic parameters may not be used in const operations
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr
new file mode 100644
index 000000000000..e0ea3fd5560c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr
@@ -0,0 +1,14 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/tuple_ctor_complex_args.rs:12:26
+   |
+LL |     with_point::<{ Point(N + 1, N) }>();
+   |                          ^^^^^
+
+error: generic parameters may not be used in const operations
+  --> $DIR/tuple_ctor_complex_args.rs:15:34
+   |
+LL |     with_point::<{ Point(const { N + 1 }, N) }>();
+   |                                  ^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_erroneous.rs b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.rs
new file mode 100644
index 000000000000..84ded05fdd0e
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.rs
@@ -0,0 +1,46 @@
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct Point(u32, u32);
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+enum MyEnum<T> {
+    Variant(T),
+    Unit,
+}
+
+const CONST_ITEM: u32 = 42;
+
+fn accepts_point<const P: Point>() {}
+fn accepts_enum<const E: MyEnum<u32>>() {}
+
+fn non_ctor() {}
+
+fn test_errors<const N: usize>() {
+    accepts_point::<{ Point(N) }>();
+    //~^ ERROR tuple constructor has 2 arguments but 1 were provided
+
+    accepts_point::<{ Point(N, N, N) }>();
+    //~^ ERROR tuple constructor has 2 arguments but 3 were provided
+
+    accepts_point::<{ UnresolvedIdent(N, N) }>();
+    //~^ ERROR cannot find function, tuple struct or tuple variant `UnresolvedIdent` in this scope
+    //~| ERROR tuple constructor with invalid base path
+
+    accepts_point::<{ non_ctor(N, N) }>();
+    //~^ ERROR tuple constructor with invalid base path
+
+    accepts_point::<{ CONST_ITEM(N, N) }>();
+    //~^ ERROR tuple constructor with invalid base path
+
+    accepts_point::<{ Point }>();
+    //~^ ERROR the constant `Point` is not of type `Point`
+
+    accepts_enum::<{ MyEnum::Variant::<u32> }>();
+    //~^ ERROR the constant `MyEnum::<u32>::Variant` is not of type `MyEnum<u32>`
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_erroneous.stderr b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.stderr
new file mode 100644
index 000000000000..cc6144b9c88a
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.stderr
@@ -0,0 +1,68 @@
+error[E0425]: cannot find function, tuple struct or tuple variant `UnresolvedIdent` in this scope
+  --> $DIR/tuple_ctor_erroneous.rs:29:23
+   |
+LL |     accepts_point::<{ UnresolvedIdent(N, N) }>();
+   |                       ^^^^^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a const parameter
+   |
+LL | fn test_errors<const N: usize, const UnresolvedIdent: /* Type */>() {
+   |                              +++++++++++++++++++++++++++++++++++
+
+error: tuple constructor has 2 arguments but 1 were provided
+  --> $DIR/tuple_ctor_erroneous.rs:23:23
+   |
+LL |     accepts_point::<{ Point(N) }>();
+   |                       ^^^^^^^^
+
+error: tuple constructor has 2 arguments but 3 were provided
+  --> $DIR/tuple_ctor_erroneous.rs:26:23
+   |
+LL |     accepts_point::<{ Point(N, N, N) }>();
+   |                       ^^^^^^^^^^^^^^
+
+error: tuple constructor with invalid base path
+  --> $DIR/tuple_ctor_erroneous.rs:29:23
+   |
+LL |     accepts_point::<{ UnresolvedIdent(N, N) }>();
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: tuple constructor with invalid base path
+  --> $DIR/tuple_ctor_erroneous.rs:33:23
+   |
+LL |     accepts_point::<{ non_ctor(N, N) }>();
+   |                       ^^^^^^^^^^^^^^
+
+error: tuple constructor with invalid base path
+  --> $DIR/tuple_ctor_erroneous.rs:36:23
+   |
+LL |     accepts_point::<{ CONST_ITEM(N, N) }>();
+   |                       ^^^^^^^^^^^^^^^^
+
+error: the constant `Point` is not of type `Point`
+  --> $DIR/tuple_ctor_erroneous.rs:39:23
+   |
+LL |     accepts_point::<{ Point }>();
+   |                       ^^^^^ expected `Point`, found struct constructor
+   |
+note: required by a const generic parameter in `accepts_point`
+  --> $DIR/tuple_ctor_erroneous.rs:17:18
+   |
+LL | fn accepts_point<const P: Point>() {}
+   |                  ^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_point`
+
+error: the constant `MyEnum::<u32>::Variant` is not of type `MyEnum<u32>`
+  --> $DIR/tuple_ctor_erroneous.rs:42:22
+   |
+LL |     accepts_enum::<{ MyEnum::Variant::<u32> }>();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^ expected `MyEnum<u32>`, found enum constructor
+   |
+note: required by a const generic parameter in `accepts_enum`
+  --> $DIR/tuple_ctor_erroneous.rs:18:17
+   |
+LL | fn accepts_enum<const E: MyEnum<u32>>() {}
+   |                 ^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_enum`
+
+error: aborting due to 8 previous errors
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.rs b/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.rs
new file mode 100644
index 000000000000..5c7290b40be2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.rs
@@ -0,0 +1,16 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/136379>
+
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+pub struct S();
+
+impl S {
+    pub fn f() -> [u8; S] {
+        //~^ ERROR the constant `S` is not of type `usize`
+        []
+        //~^ ERROR mismatched types [E0308]
+    }
+}
+
+pub fn main() {}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.stderr b/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.stderr
new file mode 100644
index 000000000000..64c3cecd4fb5
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_in_array_len.stderr
@@ -0,0 +1,23 @@
+error: the constant `S` is not of type `usize`
+  --> $DIR/tuple_ctor_in_array_len.rs:9:19
+   |
+LL |     pub fn f() -> [u8; S] {
+   |                   ^^^^^^^ expected `usize`, found struct constructor
+   |
+   = note: the length of array `[u8; S]` must be type `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/tuple_ctor_in_array_len.rs:11:9
+   |
+LL |     pub fn f() -> [u8; S] {
+   |                   ------- expected `[u8; S]` because of return type
+LL |
+LL |         []
+   |         ^^ expected an array with a size of S, found one with a size of 0
+   |
+   = note: expected array `[u8; S]`
+              found array `[_; 0]`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_nested.rs b/tests/ui/const-generics/mgca/tuple_ctor_nested.rs
new file mode 100644
index 000000000000..49a31ea3e527
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_nested.rs
@@ -0,0 +1,38 @@
+//@ run-pass
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+struct Inner(u32);
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+struct Outer(Inner);
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+enum Container<T> {
+    Wrap(T),
+}
+
+fn with_outer<const O: Outer>() -> Outer {
+    O
+}
+
+fn with_container<const C: Container<Inner>>() -> Container<Inner> {
+    C
+}
+
+fn test<const N: u32>() {
+    with_outer::<{ Outer(Inner(N)) }>();
+    with_outer::<{ Outer(Inner(const { 42 })) }>();
+
+    with_container::<{ Container::Wrap::<Inner>(Inner(N)) }>();
+}
+
+fn main() {
+    test::<5>();
+
+    let o = with_outer::<{ Outer(Inner(const { 10 })) }>();
+    assert_eq!(o, Outer(Inner(10)));
+}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_type_relative.rs b/tests/ui/const-generics/mgca/tuple_ctor_type_relative.rs
new file mode 100644
index 000000000000..d5a07cbb7d70
--- /dev/null
+++ b/tests/ui/const-generics/mgca/tuple_ctor_type_relative.rs
@@ -0,0 +1,26 @@
+//@ run-pass
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Debug, Eq, PartialEq, ConstParamTy)]
+enum Option<T> {
+    Some(T),
+}
+
+fn with_option<const O: Option<u32>>() -> Option<u32> {
+    O
+}
+
+fn test<const N: u32>() {
+    with_option::<{ <Option<u32>>::Some(N) }>();
+    with_option::<{ <Option<u32>>::Some(const { 42 }) }>();
+}
+
+fn main() {
+    test::<5>();
+
+    let o = with_option::<{ <Option<u32>>::Some(const { 10 }) }>();
+    assert_eq!(o, Option::Some(10));
+}
diff --git a/tests/ui/const-generics/mgca/type_as_const_in_array_len.rs b/tests/ui/const-generics/mgca/type_as_const_in_array_len.rs
new file mode 100644
index 000000000000..b6b76fe3fc91
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_as_const_in_array_len.rs
@@ -0,0 +1,14 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/138132>
+
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+struct B(Box<[u8; C]>);
+//~^ ERROR missing generics for struct `C`
+impl B {
+    fn d(self) {
+        self.0.e()
+    }
+}
+struct C<'a>(&'a u8);
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_as_const_in_array_len.stderr b/tests/ui/const-generics/mgca/type_as_const_in_array_len.stderr
new file mode 100644
index 000000000000..482fd730a71c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_as_const_in_array_len.stderr
@@ -0,0 +1,19 @@
+error[E0107]: missing generics for struct `C`
+  --> $DIR/type_as_const_in_array_len.rs:6:19
+   |
+LL | struct B(Box<[u8; C]>);
+   |                   ^ expected 1 lifetime argument
+   |
+note: struct defined here, with 1 lifetime parameter: `'a`
+  --> $DIR/type_as_const_in_array_len.rs:13:8
+   |
+LL | struct C<'a>(&'a u8);
+   |        ^ --
+help: add missing lifetime argument
+   |
+LL | struct B(Box<[u8; C<'a>]>);
+   |                    ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/const-generics/mgca/type_const-array-return.rs b/tests/ui/const-generics/mgca/type_const-array-return.rs
new file mode 100644
index 000000000000..5375e4fded6d
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-array-return.rs
@@ -0,0 +1,26 @@
+//@ check-pass
+// This test should compile without an ICE.
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+pub struct A;
+
+pub trait Array {
+    #[type_const]
+    const LEN: usize;
+    fn arr() -> [u8; Self::LEN];
+}
+
+impl Array for A {
+    #[type_const]
+    const LEN: usize = 4;
+
+    #[allow(unused_braces)]
+    fn arr() -> [u8; const { Self::LEN }] {
+        return [0u8; const { Self::LEN }];
+    }
+}
+
+fn main() {
+    let _ = A::arr();
+}
diff --git a/tests/ui/const-generics/mgca/type_const-generic-param-in-type.gate.stderr b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.gate.stderr
new file mode 100644
index 000000000000..8a64af285da5
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.gate.stderr
@@ -0,0 +1,38 @@
+error: anonymous constants referencing generics are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:9:53
+   |
+LL | const FOO<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+   |                                                     ^^^^^^^^^^^^
+
+error: anonymous constants referencing generics are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:14:38
+   |
+LL | const BAR<const N: usize>: [(); N] = const { [] };
+   |                                      ^^^^^^^^^^^^
+
+error: anonymous constants with lifetimes in their type are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:19:30
+   |
+LL | const BAZ<'a>: [&'a (); 0] = const { [] };
+   |                              ^^^^^^^^^^^^
+
+error: anonymous constants referencing generics are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:39:59
+   |
+LL |     const ASSOC<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+   |                                                           ^^^^^^^^^^^^
+
+error: anonymous constants referencing generics are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:44:50
+   |
+LL |     const ASSOC_CONST<const N: usize>: [(); N] = const { [] };
+   |                                                  ^^^^^^^^^^^^
+
+error: anonymous constants with lifetimes in their type are not yet supported
+  --> $DIR/type_const-generic-param-in-type.rs:49:39
+   |
+LL |     const ASSOC_LT<'a>: [&'a (); 0] = const { [] };
+   |                                       ^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/const-generics/mgca/type_const-generic-param-in-type.nogate.stderr b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.nogate.stderr
new file mode 100644
index 000000000000..14ae276324ad
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.nogate.stderr
@@ -0,0 +1,57 @@
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:9:45
+   |
+LL | const FOO<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+   |                                             ^ the type must not depend on the parameter `T`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:14:33
+   |
+LL | const BAR<const N: usize>: [(); N] = const { [] };
+   |                                 ^ the type must not depend on the parameter `N`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:19:18
+   |
+LL | const BAZ<'a>: [&'a (); 0] = const { [] };
+   |                  ^^ the type must not depend on the parameter `'a`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:25:51
+   |
+LL |     const ASSOC<T: core::marker::ConstParamTy_>: [T; 0];
+   |                                                   ^ the type must not depend on the parameter `T`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:29:45
+   |
+LL |     const ASSOC_CONST<const N: usize>: [(); N];
+   |                                             ^ the type must not depend on the parameter `N`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:33:27
+   |
+LL |     const ASSOC_LT<'a>: [&'a (); 0];
+   |                           ^^ the type must not depend on the parameter `'a`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:39:51
+   |
+LL |     const ASSOC<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+   |                                                   ^ the type must not depend on the parameter `T`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:44:45
+   |
+LL |     const ASSOC_CONST<const N: usize>: [(); N] = const { [] };
+   |                                             ^ the type must not depend on the parameter `N`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/type_const-generic-param-in-type.rs:49:27
+   |
+LL |     const ASSOC_LT<'a>: [&'a (); 0] = const { [] };
+   |                           ^^ the type must not depend on the parameter `'a`
+
+error: aborting due to 9 previous errors
+
+For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/mgca/type_const-generic-param-in-type.rs b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.rs
new file mode 100644
index 000000000000..f1a4aba9bcee
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-generic-param-in-type.rs
@@ -0,0 +1,54 @@
+//@ revisions: nogate gate
+//@ [gate] check-fail
+// FIXME(generic_const_parameter_types): this should pass
+#![expect(incomplete_features)]
+#![feature(adt_const_params, unsized_const_params, min_generic_const_args, generic_const_items)]
+#![cfg_attr(gate, feature(generic_const_parameter_types))]
+
+#[type_const]
+const FOO<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+//[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+//[gate]~^^ ERROR anonymous constants referencing generics are not yet supported
+
+#[type_const]
+const BAR<const N: usize>: [(); N] = const { [] };
+//[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+//[gate]~^^ ERROR anonymous constants referencing generics are not yet supported
+
+#[type_const]
+const BAZ<'a>: [&'a (); 0] = const { [] };
+//[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+//[gate]~^^ ERROR anonymous constants with lifetimes in their type are not yet supported
+
+trait Tr {
+    #[type_const]
+    const ASSOC<T: core::marker::ConstParamTy_>: [T; 0];
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+
+    #[type_const]
+    const ASSOC_CONST<const N: usize>: [(); N];
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+
+    #[type_const]
+    const ASSOC_LT<'a>: [&'a (); 0];
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+}
+
+impl Tr for () {
+    #[type_const]
+    const ASSOC<T: core::marker::ConstParamTy_>: [T; 0] = const { [] };
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+    //[gate]~^^ ERROR anonymous constants referencing generics are not yet supported
+
+    #[type_const]
+    const ASSOC_CONST<const N: usize>: [(); N] = const { [] };
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+    //[gate]~^^ ERROR anonymous constants referencing generics are not yet supported
+
+    #[type_const]
+    const ASSOC_LT<'a>: [&'a (); 0] = const { [] };
+    //[nogate]~^ ERROR the type of const parameters must not depend on other generic parameters
+    //[gate]~^^ ERROR anonymous constants with lifetimes in their type are not yet supported
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs
new file mode 100644
index 000000000000..b2c734098009
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs
@@ -0,0 +1,12 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+struct A;
+
+impl A {
+    #[type_const]
+    const B = 4;
+    //~^ ERROR: missing type for `const` item
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr
new file mode 100644
index 000000000000..b44e47cd7e61
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr
@@ -0,0 +1,13 @@
+error: missing type for `const` item
+  --> $DIR/type_const-inherent-const-omitted-type.rs:8:12
+   |
+LL |     const B = 4;
+   |            ^
+   |
+help: provide a type for the item
+   |
+LL |     const B: <type> = 4;
+   |            ++++++++
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs
new file mode 100644
index 000000000000..ab613859aa5c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs
@@ -0,0 +1,22 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+trait BadTr {
+    const NUM: usize;
+}
+
+struct GoodS;
+
+impl BadTr for GoodS {
+    #[type_const]
+    const NUM: = 84;
+    //~^ ERROR: missing type for `const` item
+
+}
+
+fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+//~^ ERROR use of trait associated const without `#[type_const]`
+
+fn main() {
+    accept_bad_tr::<84, _>(&GoodS);
+}
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr
new file mode 100644
index 000000000000..16f312454ed2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr
@@ -0,0 +1,16 @@
+error: missing type for `const` item
+  --> $DIR/type_const-only-in-impl-omitted-type.rs:12:15
+   |
+LL |     const NUM: = 84;
+   |               ^ help: provide a type for the associated constant: `usize`
+
+error: use of trait associated const without `#[type_const]`
+  --> $DIR/type_const-only-in-impl-omitted-type.rs:17:43
+   |
+LL | fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+   |                                           ^^^^^^^^^^^
+   |
+   = note: the declaration in the trait must be marked with `#[type_const]`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-impl.rs b/tests/ui/const-generics/mgca/type_const-only-in-impl.rs
index ae4a0004232b..1887f511bd62 100644
--- a/tests/ui/const-generics/mgca/type_const-only-in-impl.rs
+++ b/tests/ui/const-generics/mgca/type_const-only-in-impl.rs
@@ -1,5 +1,5 @@
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait BadTr {
     const NUM: usize;
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-trait.rs b/tests/ui/const-generics/mgca/type_const-only-in-trait.rs
index 8c8ff6259cae..2ff38648206a 100644
--- a/tests/ui/const-generics/mgca/type_const-only-in-trait.rs
+++ b/tests/ui/const-generics/mgca/type_const-only-in-trait.rs
@@ -1,5 +1,5 @@
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait GoodTr {
     #[type_const]
diff --git a/tests/ui/const-generics/mgca/type_const-recursive.rs b/tests/ui/const-generics/mgca/type_const-recursive.rs
new file mode 100644
index 000000000000..15e49f747ed6
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-recursive.rs
@@ -0,0 +1,8 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+#[type_const]
+const A: u8 = A;
+//~^ ERROR: overflow normalizing the unevaluated constant `A` [E0275]
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-recursive.stderr b/tests/ui/const-generics/mgca/type_const-recursive.stderr
new file mode 100644
index 000000000000..947319ec7eda
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-recursive.stderr
@@ -0,0 +1,11 @@
+error[E0275]: overflow normalizing the unevaluated constant `A`
+  --> $DIR/type_const-recursive.rs:5:1
+   |
+LL | const A: u8 = A;
+   | ^^^^^^^^^^^
+   |
+   = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/const-generics/mgca/type_const-use.rs b/tests/ui/const-generics/mgca/type_const-use.rs
new file mode 100644
index 000000000000..04362cd28538
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-use.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+// This test should compile without an ICE.
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+#[type_const]
+const CONST: usize = 1;
+
+fn uses_const() {
+    CONST;
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/using-fnptr-as-type_const.rs b/tests/ui/const-generics/mgca/using-fnptr-as-type_const.rs
index d97b3a9f0929..5c494031d4fa 100644
--- a/tests/ui/const-generics/mgca/using-fnptr-as-type_const.rs
+++ b/tests/ui/const-generics/mgca/using-fnptr-as-type_const.rs
@@ -1,7 +1,7 @@
 // Regression test for #119783
 
 #![expect(incomplete_features)]
-#![feature(associated_const_equality, min_generic_const_args)]
+#![feature(min_generic_const_args)]
 
 trait Trait {
     #[type_const]
diff --git a/tests/ui/const-generics/parser-error-recovery/issue-89013-no-kw.stderr b/tests/ui/const-generics/parser-error-recovery/issue-89013-no-kw.stderr
index d435af07db2a..9c956d79a7bb 100644
--- a/tests/ui/const-generics/parser-error-recovery/issue-89013-no-kw.stderr
+++ b/tests/ui/const-generics/parser-error-recovery/issue-89013-no-kw.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl Foo<N = 3> for Bar {
    |          ^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0229]: associated item constraints are not allowed here
diff --git a/tests/ui/const-generics/parser-error-recovery/issue-89013.stderr b/tests/ui/const-generics/parser-error-recovery/issue-89013.stderr
index f852c14b1784..4a4ff098dc4b 100644
--- a/tests/ui/const-generics/parser-error-recovery/issue-89013.stderr
+++ b/tests/ui/const-generics/parser-error-recovery/issue-89013.stderr
@@ -16,8 +16,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl Foo<N = const 3> for Bar {
    |          ^^^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0229]: associated item constraints are not allowed here
diff --git a/tests/ui/consts/const-eval/heap/vec-not-made-global.rs b/tests/ui/consts/const-eval/heap/vec-not-made-global.rs
new file mode 100644
index 000000000000..4f78e977e4d5
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/vec-not-made-global.rs
@@ -0,0 +1,5 @@
+#![feature(const_heap)]
+const V: Vec<i32> = Vec::with_capacity(1);
+//~^ ERROR: encountered `const_allocate` pointer in final value that was not made global
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/vec-not-made-global.stderr b/tests/ui/consts/const-eval/heap/vec-not-made-global.stderr
new file mode 100644
index 000000000000..595cbeb8df26
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/vec-not-made-global.stderr
@@ -0,0 +1,10 @@
+error: encountered `const_allocate` pointer in final value that was not made global
+  --> $DIR/vec-not-made-global.rs:2:1
+   |
+LL | const V: Vec<i32> = Vec::with_capacity(1);
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: use `const_make_global` to turn allocated pointers into immutable globals before returning
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/consts/const-static-ref-to-closure.rs b/tests/ui/consts/const-static-ref-to-closure.rs
new file mode 100644
index 000000000000..06b5ca5a935c
--- /dev/null
+++ b/tests/ui/consts/const-static-ref-to-closure.rs
@@ -0,0 +1,7 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/25180>
+//@ check-pass
+#![allow(dead_code)]
+
+const X: &'static dyn Fn() = &|| println!("ICE here");
+
+fn main() {}
diff --git a/tests/ui/consts/rustc-impl-const-stability.stderr b/tests/ui/consts/rustc-impl-const-stability.stderr
deleted file mode 100644
index 55c085396882..000000000000
--- a/tests/ui/consts/rustc-impl-const-stability.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: const `impl` for trait `Debug` which is not `const`
-  --> $DIR/rustc-impl-const-stability.rs:15:12
-   |
-LL | impl const std::fmt::Debug for Data {
-   |            ^^^^^^^^^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/issues/auxiliary/issue-12660-aux.rs b/tests/ui/cross-crate/auxiliary/aux-12660.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-12660-aux.rs
rename to tests/ui/cross-crate/auxiliary/aux-12660.rs
diff --git a/tests/ui/issues/issue-12660.rs b/tests/ui/cross-crate/cross-crate-unit-struct-reexport.rs
similarity index 82%
rename from tests/ui/issues/issue-12660.rs
rename to tests/ui/cross-crate/cross-crate-unit-struct-reexport.rs
index 3aa3426519af..2d4e0c654ef3 100644
--- a/tests/ui/issues/issue-12660.rs
+++ b/tests/ui/cross-crate/cross-crate-unit-struct-reexport.rs
@@ -1,5 +1,5 @@
 //@ run-pass
-//@ aux-build:issue-12660-aux.rs
+//@ aux-build:aux-12660.rs
 
 
 extern crate issue12660aux;
diff --git a/tests/ui/issues/issue-29030.rs b/tests/ui/derives/derive-debug-generic-with-lifetime.rs
similarity index 66%
rename from tests/ui/issues/issue-29030.rs
rename to tests/ui/derives/derive-debug-generic-with-lifetime.rs
index c92853fb5dc2..430ade071795 100644
--- a/tests/ui/issues/issue-29030.rs
+++ b/tests/ui/derives/derive-debug-generic-with-lifetime.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/29030>
 //@ check-pass
 #![allow(dead_code)]
 #[derive(Debug)]
diff --git a/tests/ui/issues/issue-25394.rs b/tests/ui/derives/derive-debug-newtype-unsized-slice.rs
similarity index 54%
rename from tests/ui/issues/issue-25394.rs
rename to tests/ui/derives/derive-debug-newtype-unsized-slice.rs
index 689c9f33af02..c735d9f039d2 100644
--- a/tests/ui/issues/issue-25394.rs
+++ b/tests/ui/derives/derive-debug-newtype-unsized-slice.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/25394>
 //@ check-pass
 #![allow(dead_code)]
 #[derive(Debug)]
diff --git a/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.rs b/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.rs
new file mode 100644
index 000000000000..8e5cd4248f14
--- /dev/null
+++ b/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.rs
@@ -0,0 +1,14 @@
+//@ needs-rustc-debug-assertions
+
+struct NonGeneric {}
+
+#[derive(Default)]
+//~^ ERROR struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+//~^^ ERROR struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+//~^^^ ERROR struct takes 0 generic arguments but 1 generic argument was supplied
+//~^^^^ ERROR struct takes 0 generic arguments but 1 generic argument was supplied
+struct NonGeneric<'a, const N: usize> {}
+//~^ ERROR lifetime parameter `'a` is never used
+//~^^ ERROR the name `NonGeneric` is defined multiple times
+
+pub fn main() {}
diff --git a/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.stderr b/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.stderr
new file mode 100644
index 000000000000..cf9c0d0ad3be
--- /dev/null
+++ b/tests/ui/duplicate/multiple-types-with-same-name-and-derive-default-133965.stderr
@@ -0,0 +1,81 @@
+error[E0428]: the name `NonGeneric` is defined multiple times
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:10:1
+   |
+LL | struct NonGeneric {}
+   | ----------------- previous definition of the type `NonGeneric` here
+...
+LL | struct NonGeneric<'a, const N: usize> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `NonGeneric` redefined here
+   |
+   = note: `NonGeneric` must be defined only once in the type namespace of this module
+
+error[E0107]: struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:5:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^ expected 0 lifetime arguments
+...
+LL | struct NonGeneric<'a, const N: usize> {}
+   |                   -- help: remove the lifetime argument
+   |
+note: struct defined here, with 0 lifetime parameters
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:3:8
+   |
+LL | struct NonGeneric {}
+   |        ^^^^^^^^^^
+
+error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:5:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^ expected 0 generic arguments
+   |
+note: struct defined here, with 0 generic parameters
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:3:8
+   |
+LL | struct NonGeneric {}
+   |        ^^^^^^^^^^
+
+error[E0392]: lifetime parameter `'a` is never used
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:10:19
+   |
+LL | struct NonGeneric<'a, const N: usize> {}
+   |                   ^^ unused lifetime parameter
+   |
+   = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
+
+error[E0107]: struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:5:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^ expected 0 lifetime arguments
+...
+LL | struct NonGeneric<'a, const N: usize> {}
+   |                   -- help: remove the lifetime argument
+   |
+note: struct defined here, with 0 lifetime parameters
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:3:8
+   |
+LL | struct NonGeneric {}
+   |        ^^^^^^^^^^
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:5:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^ expected 0 generic arguments
+...
+LL | struct NonGeneric<'a, const N: usize> {}
+   |                             - help: remove the unnecessary generic argument
+   |
+note: struct defined here, with 0 generic parameters
+  --> $DIR/multiple-types-with-same-name-and-derive-default-133965.rs:3:8
+   |
+LL | struct NonGeneric {}
+   |        ^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0107, E0392, E0428.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/eii/auxiliary/codegen1.rs b/tests/ui/eii/auxiliary/other_crate_privacy1.rs
similarity index 100%
rename from tests/ui/eii/auxiliary/codegen1.rs
rename to tests/ui/eii/auxiliary/other_crate_privacy1.rs
diff --git a/tests/ui/eii/auxiliary/codegen3.rs b/tests/ui/eii/auxiliary/other_crate_privacy2.rs
similarity index 100%
rename from tests/ui/eii/auxiliary/codegen3.rs
rename to tests/ui/eii/auxiliary/other_crate_privacy2.rs
diff --git a/tests/ui/eii/duplicate/eii_conflict_with_macro.rs b/tests/ui/eii/duplicate/eii_conflict_with_macro.rs
new file mode 100644
index 000000000000..d8118f8417a0
--- /dev/null
+++ b/tests/ui/eii/duplicate/eii_conflict_with_macro.rs
@@ -0,0 +1,7 @@
+//@ compile-flags: --crate-type rlib
+//@ build-pass
+#![feature(extern_item_impls)]
+
+macro_rules! foo_impl { () => {} }
+#[eii]
+fn foo_impl() {}
diff --git a/tests/ui/eii/multiple_decls.rs b/tests/ui/eii/duplicate/multiple_decls.rs
similarity index 100%
rename from tests/ui/eii/multiple_decls.rs
rename to tests/ui/eii/duplicate/multiple_decls.rs
diff --git a/tests/ui/eii/multiple_decls.stderr b/tests/ui/eii/duplicate/multiple_decls.stderr
similarity index 100%
rename from tests/ui/eii/multiple_decls.stderr
rename to tests/ui/eii/duplicate/multiple_decls.stderr
diff --git a/tests/ui/eii/multiple_impls.rs b/tests/ui/eii/duplicate/multiple_impls.rs
similarity index 100%
rename from tests/ui/eii/multiple_impls.rs
rename to tests/ui/eii/duplicate/multiple_impls.rs
diff --git a/tests/ui/eii/multiple_impls.run.stdout b/tests/ui/eii/duplicate/multiple_impls.run.stdout
similarity index 100%
rename from tests/ui/eii/multiple_impls.run.stdout
rename to tests/ui/eii/duplicate/multiple_impls.run.stdout
diff --git a/tests/ui/eii/auxiliary/codegen2.rs b/tests/ui/eii/linking/auxiliary/codegen_cross_crate_other_crate.rs
similarity index 100%
rename from tests/ui/eii/auxiliary/codegen2.rs
rename to tests/ui/eii/linking/auxiliary/codegen_cross_crate_other_crate.rs
diff --git a/tests/ui/eii/codegen_cross_crate.rs b/tests/ui/eii/linking/codegen_cross_crate.rs
similarity index 82%
rename from tests/ui/eii/codegen_cross_crate.rs
rename to tests/ui/eii/linking/codegen_cross_crate.rs
index a1fa617491bd..4016712e7504 100644
--- a/tests/ui/eii/codegen_cross_crate.rs
+++ b/tests/ui/eii/linking/codegen_cross_crate.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 //@ check-run-results
-//@ aux-build: codegen2.rs
+//@ aux-build: codegen_cross_crate_other_crate.rs
 //@ compile-flags: -O
 //@ ignore-backends: gcc
 // FIXME: linking on windows (speciifcally mingw) not yet supported, see tracking issue #125418
@@ -8,7 +8,7 @@
 // Tests whether calling EIIs works with the declaration in another crate.
 #![feature(extern_item_impls)]
 
-extern crate codegen2 as codegen;
+extern crate codegen_cross_crate_other_crate as codegen;
 
 #[codegen::eii1]
 fn eii1_impl(x: u64) {
diff --git a/tests/ui/eii/codegen_cross_crate.run.stdout b/tests/ui/eii/linking/codegen_cross_crate.run.stdout
similarity index 100%
rename from tests/ui/eii/codegen_cross_crate.run.stdout
rename to tests/ui/eii/linking/codegen_cross_crate.run.stdout
diff --git a/tests/ui/eii/codegen_single_crate.rs b/tests/ui/eii/linking/codegen_single_crate.rs
similarity index 100%
rename from tests/ui/eii/codegen_single_crate.rs
rename to tests/ui/eii/linking/codegen_single_crate.rs
diff --git a/tests/ui/eii/codegen_single_crate.run.stdout b/tests/ui/eii/linking/codegen_single_crate.run.stdout
similarity index 100%
rename from tests/ui/eii/codegen_single_crate.run.stdout
rename to tests/ui/eii/linking/codegen_single_crate.run.stdout
diff --git a/tests/ui/eii/same-symbol.rs b/tests/ui/eii/linking/same-symbol.rs
similarity index 100%
rename from tests/ui/eii/same-symbol.rs
rename to tests/ui/eii/linking/same-symbol.rs
diff --git a/tests/ui/eii/same-symbol.run.stdout b/tests/ui/eii/linking/same-symbol.run.stdout
similarity index 100%
rename from tests/ui/eii/same-symbol.run.stdout
rename to tests/ui/eii/linking/same-symbol.run.stdout
diff --git a/tests/ui/eii/privacy1.rs b/tests/ui/eii/privacy1.rs
index b5bbf68bfdaf..72aec83d2cee 100644
--- a/tests/ui/eii/privacy1.rs
+++ b/tests/ui/eii/privacy1.rs
@@ -1,13 +1,13 @@
 //@ run-pass
 //@ check-run-results
-//@ aux-build: codegen1.rs
+//@ aux-build: other_crate_privacy1.rs
 //@ ignore-backends: gcc
-// FIXME: linking on windows (speciifcally mingw) not yet supported, see tracking issue #125418
+// FIXME: linking on windows (specifically mingw) not yet supported, see tracking issue #125418
 //@ ignore-windows
 // Tests whether re-exports work.
 #![feature(extern_item_impls)]
 
-extern crate codegen1 as codegen;
+extern crate other_crate_privacy1 as codegen;
 
 #[codegen::eii1]
 fn eii1_impl(x: u64) {
diff --git a/tests/ui/eii/privacy2.rs b/tests/ui/eii/privacy2.rs
index a4ae188bd0ec..e3f1f8c863da 100644
--- a/tests/ui/eii/privacy2.rs
+++ b/tests/ui/eii/privacy2.rs
@@ -1,8 +1,8 @@
-//@ aux-build:codegen3.rs
-// Tests whether name resulution respects privacy properly.
+//@ aux-build:other_crate_privacy2.rs
+// Tests whether name resolution respects privacy properly.
 #![feature(extern_item_impls)]
 
-extern crate codegen3 as codegen;
+extern crate other_crate_privacy2 as codegen;
 
 // has a span but in the other crate
 //~? ERROR `#[eii2]` required, but not found
diff --git a/tests/ui/eii/privacy2.stderr b/tests/ui/eii/privacy2.stderr
index 0d44604567e4..9f4fd6a071c9 100644
--- a/tests/ui/eii/privacy2.stderr
+++ b/tests/ui/eii/privacy2.stderr
@@ -11,24 +11,24 @@ LL |     codegen::decl1(42);
    |              ^^^^^ private function
    |
 note: the function `decl1` is defined here
-  --> $DIR/auxiliary/codegen3.rs:7:1
+  --> $DIR/auxiliary/other_crate_privacy2.rs:7:1
    |
 LL | fn decl1(x: u64);
    | ^^^^^^^^^^^^^^^^^
 
 error: `#[eii2]` required, but not found
-  --> $DIR/auxiliary/codegen3.rs:9:1
+  --> $DIR/auxiliary/other_crate_privacy2.rs:9:7
    |
 LL | #[eii(eii2)]
-   | ^^^^^^^^^^^^ expected because `#[eii2]` was declared here in crate `codegen3`
+   |       ^^^^ expected because `#[eii2]` was declared here in crate `other_crate_privacy2`
    |
    = help: expected at least one implementation in crate `privacy2` or any of its dependencies
 
 error: `#[eii3]` required, but not found
-  --> $DIR/auxiliary/codegen3.rs:13:5
+  --> $DIR/auxiliary/other_crate_privacy2.rs:13:11
    |
 LL |     #[eii(eii3)]
-   |     ^^^^^^^^^^^^ expected because `#[eii3]` was declared here in crate `codegen3`
+   |           ^^^^ expected because `#[eii3]` was declared here in crate `other_crate_privacy2`
    |
    = help: expected at least one implementation in crate `privacy2` or any of its dependencies
 
diff --git a/tests/ui/eii/auxiliary/cross_crate_eii_declaration.rs b/tests/ui/eii/type_checking/auxiliary/cross_crate_eii_declaration.rs
similarity index 100%
rename from tests/ui/eii/auxiliary/cross_crate_eii_declaration.rs
rename to tests/ui/eii/type_checking/auxiliary/cross_crate_eii_declaration.rs
diff --git a/tests/ui/eii/cross_crate.rs b/tests/ui/eii/type_checking/cross_crate_type_ok.rs
similarity index 100%
rename from tests/ui/eii/cross_crate.rs
rename to tests/ui/eii/type_checking/cross_crate_type_ok.rs
diff --git a/tests/ui/eii/cross_crate_wrong_ty.rs b/tests/ui/eii/type_checking/cross_crate_wrong_ty.rs
similarity index 100%
rename from tests/ui/eii/cross_crate_wrong_ty.rs
rename to tests/ui/eii/type_checking/cross_crate_wrong_ty.rs
diff --git a/tests/ui/eii/cross_crate_wrong_ty.stderr b/tests/ui/eii/type_checking/cross_crate_wrong_ty.stderr
similarity index 100%
rename from tests/ui/eii/cross_crate_wrong_ty.stderr
rename to tests/ui/eii/type_checking/cross_crate_wrong_ty.stderr
diff --git a/tests/ui/error-codes/E0059.stderr b/tests/ui/error-codes/E0059.stderr
index d26fadcdbfa7..698ee0a2a902 100644
--- a/tests/ui/error-codes/E0059.stderr
+++ b/tests/ui/error-codes/E0059.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/E0059.rs:3:11
    |
 LL | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
-   |           ^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   |           ^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -11,7 +11,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/E0059.rs:3:41
    |
 LL | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
-   |                                         ^^^^ the trait `Tuple` is not implemented for `i32`
+   |                                         ^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error[E0059]: cannot use call notation; the first type parameter for the function trait is neither a tuple nor unit
   --> $DIR/E0059.rs:3:41
diff --git a/tests/ui/feature-gates/feature-gate-associated_const_equality.rs b/tests/ui/feature-gates/feature-gate-associated_const_equality.rs
index 2534c527be46..6b643b629a29 100644
--- a/tests/ui/feature-gates/feature-gate-associated_const_equality.rs
+++ b/tests/ui/feature-gates/feature-gate-associated_const_equality.rs
@@ -8,7 +8,7 @@ impl TraitWAssocConst for Demo {
 }
 
 fn foo<A: TraitWAssocConst<A=32>>() {}
-//~^ ERROR associated const equality
+//~^ ERROR associated const equality is incomplete
 
 fn main() {
   foo::<Demo>();
diff --git a/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr b/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
index 5a0fb69b6ba7..096755701931 100644
--- a/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
+++ b/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | fn foo<A: TraitWAssocConst<A=32>>() {}
    |                            ^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/feature-gates/feature-gate-multiple_supertrait_upcastable.stderr b/tests/ui/feature-gates/feature-gate-multiple_supertrait_upcastable.stderr
index 0c7e68a599cd..0fd987e40289 100644
--- a/tests/ui/feature-gates/feature-gate-multiple_supertrait_upcastable.stderr
+++ b/tests/ui/feature-gates/feature-gate-multiple_supertrait_upcastable.stderr
@@ -5,6 +5,7 @@ LL | #![deny(multiple_supertrait_upcastable)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: the `multiple_supertrait_upcastable` lint is unstable
+   = note: see issue #150833 <https://github.com/rust-lang/rust/issues/150833> for more information
    = help: add `#![feature(multiple_supertrait_upcastable)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = note: `#[warn(unknown_lints)]` on by default
@@ -16,6 +17,7 @@ LL | #![warn(multiple_supertrait_upcastable)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: the `multiple_supertrait_upcastable` lint is unstable
+   = note: see issue #150833 <https://github.com/rust-lang/rust/issues/150833> for more information
    = help: add `#![feature(multiple_supertrait_upcastable)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
diff --git a/tests/ui/fmt/format-string-error-2.rs b/tests/ui/fmt/format-string-error-2.rs
index 357dd7b10a3e..e14a4064aa83 100644
--- a/tests/ui/fmt/format-string-error-2.rs
+++ b/tests/ui/fmt/format-string-error-2.rs
@@ -83,4 +83,7 @@ raw  { \n
 
     println!(r#"\x7B}\u8 {"#, 1);
     //~^ ERROR invalid format string: unmatched `}` found
+
+    println!("{x?}, world!",);
+    //~^ ERROR invalid format string: expected `}`, found `?`
 }
diff --git a/tests/ui/fmt/format-string-error-2.stderr b/tests/ui/fmt/format-string-error-2.stderr
index 6d8c34fdb709..b117fb57cf07 100644
--- a/tests/ui/fmt/format-string-error-2.stderr
+++ b/tests/ui/fmt/format-string-error-2.stderr
@@ -177,5 +177,16 @@ LL |     println!(r#"\x7B}\u8 {"#, 1);
    |
    = note: if you intended to print `}`, you can escape it using `}}`
 
-error: aborting due to 18 previous errors
+error: invalid format string: expected `}`, found `?`
+  --> $DIR/format-string-error-2.rs:87:17
+   |
+LL |     println!("{x?}, world!",);
+   |                 ^
+   |                 |
+   |                 expected `:` before `?` to format with `Debug` in format string
+   |                 help: add a colon before the format specifier: `:?`
+   |
+   = note: to print `{`, you can escape it using `{{`
+
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/issues/issue-33687.rs b/tests/ui/fn_traits/call-unit-struct-impl-fn-once.rs
similarity index 79%
rename from tests/ui/issues/issue-33687.rs
rename to tests/ui/fn_traits/call-unit-struct-impl-fn-once.rs
index a5693b3aca8e..15554482931b 100644
--- a/tests/ui/issues/issue-33687.rs
+++ b/tests/ui/fn_traits/call-unit-struct-impl-fn-once.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/33687>
 //@ run-pass
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
diff --git a/tests/ui/issues/issue-20847.rs b/tests/ui/fn_traits/fn-trait-explicit-call.rs
similarity index 65%
rename from tests/ui/issues/issue-20847.rs
rename to tests/ui/fn_traits/fn-trait-explicit-call.rs
index 364b07bf6922..f37e0a558baa 100644
--- a/tests/ui/issues/issue-20847.rs
+++ b/tests/ui/fn_traits/fn-trait-explicit-call.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/20847>
 //@ run-pass
 #![feature(fn_traits)]
 
diff --git a/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.rs b/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.rs
new file mode 100644
index 000000000000..69b57486138d
--- /dev/null
+++ b/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.rs
@@ -0,0 +1,39 @@
+//! Don't suggest breaking with value from `for` or `while` loops
+//!
+//! Regression test for https://github.com/rust-lang/rust/issues/150850
+
+fn returns_i32() -> i32 { 0 }
+
+fn suggest_breaking_from_loop() {
+    let _ = loop {
+        returns_i32() //~ ERROR mismatched types
+        //~^ SUGGESTION ;
+        //~| SUGGESTION break
+    };
+}
+
+fn dont_suggest_breaking_from_for() {
+    let _ = for _ in 0.. {
+        returns_i32() //~ ERROR mismatched types
+        //~^ SUGGESTION ;
+    };
+}
+
+fn dont_suggest_breaking_from_while() {
+    let cond = true;
+    let _ = while cond {
+        returns_i32() //~ ERROR mismatched types
+        //~^ SUGGESTION ;
+    };
+}
+
+fn dont_suggest_breaking_from_for_nested_in_loop() {
+    let _ = loop {
+        for _ in 0.. {
+            returns_i32() //~ ERROR mismatched types
+            //~^ SUGGESTION ;
+        }
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.stderr b/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.stderr
new file mode 100644
index 000000000000..880cc53f9a7c
--- /dev/null
+++ b/tests/ui/for-loop-while/dont-suggest-break-from-unbreakable-loops.stderr
@@ -0,0 +1,42 @@
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-break-from-unbreakable-loops.rs:9:9
+   |
+LL |         returns_i32()
+   |         ^^^^^^^^^^^^^ expected `()`, found `i32`
+   |
+help: consider using a semicolon here
+   |
+LL |         returns_i32();
+   |                      +
+help: you might have meant to break the loop with this value
+   |
+LL |         break returns_i32();
+   |         +++++              +
+
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-break-from-unbreakable-loops.rs:17:9
+   |
+LL |         returns_i32()
+   |         ^^^^^^^^^^^^^- help: consider using a semicolon here: `;`
+   |         |
+   |         expected `()`, found `i32`
+
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-break-from-unbreakable-loops.rs:25:9
+   |
+LL |         returns_i32()
+   |         ^^^^^^^^^^^^^- help: consider using a semicolon here: `;`
+   |         |
+   |         expected `()`, found `i32`
+
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-break-from-unbreakable-loops.rs:33:13
+   |
+LL |             returns_i32()
+   |             ^^^^^^^^^^^^^- help: consider using a semicolon here: `;`
+   |             |
+   |             expected `()`, found `i32`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/force-inlining/invalid.stderr b/tests/ui/force-inlining/invalid.stderr
index df3b646b6cec..ce4f1d77ad2d 100644
--- a/tests/ui/force-inlining/invalid.stderr
+++ b/tests/ui/force-inlining/invalid.stderr
@@ -152,7 +152,7 @@ LL | #[rustc_force_inline]
    |
    = help: `#[rustc_force_inline]` can only be applied to functions
 
-error: `#[rustc_force_inline]` attribute cannot be used on function params
+error: `#[rustc_force_inline]` attribute cannot be used on type parameters
   --> $DIR/invalid.rs:72:10
    |
 LL | enum Bar<#[rustc_force_inline] T> {
diff --git a/tests/ui/generic-const-items/assoc-const-no-infer-ice-115806.rs b/tests/ui/generic-const-items/assoc-const-no-infer-ice-115806.rs
index a72aaedb980e..fb2506daf078 100644
--- a/tests/ui/generic-const-items/assoc-const-no-infer-ice-115806.rs
+++ b/tests/ui/generic-const-items/assoc-const-no-infer-ice-115806.rs
@@ -1,6 +1,6 @@
 // ICE: assertion failed: !value.has_infer()
 // issue: rust-lang/rust#115806
-#![feature(associated_const_equality, min_generic_const_args, unsized_const_params)]
+#![feature(min_generic_const_args, unsized_const_params)]
 #![allow(incomplete_features)]
 
 pub struct NoPin;
diff --git a/tests/ui/generic-const-items/associated-const-equality.rs b/tests/ui/generic-const-items/associated-const-equality.rs
index 37cf381e6824..d0301b920e27 100644
--- a/tests/ui/generic-const-items/associated-const-equality.rs
+++ b/tests/ui/generic-const-items/associated-const-equality.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 
 #![feature(generic_const_items, min_generic_const_args)]
-#![feature(associated_const_equality, adt_const_params)]
+#![feature(adt_const_params)]
 #![allow(incomplete_features)]
 
 trait Owner {
diff --git a/tests/ui/generics/wrong-number-of-args.rs b/tests/ui/generics/wrong-number-of-args.rs
index 6524bd538b6b..8bc384a3d817 100644
--- a/tests/ui/generics/wrong-number-of-args.rs
+++ b/tests/ui/generics/wrong-number-of-args.rs
@@ -321,10 +321,6 @@ mod stdlib {
         //~| ERROR struct takes at least 2
         //~| HELP add missing
 
-        type D = HashMap<usize, String, char, f64>;
-        //~^ ERROR struct takes at most 3
-        //~| HELP remove the
-
         type E = HashMap<>;
         //~^ ERROR struct takes at least 2 generic arguments but 0 generic arguments
         //~| HELP add missing
diff --git a/tests/ui/generics/wrong-number-of-args.stderr b/tests/ui/generics/wrong-number-of-args.stderr
index bac0d26b622d..bedeeb812fc9 100644
--- a/tests/ui/generics/wrong-number-of-args.stderr
+++ b/tests/ui/generics/wrong-number-of-args.stderr
@@ -926,16 +926,8 @@ help: add missing generic arguments
 LL |         type C = HashMap<'static, K, V>;
    |                                 ++++++
 
-error[E0107]: struct takes at most 3 generic arguments but 4 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:324:18
-   |
-LL |         type D = HashMap<usize, String, char, f64>;
-   |                  ^^^^^^^                    ----- help: remove the unnecessary generic argument
-   |                  |
-   |                  expected at most 3 generic arguments
-
 error[E0107]: struct takes at least 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:328:18
+  --> $DIR/wrong-number-of-args.rs:324:18
    |
 LL |         type E = HashMap<>;
    |                  ^^^^^^^ expected at least 2 generic arguments
@@ -946,7 +938,7 @@ LL |         type E = HashMap<K, V>;
    |                          ++++
 
 error[E0107]: missing generics for enum `Result`
-  --> $DIR/wrong-number-of-args.rs:334:18
+  --> $DIR/wrong-number-of-args.rs:330:18
    |
 LL |         type A = Result;
    |                  ^^^^^^ expected 2 generic arguments
@@ -957,7 +949,7 @@ LL |         type A = Result<T, E>;
    |                        ++++++
 
 error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
-  --> $DIR/wrong-number-of-args.rs:338:18
+  --> $DIR/wrong-number-of-args.rs:334:18
    |
 LL |         type B = Result<String>;
    |                  ^^^^^^ ------ supplied 1 generic argument
@@ -970,7 +962,7 @@ LL |         type B = Result<String, E>;
    |                               +++
 
 error[E0107]: enum takes 0 lifetime arguments but 1 lifetime argument was supplied
-  --> $DIR/wrong-number-of-args.rs:342:18
+  --> $DIR/wrong-number-of-args.rs:338:18
    |
 LL |         type C = Result<'static>;
    |                  ^^^^^^--------- help: remove the unnecessary generics
@@ -978,7 +970,7 @@ LL |         type C = Result<'static>;
    |                  expected 0 lifetime arguments
 
 error[E0107]: enum takes 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:342:18
+  --> $DIR/wrong-number-of-args.rs:338:18
    |
 LL |         type C = Result<'static>;
    |                  ^^^^^^ expected 2 generic arguments
@@ -989,7 +981,7 @@ LL |         type C = Result<'static, T, E>;
    |                                ++++++
 
 error[E0107]: enum takes 2 generic arguments but 3 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:348:18
+  --> $DIR/wrong-number-of-args.rs:344:18
    |
 LL |         type D = Result<usize, String, char>;
    |                  ^^^^^^              ------ help: remove the unnecessary generic argument
@@ -997,7 +989,7 @@ LL |         type D = Result<usize, String, char>;
    |                  expected 2 generic arguments
 
 error[E0107]: enum takes 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:352:18
+  --> $DIR/wrong-number-of-args.rs:348:18
    |
 LL |         type E = Result<>;
    |                  ^^^^^^ expected 2 generic arguments
@@ -1007,7 +999,7 @@ help: add missing generic arguments
 LL |         type E = Result<T, E>;
    |                         ++++
 
-error: aborting due to 71 previous errors
+error: aborting due to 70 previous errors
 
 Some errors have detailed explanations: E0106, E0107.
 For more information about an error, try `rustc --explain E0106`.
diff --git a/tests/ui/hygiene/duplicate_lifetimes.rs b/tests/ui/hygiene/duplicate_lifetimes.rs
index 8971fb62626c..4d128da7fdbf 100644
--- a/tests/ui/hygiene/duplicate_lifetimes.rs
+++ b/tests/ui/hygiene/duplicate_lifetimes.rs
@@ -3,7 +3,7 @@
 
 #![feature(decl_macro, rustc_attrs)]
 
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 macro m($a:lifetime) {
     fn g<$a, 'a>() {} //~ ERROR the name `'a` is already used for a generic parameter
 }
diff --git a/tests/ui/hygiene/generic_params.rs b/tests/ui/hygiene/generic_params.rs
index def9be3a1b64..bb0de15d9a0a 100644
--- a/tests/ui/hygiene/generic_params.rs
+++ b/tests/ui/hygiene/generic_params.rs
@@ -11,7 +11,7 @@ mod type_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($T:ident) {
         fn g<$T: Clone>(t1: $T, t2: T) -> (T, $T) {
             (t1.clone(), t2.clone())
@@ -43,7 +43,7 @@ mod lifetime_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($a:lifetime) {
         fn g<$a>(t1: &$a(), t2: &'a ()) -> (&'a (), &$a ()) {
             (t1, t2)
@@ -75,7 +75,7 @@ mod const_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($C:ident) {
         fn g<const $C: usize>(t1: [(); $C], t2: [(); C]) -> ([(); C], [(); $C]) {
             (t1, t2)
diff --git a/tests/ui/hygiene/rustc-macro-transparency.rs b/tests/ui/hygiene/rustc-macro-transparency.rs
index 1a78a7543cfd..0c680abb4153 100644
--- a/tests/ui/hygiene/rustc-macro-transparency.rs
+++ b/tests/ui/hygiene/rustc-macro-transparency.rs
@@ -5,7 +5,7 @@ macro transparent() {
     struct Transparent;
     let transparent = 0;
 }
-#[rustc_macro_transparency = "semitransparent"]
+#[rustc_macro_transparency = "semiopaque"]
 macro semiopaque() {
     struct SemiOpaque;
     let semiopaque = 0;
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index 6cab4fabb1ff..1a8d6509e137 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -384,11 +384,11 @@ LL | fn in_impl_Fn_return_in_return() -> &'static impl Fn() -> impl Debug { pani
    |
    = note: multiple `impl`s satisfying `_: Fn()` found in the following crates: `alloc`, `core`:
            - impl<A, F> Fn<A> for &F
-             where A: Tuple, F: Fn<A>, F: ?Sized;
+             where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
-             where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+             where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
            - impl<F, Args> Fn<Args> for Exclusive<F>
-             where F: Sync, F: Fn<Args>, Args: Tuple;
+             where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
 
 error[E0118]: no nominal type found for inherent implementation
   --> $DIR/where-allowed.rs:241:1
diff --git a/tests/ui/imports/ambiguous-14.stderr b/tests/ui/imports/ambiguous-14.stderr
index 4efa31c61e32..2a3557c31f12 100644
--- a/tests/ui/imports/ambiguous-14.stderr
+++ b/tests/ui/imports/ambiguous-14.stderr
@@ -8,15 +8,15 @@ LL |     g::foo();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/ambiguous-14.rs:13:13
+  --> $DIR/ambiguous-14.rs:18:13
    |
 LL |     pub use a::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/ambiguous-14.rs:14:13
+  --> $DIR/ambiguous-14.rs:19:13
    |
-LL |     pub use b::*;
+LL |     pub use f::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
    = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
@@ -34,15 +34,15 @@ LL |     g::foo();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/ambiguous-14.rs:13:13
+  --> $DIR/ambiguous-14.rs:18:13
    |
 LL |     pub use a::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/ambiguous-14.rs:14:13
+  --> $DIR/ambiguous-14.rs:19:13
    |
-LL |     pub use b::*;
+LL |     pub use f::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
    = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
diff --git a/tests/ui/imports/ambiguous-glob-vs-expanded-extern.rs b/tests/ui/imports/ambiguous-glob-vs-expanded-extern.rs
index de632119ecba..0277da46f750 100644
--- a/tests/ui/imports/ambiguous-glob-vs-expanded-extern.rs
+++ b/tests/ui/imports/ambiguous-glob-vs-expanded-extern.rs
@@ -1,6 +1,6 @@
+//@ check-pass
 //@ aux-crate: glob_vs_expanded=glob-vs-expanded.rs
 
 fn main() {
-    glob_vs_expanded::mac!(); //~ ERROR `mac` is ambiguous
-                              //~| WARN this was previously accepted
+    glob_vs_expanded::mac!(); // OK
 }
diff --git a/tests/ui/imports/ambiguous-glob-vs-expanded-extern.stderr b/tests/ui/imports/ambiguous-glob-vs-expanded-extern.stderr
deleted file mode 100644
index 4a9a6c99819b..000000000000
--- a/tests/ui/imports/ambiguous-glob-vs-expanded-extern.stderr
+++ /dev/null
@@ -1,53 +0,0 @@
-error: `mac` is ambiguous
-  --> $DIR/ambiguous-glob-vs-expanded-extern.rs:4:23
-   |
-LL |     glob_vs_expanded::mac!();
-   |                       ^^^ ambiguous name
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
-note: `mac` could refer to the macro defined here
-  --> $DIR/auxiliary/glob-vs-expanded.rs:9:13
-   |
-LL |     () => { pub macro mac() {} }
-   |             ^^^^^^^^^^^^^
-LL | }
-LL | define_mac!();
-   | ------------- in this macro invocation
-note: `mac` could also refer to the macro defined here
-  --> $DIR/auxiliary/glob-vs-expanded.rs:5:9
-   |
-LL | pub use inner::*;
-   |         ^^^^^
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the macro `define_mac` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 1 previous error
-
-Future incompatibility report: Future breakage diagnostic:
-error: `mac` is ambiguous
-  --> $DIR/ambiguous-glob-vs-expanded-extern.rs:4:23
-   |
-LL |     glob_vs_expanded::mac!();
-   |                       ^^^ ambiguous name
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
-note: `mac` could refer to the macro defined here
-  --> $DIR/auxiliary/glob-vs-expanded.rs:9:13
-   |
-LL |     () => { pub macro mac() {} }
-   |             ^^^^^^^^^^^^^
-LL | }
-LL | define_mac!();
-   | ------------- in this macro invocation
-note: `mac` could also refer to the macro defined here
-  --> $DIR/auxiliary/glob-vs-expanded.rs:5:9
-   |
-LL | pub use inner::*;
-   |         ^^^^^
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the macro `define_mac` (in Nightly builds, run with -Z macro-backtrace for more info)
-
diff --git a/tests/ui/imports/duplicate.stderr b/tests/ui/imports/duplicate.stderr
index 5cd3b0c2c8a5..74829fc21e22 100644
--- a/tests/ui/imports/duplicate.stderr
+++ b/tests/ui/imports/duplicate.stderr
@@ -78,15 +78,15 @@ LL |     g::foo();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/duplicate.rs:24:13
+  --> $DIR/duplicate.rs:29:13
    |
 LL |     pub use crate::a::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/duplicate.rs:25:13
+  --> $DIR/duplicate.rs:30:13
    |
-LL |     pub use crate::b::*;
+LL |     pub use crate::f::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
    = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
@@ -106,15 +106,15 @@ LL |     g::foo();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/duplicate.rs:24:13
+  --> $DIR/duplicate.rs:29:13
    |
 LL |     pub use crate::a::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/duplicate.rs:25:13
+  --> $DIR/duplicate.rs:30:13
    |
-LL |     pub use crate::b::*;
+LL |     pub use crate::f::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
    = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
diff --git a/tests/ui/imports/issue-114682-1.stderr b/tests/ui/imports/issue-114682-1.stderr
index 85fb7f7919e4..fd2776f50ad7 100644
--- a/tests/ui/imports/issue-114682-1.stderr
+++ b/tests/ui/imports/issue-114682-1.stderr
@@ -4,7 +4,7 @@ error[E0659]: `A` is ambiguous
 LL |     A!();
    |     ^ ambiguous name
    |
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
 note: `A` could refer to the macro defined here
   --> $DIR/issue-114682-1.rs:7:9
    |
@@ -15,12 +15,13 @@ LL | |         }
 ...
 LL |   mac!();
    |   ------ in this macro invocation
+   = help: use `crate::A` to refer to this macro unambiguously
 note: `A` could also refer to the macro imported here
   --> $DIR/issue-114682-1.rs:19:9
    |
 LL | pub use m::*;
    |         ^^^^
-   = help: consider adding an explicit import of `A` to disambiguate
+   = help: use `crate::A` to refer to this macro unambiguously
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/imports/issue-55884-1.rs b/tests/ui/imports/issue-55884-1.rs
index 21744aa5d7bf..3c9c033c158e 100644
--- a/tests/ui/imports/issue-55884-1.rs
+++ b/tests/ui/imports/issue-55884-1.rs
@@ -17,5 +17,5 @@ mod m {
 
 fn main() {
     use m::S; //~ ERROR `S` is ambiguous
-    let s = S {};
+    let s = S {}; //~ ERROR `S` is ambiguous
 }
diff --git a/tests/ui/imports/issue-55884-1.stderr b/tests/ui/imports/issue-55884-1.stderr
index ae8edb049564..a0b63ddc9108 100644
--- a/tests/ui/imports/issue-55884-1.stderr
+++ b/tests/ui/imports/issue-55884-1.stderr
@@ -18,6 +18,26 @@ LL |     pub use self::m2::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `S` to disambiguate
 
-error: aborting due to 1 previous error
+error[E0659]: `S` is ambiguous
+  --> $DIR/issue-55884-1.rs:20:13
+   |
+LL |     let s = S {};
+   |             ^ ambiguous name
+   |
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `S` could refer to the struct imported here
+  --> $DIR/issue-55884-1.rs:14:13
+   |
+LL |     pub use self::m1::*;
+   |             ^^^^^^^^^^^
+   = help: consider adding an explicit import of `S` to disambiguate
+note: `S` could also refer to the struct imported here
+  --> $DIR/issue-55884-1.rs:15:13
+   |
+LL |     pub use self::m2::*;
+   |             ^^^^^^^^^^^
+   = help: consider adding an explicit import of `S` to disambiguate
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/local-modularized-tricky-fail-1.stderr b/tests/ui/imports/local-modularized-tricky-fail-1.stderr
index 52a01e8bcdfe..b5b3be5953f9 100644
--- a/tests/ui/imports/local-modularized-tricky-fail-1.stderr
+++ b/tests/ui/imports/local-modularized-tricky-fail-1.stderr
@@ -4,7 +4,7 @@ error[E0659]: `exported` is ambiguous
 LL | exported!();
    | ^^^^^^^^ ambiguous name
    |
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
 note: `exported` could refer to the macro defined here
   --> $DIR/local-modularized-tricky-fail-1.rs:6:5
    |
@@ -15,12 +15,13 @@ LL | |     }
 ...
 LL |       define_exported!();
    |       ------------------ in this macro invocation
+   = help: use `crate::exported` to refer to this macro unambiguously
 note: `exported` could also refer to the macro imported here
   --> $DIR/local-modularized-tricky-fail-1.rs:23:5
    |
 LL | use inner1::*;
    |     ^^^^^^^^^
-   = help: consider adding an explicit import of `exported` to disambiguate
+   = help: use `crate::exported` to refer to this macro unambiguously
    = note: this error originates in the macro `define_exported` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0659]: `panic` is ambiguous
diff --git a/tests/ui/imports/macro-paths.stderr b/tests/ui/imports/macro-paths.stderr
index 5f113ce2bee5..56a40e908258 100644
--- a/tests/ui/imports/macro-paths.stderr
+++ b/tests/ui/imports/macro-paths.stderr
@@ -4,7 +4,7 @@ error[E0659]: `bar` is ambiguous
 LL |     bar::m! {
    |     ^^^ ambiguous name
    |
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
 note: `bar` could refer to the module defined here
   --> $DIR/macro-paths.rs:14:9
    |
@@ -15,7 +15,6 @@ note: `bar` could also refer to the module imported here
    |
 LL |     use foo::*;
    |         ^^^^^^
-   = help: consider adding an explicit import of `bar` to disambiguate
 
 error[E0659]: `baz` is ambiguous
   --> $DIR/macro-paths.rs:23:5
diff --git a/tests/ui/imports/macros.rs b/tests/ui/imports/macros.rs
index cf67e08c87a3..121f1f7ae043 100644
--- a/tests/ui/imports/macros.rs
+++ b/tests/ui/imports/macros.rs
@@ -13,7 +13,7 @@ mod m1 {
 
 mod m2 {
     use two_macros::*;
-    m! { //~ ERROR ambiguous
+    m! { //~ ERROR `m` is ambiguous
         use crate::foo::m;
     }
 }
diff --git a/tests/ui/imports/macros.stderr b/tests/ui/imports/macros.stderr
index 25a678c6b375..9c081cc7af8b 100644
--- a/tests/ui/imports/macros.stderr
+++ b/tests/ui/imports/macros.stderr
@@ -4,18 +4,19 @@ error[E0659]: `m` is ambiguous
 LL |     m! {
    |     ^ ambiguous name
    |
-   = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
 note: `m` could refer to the macro imported here
   --> $DIR/macros.rs:17:13
    |
 LL |         use crate::foo::m;
    |             ^^^^^^^^^^^^^
+   = help: use `self::m` to refer to this macro unambiguously
 note: `m` could also refer to the macro imported here
   --> $DIR/macros.rs:15:9
    |
 LL |     use two_macros::*;
    |         ^^^^^^^^^^^^^
-   = help: consider adding an explicit import of `m` to disambiguate
+   = help: use `self::m` to refer to this macro unambiguously
 
 error[E0659]: `m` is ambiguous
   --> $DIR/macros.rs:29:9
diff --git a/tests/ui/imports/overwritten-glob-ambig.rs b/tests/ui/imports/overwritten-glob-ambig.rs
new file mode 100644
index 000000000000..a5918568c62a
--- /dev/null
+++ b/tests/ui/imports/overwritten-glob-ambig.rs
@@ -0,0 +1,26 @@
+// Test for a regression introduced by splitting module scope into two scopes
+// (similar to issue #145575).
+
+//@ check-pass
+//@ edition: 2018..
+
+#[macro_use]
+mod one {
+    // Macro that is in a different module, but still in scope due to `macro_use`
+    macro_rules! mac { () => {} }
+    pub(crate) use mac;
+}
+
+mod other {
+    macro_rules! mac { () => {} }
+    pub(crate) use mac;
+}
+
+// Single import of the same in the current module.
+use one::mac;
+// Glob import of a different macro in the current module (should be an ambiguity).
+use other::*;
+
+fn main() {
+    mac!(); // OK for now, the ambiguity is not reported
+}
diff --git a/tests/ui/inference/issue-71732.stderr b/tests/ui/inference/issue-71732.stderr
index af8b310fd1d9..e79131694856 100644
--- a/tests/ui/inference/issue-71732.stderr
+++ b/tests/ui/inference/issue-71732.stderr
@@ -10,7 +10,7 @@ LL |         .get(&"key".into())
            - impl Borrow<str> for String;
            - impl<T> Borrow<T> for T
              where T: ?Sized;
-note: required by a bound in `HashMap::<K, V, S>::get`
+note: required by a bound in `HashMap::<K, V, S, A>::get`
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 help: consider specifying the generic argument
    |
diff --git a/tests/ui/issues/issue-11384.rs b/tests/ui/issues/issue-11384.rs
deleted file mode 100644
index ad0affa4b0d2..000000000000
--- a/tests/ui/issues/issue-11384.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ check-pass
-
-trait Common { fn dummy(&self) { } }
-
-impl<'t, T> Common for (T, &'t T) {}
-
-impl<'t, T> Common for (&'t T, T) {}
-
-fn main() {}
diff --git a/tests/ui/issues/issue-19601.rs b/tests/ui/issues/issue-19601.rs
deleted file mode 100644
index e97819e4122d..000000000000
--- a/tests/ui/issues/issue-19601.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ check-pass
-
-trait A<T> {}
-struct B<T> where B<T>: A<B<T>> { t: T }
-
-fn main() {}
diff --git a/tests/ui/issues/issue-20676.rs b/tests/ui/issues/issue-20676.rs
deleted file mode 100644
index 2059365c7d62..000000000000
--- a/tests/ui/issues/issue-20676.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-// Regression test for #20676. Error was that we didn't support
-// UFCS-style calls to a method in `Trait` where `Self` was bound to a
-// trait object of type `Trait`. See also `ufcs-trait-object.rs`.
-
-
-use std::fmt;
-
-fn main() {
-    let a: &dyn fmt::Debug = &1;
-    let _ = format!("{:?}", a);
-}
diff --git a/tests/ui/issues/issue-22426.rs b/tests/ui/issues/issue-22426.rs
deleted file mode 100644
index 0857ac9dfb4d..000000000000
--- a/tests/ui/issues/issue-22426.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ run-pass
-
-fn main() {
-  match 42 {
-    x if x < 7 => (),
-    _ => ()
-  }
-}
diff --git a/tests/ui/issues/issue-2428.rs b/tests/ui/issues/issue-2428.rs
deleted file mode 100644
index 9cb02460f35b..000000000000
--- a/tests/ui/issues/issue-2428.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-#![allow(non_upper_case_globals)]
-
-
-pub fn main() {
-    let _foo = 100;
-    const quux: isize = 5;
-
-    enum Stuff {
-        Bar = quux
-    }
-
-    assert_eq!(Stuff::Bar as isize, quux);
-}
diff --git a/tests/ui/issues/issue-24389.rs b/tests/ui/issues/issue-24389.rs
deleted file mode 100644
index 95bb2af9b25c..000000000000
--- a/tests/ui/issues/issue-24389.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ check-pass
-#![allow(dead_code)]
-
-struct Foo;
-
-impl Foo {
-    fn new() -> Self { Foo }
-    fn bar() { Self::new(); }
-}
-
-fn main() {}
diff --git a/tests/ui/issues/issue-25180.rs b/tests/ui/issues/issue-25180.rs
deleted file mode 100644
index 339aca037546..000000000000
--- a/tests/ui/issues/issue-25180.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ check-pass
-#![allow(dead_code)]
-#![allow(non_upper_case_globals)]
-
-const x: &'static dyn Fn() = &|| println!("ICE here");
-
-fn main() {}
diff --git a/tests/ui/issues/issue-27639.rs b/tests/ui/issues/issue-27639.rs
deleted file mode 100644
index 95edcb8695e2..000000000000
--- a/tests/ui/issues/issue-27639.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_upper_case_globals)]
-
-fn main() {
-    const iter: i32 = 0;
-
-    for i in 1..10 {
-        println!("{}", i);
-    }
-}
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index 75ee936d9e8b..e7cb82687fa7 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:31:5
    |
 LL |     extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -15,7 +15,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:24:12
    |
 LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
-   |            ^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |            ^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -28,7 +28,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:45:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -41,7 +41,7 @@ error[E0059]: type parameter to bare `FnMut` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:39:12
    |
 LL | impl<A, B> FnMut<A> for CachedFun<A, B>
-   |            ^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |            ^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnMut`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -54,7 +54,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:31:5
    |
 LL |     extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 help: consider further restricting type parameter `A` with unstable trait `Tuple`
    |
@@ -65,7 +65,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:45:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 help: consider further restricting type parameter `A` with unstable trait `Tuple`
    |
@@ -76,7 +76,7 @@ error[E0277]: `A` is not a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:34:19
    |
 LL |     self.call_mut(a)
-   |          -------- ^ the trait `Tuple` is not implemented for `A`
+   |          -------- ^ the trait `std::marker::Tuple` is not implemented for `A`
    |          |
    |          required by a bound introduced by this call
    |
@@ -91,7 +91,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:59:26
    |
 LL |     cachedcoso.call_once(1);
-   |                --------- ^ the trait `Tuple` is not implemented for `i32`
+   |                --------- ^ the trait `std::marker::Tuple` is not implemented for `i32`
    |                |
    |                required by a bound introduced by this call
    |
diff --git a/tests/ui/lint/dead-code/allow-trait-or-impl.rs b/tests/ui/lint/dead-code/allow-trait-or-impl.rs
new file mode 100644
index 000000000000..92817549a91e
--- /dev/null
+++ b/tests/ui/lint/dead-code/allow-trait-or-impl.rs
@@ -0,0 +1,38 @@
+#![deny(dead_code)]
+
+pub mod a {
+    pub trait Foo { }
+    impl Foo for u32 { }
+
+    struct PrivateType; //~ ERROR struct `PrivateType` is never constructed
+    impl Foo for PrivateType { } // <-- warns as dead, even though Foo is public
+
+    struct AnotherPrivateType; //~ ERROR struct `AnotherPrivateType` is never constructed
+    impl Foo for AnotherPrivateType { } // <-- warns as dead, even though Foo is public
+}
+
+pub mod b {
+    #[allow(dead_code)]
+    pub trait Foo { }
+    impl Foo for u32 { }
+
+    struct PrivateType;
+    impl Foo for PrivateType { } // <-- no warning, trait is "allowed"
+
+    struct AnotherPrivateType;
+    impl Foo for AnotherPrivateType { } // <-- no warning, trait is "allowed"
+}
+
+pub mod c {
+    pub trait Foo { }
+    impl Foo for u32 { }
+
+    struct PrivateType;
+    #[allow(dead_code)]
+    impl Foo for PrivateType { } // <-- no warning, impl is allowed
+
+    struct AnotherPrivateType; //~ ERROR struct `AnotherPrivateType` is never constructed
+    impl Foo for AnotherPrivateType { } // <-- warns as dead, even though Foo is public
+}
+
+fn main() {}
diff --git a/tests/ui/lint/dead-code/allow-trait-or-impl.stderr b/tests/ui/lint/dead-code/allow-trait-or-impl.stderr
new file mode 100644
index 000000000000..130116b6c91d
--- /dev/null
+++ b/tests/ui/lint/dead-code/allow-trait-or-impl.stderr
@@ -0,0 +1,26 @@
+error: struct `PrivateType` is never constructed
+  --> $DIR/allow-trait-or-impl.rs:7:12
+   |
+LL |     struct PrivateType;
+   |            ^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/allow-trait-or-impl.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: struct `AnotherPrivateType` is never constructed
+  --> $DIR/allow-trait-or-impl.rs:10:12
+   |
+LL |     struct AnotherPrivateType;
+   |            ^^^^^^^^^^^^^^^^^^
+
+error: struct `AnotherPrivateType` is never constructed
+  --> $DIR/allow-trait-or-impl.rs:34:12
+   |
+LL |     struct AnotherPrivateType;
+   |            ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/lint/dead-code/allow-unused-trait.rs b/tests/ui/lint/dead-code/allow-unused-trait.rs
new file mode 100644
index 000000000000..4eb63bd4d27a
--- /dev/null
+++ b/tests/ui/lint/dead-code/allow-unused-trait.rs
@@ -0,0 +1,29 @@
+//@ check-pass
+
+#![deny(dead_code)]
+
+#[allow(dead_code)]
+trait Foo {
+    const FOO: u32;
+    type Baz;
+    fn foobar();
+}
+
+const fn bar(x: u32) -> u32 {
+    x
+}
+
+struct Qux;
+
+struct FooBar;
+
+impl Foo for u32 {
+    const FOO: u32 = bar(0);
+    type Baz = Qux;
+
+    fn foobar() {
+        let _ = FooBar;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/lint/lint-gpu-kernel.amdgpu.stderr b/tests/ui/lint/lint-gpu-kernel.amdgpu.stderr
new file mode 100644
index 000000000000..21eebe42f8b1
--- /dev/null
+++ b/tests/ui/lint/lint-gpu-kernel.amdgpu.stderr
@@ -0,0 +1,86 @@
+warning: `extern` fn uses type `()`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:36:35
+   |
+LL | extern "gpu-kernel" fn arg_zst(_: ()) { }
+   |                                   ^^ not FFI-safe
+   |
+   = help: consider using a struct instead
+   = note: tuples have unspecified layout
+   = note: `#[warn(improper_ctypes_definitions)]` on by default
+
+warning: passing type `()` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:36:35
+   |
+LL | extern "gpu-kernel" fn arg_zst(_: ()) { }
+   |                                   ^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+   = note: `#[warn(improper_gpu_kernel_arg)]` on by default
+
+warning: passing type `&i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:41:35
+   |
+LL | extern "gpu-kernel" fn arg_ref(_: &i32) { }
+   |                                   ^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: passing type `&mut i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:44:39
+   |
+LL | extern "gpu-kernel" fn arg_ref_mut(_: &mut i32) { }
+   |                                       ^^^^^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: `extern` fn uses type `S`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:49:38
+   |
+LL | extern "gpu-kernel" fn arg_struct(_: S) { }
+   |                                      ^ not FFI-safe
+   |
+   = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+   = note: this struct has unspecified layout
+note: the type is defined here
+  --> $DIR/lint-gpu-kernel.rs:47:1
+   |
+LL | struct S { a: i32, b: i32 }
+   | ^^^^^^^^
+
+warning: passing type `S` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:49:38
+   |
+LL | extern "gpu-kernel" fn arg_struct(_: S) { }
+   |                                      ^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:54:35
+   |
+LL | extern "gpu-kernel" fn arg_tup(_: (i32, i32)) { }
+   |                                   ^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using a struct instead
+   = note: tuples have unspecified layout
+
+warning: passing type `(i32, i32)` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:54:35
+   |
+LL | extern "gpu-kernel" fn arg_tup(_: (i32, i32)) { }
+   |                                   ^^^^^^^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: function with the "gpu-kernel" ABI has a mangled name
+  --> $DIR/lint-gpu-kernel.rs:61:1
+   |
+LL | pub extern "gpu-kernel" fn mangled_kernel() { }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `unsafe(no_mangle)` or `unsafe(export_name = "<name>")`
+   = note: mangled names make it hard to find the kernel, this is usually not intended
+   = note: `#[warn(missing_gpu_kernel_export_name)]` on by default
+
+warning: 9 warnings emitted
+
diff --git a/tests/ui/lint/lint-gpu-kernel.nvptx.stderr b/tests/ui/lint/lint-gpu-kernel.nvptx.stderr
new file mode 100644
index 000000000000..21eebe42f8b1
--- /dev/null
+++ b/tests/ui/lint/lint-gpu-kernel.nvptx.stderr
@@ -0,0 +1,86 @@
+warning: `extern` fn uses type `()`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:36:35
+   |
+LL | extern "gpu-kernel" fn arg_zst(_: ()) { }
+   |                                   ^^ not FFI-safe
+   |
+   = help: consider using a struct instead
+   = note: tuples have unspecified layout
+   = note: `#[warn(improper_ctypes_definitions)]` on by default
+
+warning: passing type `()` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:36:35
+   |
+LL | extern "gpu-kernel" fn arg_zst(_: ()) { }
+   |                                   ^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+   = note: `#[warn(improper_gpu_kernel_arg)]` on by default
+
+warning: passing type `&i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:41:35
+   |
+LL | extern "gpu-kernel" fn arg_ref(_: &i32) { }
+   |                                   ^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: passing type `&mut i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:44:39
+   |
+LL | extern "gpu-kernel" fn arg_ref_mut(_: &mut i32) { }
+   |                                       ^^^^^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: `extern` fn uses type `S`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:49:38
+   |
+LL | extern "gpu-kernel" fn arg_struct(_: S) { }
+   |                                      ^ not FFI-safe
+   |
+   = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+   = note: this struct has unspecified layout
+note: the type is defined here
+  --> $DIR/lint-gpu-kernel.rs:47:1
+   |
+LL | struct S { a: i32, b: i32 }
+   | ^^^^^^^^
+
+warning: passing type `S` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:49:38
+   |
+LL | extern "gpu-kernel" fn arg_struct(_: S) { }
+   |                                      ^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
+  --> $DIR/lint-gpu-kernel.rs:54:35
+   |
+LL | extern "gpu-kernel" fn arg_tup(_: (i32, i32)) { }
+   |                                   ^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using a struct instead
+   = note: tuples have unspecified layout
+
+warning: passing type `(i32, i32)` to a function with "gpu-kernel" ABI may have unexpected behavior
+  --> $DIR/lint-gpu-kernel.rs:54:35
+   |
+LL | extern "gpu-kernel" fn arg_tup(_: (i32, i32)) { }
+   |                                   ^^^^^^^^^^
+   |
+   = help: use primitive types and raw pointers to get reliable behavior
+
+warning: function with the "gpu-kernel" ABI has a mangled name
+  --> $DIR/lint-gpu-kernel.rs:61:1
+   |
+LL | pub extern "gpu-kernel" fn mangled_kernel() { }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `unsafe(no_mangle)` or `unsafe(export_name = "<name>")`
+   = note: mangled names make it hard to find the kernel, this is usually not intended
+   = note: `#[warn(missing_gpu_kernel_export_name)]` on by default
+
+warning: 9 warnings emitted
+
diff --git a/tests/ui/lint/lint-gpu-kernel.rs b/tests/ui/lint/lint-gpu-kernel.rs
new file mode 100644
index 000000000000..9b3ed0d14d8a
--- /dev/null
+++ b/tests/ui/lint/lint-gpu-kernel.rs
@@ -0,0 +1,62 @@
+// Test argument and return type restrictions of the gpu-kernel ABI and
+// check for warnings on mangled gpu-kernels.
+
+//@ check-pass
+//@ ignore-backends: gcc
+//@ revisions: amdgpu nvptx
+//@ add-minicore
+//@ edition: 2024
+//@[amdgpu] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
+//@[amdgpu] needs-llvm-components: amdgpu
+//@[nvptx]  compile-flags: --target nvptx64-nvidia-cuda
+//@[nvptx] needs-llvm-components: nvptx
+
+#![feature(no_core, abi_gpu_kernel)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// Return types can be () or !
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn ret_empty() {}
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn ret_never() -> ! { loop {} }
+
+// Arguments can be scalars or pointers
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_i32(_: i32) { }
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_ptr(_: *const i32) { }
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_ptr_mut(_: *mut i32) { }
+
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_zst(_: ()) { }
+//~^ WARN passing type `()` to a function with "gpu-kernel" ABI may have unexpected behavior
+//~^^ WARN `extern` fn uses type `()`, which is not FFI-safe
+
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_ref(_: &i32) { }
+//~^ WARN passing type `&i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_ref_mut(_: &mut i32) { }
+//~^ WARN passing type `&mut i32` to a function with "gpu-kernel" ABI may have unexpected behavior
+
+struct S { a: i32, b: i32 }
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_struct(_: S) { }
+//~^ WARN passing type `S` to a function with "gpu-kernel" ABI may have unexpected behavior
+//~^^ WARN `extern` fn uses type `S`, which is not FFI-safe
+
+#[unsafe(no_mangle)]
+extern "gpu-kernel" fn arg_tup(_: (i32, i32)) { }
+//~^ WARN passing type `(i32, i32)` to a function with "gpu-kernel" ABI may have unexpected behavior
+//~^^ WARN `extern` fn uses type `(i32, i32)`, which is not FFI-safe
+
+#[unsafe(export_name = "kernel")]
+pub extern "gpu-kernel" fn allowed_kernel_name() {}
+
+pub extern "gpu-kernel" fn mangled_kernel() { }
+//~^ WARN function with the "gpu-kernel" ABI has a mangled name
diff --git a/tests/ui/lint/unused/unused_attributes-must_use.stderr b/tests/ui/lint/unused/unused_attributes-must_use.stderr
index 9b9a6a9c9f3d..3192c0994548 100644
--- a/tests/ui/lint/unused/unused_attributes-must_use.stderr
+++ b/tests/ui/lint/unused/unused_attributes-must_use.stderr
@@ -93,7 +93,7 @@ LL | #[must_use]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
-error: `#[must_use]` attribute cannot be used on function params
+error: `#[must_use]` attribute cannot be used on type parameters
   --> $DIR/unused_attributes-must_use.rs:77:8
    |
 LL | fn qux<#[must_use] T>(_: T) {}
diff --git a/tests/ui/lint/unused/unused_parens/parens-around-guard-patterns-not-unused.rs b/tests/ui/lint/unused/unused_parens/parens-around-guard-patterns-not-unused.rs
new file mode 100644
index 000000000000..d5b8365ee612
--- /dev/null
+++ b/tests/ui/lint/unused/unused_parens/parens-around-guard-patterns-not-unused.rs
@@ -0,0 +1,13 @@
+//! Guard patterns require parentheses to disambiguate precedence
+//!
+//! Regression test for https://github.com/rust-lang/rust/issues/149594
+
+//@ check-pass
+
+#![feature(guard_patterns)]
+#![expect(incomplete_features)]
+#![warn(unused_parens)]
+
+fn main() {
+    let (_ if false) = ();
+}
diff --git a/tests/ui/lowering/no-name-for-DefPath-issue-133426.stderr b/tests/ui/lowering/no-name-for-DefPath-issue-133426.stderr
index 555d8eec6bab..3d1233cdd019 100644
--- a/tests/ui/lowering/no-name-for-DefPath-issue-133426.stderr
+++ b/tests/ui/lowering/no-name-for-DefPath-issue-133426.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | fn b(_: impl Iterator<Item = { match 0 { ! } }>) {}
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0614]: type `!` cannot be dereferenced
diff --git a/tests/ui/macros/concat-nested-repetition.rs b/tests/ui/macros/concat-nested-repetition.rs
new file mode 100644
index 000000000000..ac5394ef8dcc
--- /dev/null
+++ b/tests/ui/macros/concat-nested-repetition.rs
@@ -0,0 +1,35 @@
+//@ check-pass
+#![feature(macro_metavar_expr_concat)]
+
+struct A;
+struct B;
+const AA: A = A;
+const BB: B = B;
+
+macro_rules! define_ioctl_data {
+    (struct $s:ident {
+        $($field:ident: $ty:ident $([$opt:ident])?,)*
+    }) => {
+        pub struct $s {
+            $($field: $ty,)*
+        }
+
+        impl $s {
+            $($(
+                fn ${concat(get_, $field)}(&self) -> $ty {
+                    let _ = $opt;
+                    todo!()
+                }
+            )?)*
+        }
+    };
+}
+
+define_ioctl_data! {
+    struct Foo {
+        a: A [AA],
+        b: B [BB],
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
index d2bd31b06d60..3ee11d373e05 100644
--- a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
+++ b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
@@ -11,7 +11,7 @@ macro_rules! InRepetition {
      ) => {
         $(
             $(
-                ${concat(_, $arg)} //~ ERROR nested repetitions with `${concat(...)}` metavariable expressions are not yet supported
+                ${concat(_, $arg)} //~ ERROR macro expansion ends with an incomplete expression: expected one of `!` or `::`
             )*
         )*
     };
diff --git a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr
index ec39ca799e19..b84d98874931 100644
--- a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr
+++ b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr
@@ -1,8 +1,8 @@
-error: nested repetitions with `${concat(...)}` metavariable expressions are not yet supported
-  --> $DIR/in-repetition.rs:14:30
+error: macro expansion ends with an incomplete expression: expected one of `!` or `::`
+  --> $DIR/in-repetition.rs:14:35
    |
 LL |                 ${concat(_, $arg)}
-   |                              ^^^
+   |                                   ^ expected one of `!` or `::`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/metavar-expressions/concat-repetitions.rs b/tests/ui/macros/metavar-expressions/concat-repetitions.rs
index 52a7d5cd8a7e..133a969b1248 100644
--- a/tests/ui/macros/metavar-expressions/concat-repetitions.rs
+++ b/tests/ui/macros/metavar-expressions/concat-repetitions.rs
@@ -11,8 +11,7 @@ macro_rules! one_rep {
 macro_rules! issue_128346 {
     ( $($a:ident)* ) => {
         A(
-            const ${concat($a, Z)}: i32 = 3;
-            //~^ ERROR invalid syntax
+            const ${concat($a, Z)}: i32 = 3; //~ ERROR `${concat(...)}` variable is still repeating at this depth
         )*
     };
 }
@@ -20,8 +19,8 @@ macro_rules! issue_128346 {
 macro_rules! issue_131393 {
     ($t:ident $($en:ident)?) => {
         read::<${concat($t, $en)}>()
-        //~^ ERROR invalid syntax
-        //~| ERROR invalid syntax
+        //~^ ERROR `${concat(...)}` variable is still repeating at this depth
+        //~| ERROR `${concat(...)}` variable is still repeating at this depth
     }
 }
 
diff --git a/tests/ui/macros/metavar-expressions/concat-repetitions.stderr b/tests/ui/macros/metavar-expressions/concat-repetitions.stderr
index 18b0a90c1c8a..0ef20c65a284 100644
--- a/tests/ui/macros/metavar-expressions/concat-repetitions.stderr
+++ b/tests/ui/macros/metavar-expressions/concat-repetitions.stderr
@@ -1,20 +1,20 @@
-error: invalid syntax
-  --> $DIR/concat-repetitions.rs:14:20
+error: `${concat(...)}` variable is still repeating at this depth
+  --> $DIR/concat-repetitions.rs:14:29
    |
 LL |             const ${concat($a, Z)}: i32 = 3;
-   |                    ^^^^^^^^^^^^^^^
+   |                             ^
 
-error: invalid syntax
-  --> $DIR/concat-repetitions.rs:22:17
+error: `${concat(...)}` variable is still repeating at this depth
+  --> $DIR/concat-repetitions.rs:21:30
    |
 LL |         read::<${concat($t, $en)}>()
-   |                 ^^^^^^^^^^^^^^^^^
+   |                              ^^
 
-error: invalid syntax
-  --> $DIR/concat-repetitions.rs:22:17
+error: `${concat(...)}` variable is still repeating at this depth
+  --> $DIR/concat-repetitions.rs:21:30
    |
 LL |         read::<${concat($t, $en)}>()
-   |                 ^^^^^^^^^^^^^^^^^
+   |                              ^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
diff --git a/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr b/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
index 6272455cc57e..af0f67b7c1c0 100644
--- a/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
+++ b/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
@@ -6,7 +6,7 @@ LL |     let mut copy: Vec<U> = map.clone().into_values().collect();
    |                            |
    |                            move occurs because value has type `HashMap<T, U, Hash128_1>`, which does not implement the `Copy` trait
    |
-note: `HashMap::<K, V, S>::into_values` takes ownership of the receiver `self`, which moves value
+note: `HashMap::<K, V, S, A>::into_values` takes ownership of the receiver `self`, which moves value
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 note: if `Hash128_1` implemented `Clone`, you could clone the value
   --> $DIR/suggest-clone-when-some-obligation-is-unmet.rs:8:1
diff --git a/tests/ui/overloaded/overloaded-calls-nontuple.stderr b/tests/ui/overloaded/overloaded-calls-nontuple.stderr
index 22598f3a3901..54a9d1f09b52 100644
--- a/tests/ui/overloaded/overloaded-calls-nontuple.stderr
+++ b/tests/ui/overloaded/overloaded-calls-nontuple.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `FnMut` trait must be a tuple
   --> $DIR/overloaded-calls-nontuple.rs:10:6
    |
 LL | impl FnMut<isize> for S {
-   |      ^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |      ^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
    |
 note: required by a bound in `FnMut`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -11,7 +11,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/overloaded-calls-nontuple.rs:18:6
    |
 LL | impl FnOnce<isize> for S {
-   |      ^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |      ^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -20,19 +20,19 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/overloaded-calls-nontuple.rs:12:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, z: isize) -> isize {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error[E0277]: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/overloaded-calls-nontuple.rs:21:5
    |
 LL |     extern "rust-call" fn call_once(mut self, z: isize) -> isize {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error[E0277]: `isize` is not a tuple
   --> $DIR/overloaded-calls-nontuple.rs:23:23
    |
 LL |         self.call_mut(z)
-   |              -------- ^ the trait `Tuple` is not implemented for `isize`
+   |              -------- ^ the trait `std::marker::Tuple` is not implemented for `isize`
    |              |
    |              required by a bound introduced by this call
    |
@@ -53,7 +53,7 @@ error[E0277]: `isize` is not a tuple
   --> $DIR/overloaded-calls-nontuple.rs:29:10
    |
 LL |     drop(s(3))
-   |          ^^^^ the trait `Tuple` is not implemented for `isize`
+   |          ^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/parser/recover/recover-assoc-const-constraint.stderr b/tests/ui/parser/recover/recover-assoc-const-constraint.stderr
index 02b1c3fe68a9..766acd0398d2 100644
--- a/tests/ui/parser/recover/recover-assoc-const-constraint.stderr
+++ b/tests/ui/parser/recover/recover-assoc-const-constraint.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL |     bar::<Item = 42>();
    |           ^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated const equality is incomplete
@@ -14,8 +14,8 @@ error[E0658]: associated const equality is incomplete
 LL |     bar::<Item = { 42 }>();
    |           ^^^^^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/pin-ergonomics/pin_v2-attr.rs b/tests/ui/pin-ergonomics/pin_v2-attr.rs
index cfafe4b0b899..ba25d3587edd 100644
--- a/tests/ui/pin-ergonomics/pin_v2-attr.rs
+++ b/tests/ui/pin-ergonomics/pin_v2-attr.rs
@@ -25,8 +25,8 @@ union Union {
 // disallowed
 
 enum Foo<#[pin_v2] T, #[pin_v2] U = ()> {
-    //~^ ERROR `#[pin_v2]` attribute cannot be used on function params
-    //~| ERROR `#[pin_v2]` attribute cannot be used on function params
+    //~^ ERROR `#[pin_v2]` attribute cannot be used on type parameters
+    //~| ERROR `#[pin_v2]` attribute cannot be used on type parameters
     #[pin_v2] //~ ERROR `#[pin_v2]` attribute cannot be used on enum variants
     UnitVariant,
     TupleVariant(#[pin_v2] T), //~ ERROR `#[pin_v2]` attribute cannot be used on struct fields
diff --git a/tests/ui/pin-ergonomics/pin_v2-attr.stderr b/tests/ui/pin-ergonomics/pin_v2-attr.stderr
index 81e086f5a7ef..c297afa87a73 100644
--- a/tests/ui/pin-ergonomics/pin_v2-attr.stderr
+++ b/tests/ui/pin-ergonomics/pin_v2-attr.stderr
@@ -20,7 +20,7 @@ LL | #![pin_v2]
    |
    = help: `#[pin_v2]` can be applied to data types and unions
 
-error: `#[pin_v2]` attribute cannot be used on function params
+error: `#[pin_v2]` attribute cannot be used on type parameters
   --> $DIR/pin_v2-attr.rs:27:10
    |
 LL | enum Foo<#[pin_v2] T, #[pin_v2] U = ()> {
@@ -28,7 +28,7 @@ LL | enum Foo<#[pin_v2] T, #[pin_v2] U = ()> {
    |
    = help: `#[pin_v2]` can be applied to data types and unions
 
-error: `#[pin_v2]` attribute cannot be used on function params
+error: `#[pin_v2]` attribute cannot be used on type parameters
   --> $DIR/pin_v2-attr.rs:27:23
    |
 LL | enum Foo<#[pin_v2] T, #[pin_v2] U = ()> {
diff --git a/tests/ui/privacy/suggest-box-new.rs b/tests/ui/privacy/suggest-box-new.rs
index ff585387020e..87ee13d15edb 100644
--- a/tests/ui/privacy/suggest-box-new.rs
+++ b/tests/ui/privacy/suggest-box-new.rs
@@ -14,7 +14,7 @@ fn main() {
     let _ = std::collections::HashMap();
     //~^ ERROR expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
     let _ = std::collections::HashMap {};
-    //~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+    //~^ ERROR cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
     let _ = Box {}; //~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
 
     // test that we properly instantiate the parameter of `Box::<T>::new` with an inference variable
diff --git a/tests/ui/privacy/suggest-box-new.stderr b/tests/ui/privacy/suggest-box-new.stderr
index e3a7e5f62017..7367672351d6 100644
--- a/tests/ui/privacy/suggest-box-new.stderr
+++ b/tests/ui/privacy/suggest-box-new.stderr
@@ -5,6 +5,7 @@ LL |     let _ = std::collections::HashMap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+  ::: $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    |
    = note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL |     let _ = std::collections::HashMap::new();
    |                                      +++++
 LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::new_in(_);
+   |
+LL -     let _ = std::collections::HashMap();
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   |
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    |
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
   --> $DIR/suggest-box-new.rs:16:13
    |
 LL |     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    |
 LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::new_in(_);
+   |
+LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   |
-LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/proc-macro/generate-mod.stderr b/tests/ui/proc-macro/generate-mod.stderr
index af90df2c3dc3..371fd73e507b 100644
--- a/tests/ui/proc-macro/generate-mod.stderr
+++ b/tests/ui/proc-macro/generate-mod.stderr
@@ -47,7 +47,6 @@ LL | #[derive(generate_mod::CheckDerive)]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
    = note: `#[deny(proc_macro_derive_resolution_fallback)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `OuterDerive` in this scope
   --> $DIR/generate-mod.rs:18:10
@@ -57,7 +56,6 @@ LL | #[derive(generate_mod::CheckDerive)]
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `FromOutside` in this scope
   --> $DIR/generate-mod.rs:25:14
@@ -67,7 +65,6 @@ LL |     #[derive(generate_mod::CheckDerive)]
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `OuterDerive` in this scope
   --> $DIR/generate-mod.rs:25:14
@@ -77,7 +74,6 @@ LL |     #[derive(generate_mod::CheckDerive)]
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 8 previous errors
 
@@ -92,7 +88,6 @@ LL | #[derive(generate_mod::CheckDerive)]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
    = note: `#[deny(proc_macro_derive_resolution_fallback)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 Future breakage diagnostic:
 error: cannot find type `OuterDerive` in this scope
@@ -104,7 +99,6 @@ LL | #[derive(generate_mod::CheckDerive)]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
    = note: `#[deny(proc_macro_derive_resolution_fallback)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 Future breakage diagnostic:
 error: cannot find type `FromOutside` in this scope
@@ -116,7 +110,6 @@ LL |     #[derive(generate_mod::CheckDerive)]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
    = note: `#[deny(proc_macro_derive_resolution_fallback)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 Future breakage diagnostic:
 error: cannot find type `OuterDerive` in this scope
@@ -128,7 +121,6 @@ LL |     #[derive(generate_mod::CheckDerive)]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
    = note: `#[deny(proc_macro_derive_resolution_fallback)]` (part of `#[deny(future_incompatible)]`) on by default
-   = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 Future breakage diagnostic:
 warning: cannot find type `FromOutside` in this scope
@@ -139,7 +131,6 @@ LL | #[derive(generate_mod::CheckDeriveLint)] // OK, lint is suppressed
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
-   = note: this warning originates in the derive macro `generate_mod::CheckDeriveLint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 Future breakage diagnostic:
 warning: cannot find type `OuterDeriveLint` in this scope
@@ -150,5 +141,4 @@ LL | #[derive(generate_mod::CheckDeriveLint)] // OK, lint is suppressed
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #83583 <https://github.com/rust-lang/rust/issues/83583>
-   = note: this warning originates in the derive macro `generate_mod::CheckDeriveLint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/reachable/guard_read_for_never.rs b/tests/ui/reachable/guard_read_for_never.rs
index 7061da635301..763dfd354b58 100644
--- a/tests/ui/reachable/guard_read_for_never.rs
+++ b/tests/ui/reachable/guard_read_for_never.rs
@@ -2,7 +2,7 @@
 //
 //@ check-pass
 #![feature(guard_patterns, never_type)]
-#![expect(incomplete_features, unused_parens)]
+#![expect(incomplete_features)]
 #![deny(unreachable_code)]
 
 fn main() {
diff --git a/tests/ui/reflection/dump.rs b/tests/ui/reflection/dump.rs
new file mode 100644
index 000000000000..3bf4f32b6641
--- /dev/null
+++ b/tests/ui/reflection/dump.rs
@@ -0,0 +1,30 @@
+#![feature(type_info)]
+//@ run-pass
+//@ check-run-results
+#![allow(dead_code)]
+
+use std::mem::type_info::Type;
+
+struct Foo {
+    a: u32,
+}
+
+enum Bar {
+    Some(u32),
+    None,
+    Foomp { a: (), b: &'static str },
+}
+
+struct Unsized {
+    x: u16,
+    s: str,
+}
+
+fn main() {
+    println!("{:#?}", const { Type::of::<(u8, u8, ())>() }.kind);
+    println!("{:#?}", const { Type::of::<Foo>() }.kind);
+    println!("{:#?}", const { Type::of::<Bar>() }.kind);
+    println!("{:#?}", const { Type::of::<&Unsized>() }.kind);
+    println!("{:#?}", const { Type::of::<&str>() }.kind);
+    println!("{:#?}", const { Type::of::<&[u8]>() }.kind);
+}
diff --git a/tests/ui/reflection/dump.run.stdout b/tests/ui/reflection/dump.run.stdout
new file mode 100644
index 000000000000..71fd80b46658
--- /dev/null
+++ b/tests/ui/reflection/dump.run.stdout
@@ -0,0 +1,23 @@
+Tuple(
+    Tuple {
+        fields: [
+            Field {
+                ty: TypeId(0x0596b48cc04376e64d5c788c2aa46bdb),
+                offset: 0,
+            },
+            Field {
+                ty: TypeId(0x0596b48cc04376e64d5c788c2aa46bdb),
+                offset: 1,
+            },
+            Field {
+                ty: TypeId(0x41223169ff28813ba79b7268a2a968d9),
+                offset: 2,
+            },
+        ],
+    },
+)
+Other
+Other
+Other
+Other
+Other
diff --git a/tests/ui/reflection/feature_gate.rs b/tests/ui/reflection/feature_gate.rs
new file mode 100644
index 000000000000..2dde26809793
--- /dev/null
+++ b/tests/ui/reflection/feature_gate.rs
@@ -0,0 +1,8 @@
+use std::mem::type_info::Type;
+//~^ ERROR: use of unstable library feature `type_info`
+
+fn main() {
+    let ty = std::mem::type_info::Type::of::<()>();
+    //~^ ERROR: use of unstable library feature `type_info`
+    //~| ERROR: use of unstable library feature `type_info`
+}
diff --git a/tests/ui/reflection/feature_gate.stderr b/tests/ui/reflection/feature_gate.stderr
new file mode 100644
index 000000000000..76ad18ffb0ba
--- /dev/null
+++ b/tests/ui/reflection/feature_gate.stderr
@@ -0,0 +1,33 @@
+error[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:1:5
+   |
+LL | use std::mem::type_info::Type;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:5:14
+   |
+LL |     let ty = std::mem::type_info::Type::of::<()>();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:5:14
+   |
+LL |     let ty = std::mem::type_info::Type::of::<()>();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/reflection/tuples.rs b/tests/ui/reflection/tuples.rs
new file mode 100644
index 000000000000..eab25a691efe
--- /dev/null
+++ b/tests/ui/reflection/tuples.rs
@@ -0,0 +1,36 @@
+#![feature(type_info)]
+
+//@ run-pass
+
+use std::mem::type_info::{Type, TypeKind};
+
+fn assert_tuple_arity<T: 'static, const N: usize>() {
+    const {
+        match &Type::of::<T>().kind {
+            TypeKind::Tuple(tup) => {
+                assert!(tup.fields.len() == N);
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn main() {
+    assert_tuple_arity::<(), 0>();
+    assert_tuple_arity::<(u8,), 1>();
+    assert_tuple_arity::<(u8, u8), 2>();
+    const {
+        match &Type::of::<(u8, u8)>().kind {
+            TypeKind::Tuple(tup) => {
+                let [a, b] = tup.fields else { unreachable!() };
+                assert!(a.offset == 0);
+                assert!(b.offset == 1);
+                match (&a.ty.info().kind, &b.ty.info().kind) {
+                    (TypeKind::Leaf, TypeKind::Leaf) => {}
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/tests/ui/repeat-expr/can-have-side-effects-consider-element.rs b/tests/ui/repeat-expr/can-have-side-effects-consider-element.rs
new file mode 100644
index 000000000000..274942f9379f
--- /dev/null
+++ b/tests/ui/repeat-expr/can-have-side-effects-consider-element.rs
@@ -0,0 +1,20 @@
+//@ check-pass
+
+#![allow(unused)]
+
+// Test if `Expr::can_have_side_effects` considers element of repeat expressions.
+
+fn drop_repeat_in_arm_body() {
+    // Built-in lint `dropping_copy_types` relies on `Expr::can_have_side_effects`
+    // (See rust-clippy#9482 and rust#113231)
+
+    match () {
+        () => drop([0; 1]), // No side effects
+        //~^ WARNING calls to `std::mem::drop` with a value that implements `Copy` does nothing
+    }
+    match () {
+        () => drop([return; 1]), // Definitely has side effects
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/repeat-expr/can-have-side-effects-consider-element.stderr b/tests/ui/repeat-expr/can-have-side-effects-consider-element.stderr
new file mode 100644
index 000000000000..70c7e8b404e0
--- /dev/null
+++ b/tests/ui/repeat-expr/can-have-side-effects-consider-element.stderr
@@ -0,0 +1,13 @@
+warning: calls to `std::mem::drop` with a value that implements `Copy` does nothing
+  --> $DIR/can-have-side-effects-consider-element.rs:12:15
+   |
+LL |         () => drop([0; 1]), // No side effects
+   |               ^^^^^------^
+   |                    |
+   |                    argument has type `[i32; 1]`
+   |
+   = note: use `let _ = ...` to ignore the expression or result
+   = note: `#[warn(dropping_copy_types)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/issues/auxiliary/i8.rs b/tests/ui/resolve/auxiliary/i8.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/i8.rs
rename to tests/ui/resolve/auxiliary/i8.rs
diff --git a/tests/ui/resolve/const-iter-no-conflict-for-loop.rs b/tests/ui/resolve/const-iter-no-conflict-for-loop.rs
new file mode 100644
index 000000000000..ddbba64e5a31
--- /dev/null
+++ b/tests/ui/resolve/const-iter-no-conflict-for-loop.rs
@@ -0,0 +1,15 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/27639>
+//! Ensure that a constant named `iter` does not
+//! interfere with the name resolution of the `iter` methods used internally
+//! by `for` loops
+//@ run-pass
+#![allow(dead_code)]
+#![allow(non_upper_case_globals)]
+
+fn main() {
+    const iter: i32 = 0;
+
+    for i in 1..10 {
+        println!("{}", i);
+    }
+}
diff --git a/tests/ui/resolve/resolve-assoc-suggestions.stderr b/tests/ui/resolve/resolve-assoc-suggestions.stderr
index ef519ac0d921..7d94fb5ca35f 100644
--- a/tests/ui/resolve/resolve-assoc-suggestions.stderr
+++ b/tests/ui/resolve/resolve-assoc-suggestions.stderr
@@ -31,6 +31,10 @@ help: you might have meant to use the associated type
    |
 LL |         let _: Self::Type;
    |                ++++++
+help: consider importing this struct
+   |
+LL + use std::mem::type_info::Type;
+   |
 
 error[E0531]: cannot find tuple struct or tuple variant `Type` in this scope
   --> $DIR/resolve-assoc-suggestions.rs:25:13
diff --git a/tests/ui/issues/issue-20427.rs b/tests/ui/resolve/shadow-primitives.rs
similarity index 69%
rename from tests/ui/issues/issue-20427.rs
rename to tests/ui/resolve/shadow-primitives.rs
index 4018043c371e..17da0cd0530c 100644
--- a/tests/ui/issues/issue-20427.rs
+++ b/tests/ui/resolve/shadow-primitives.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/20427>
 //@ run-pass
 #![allow(dead_code)]
 #![allow(unused_variables)]
@@ -31,17 +32,10 @@ mod char {
     mod char_ {}
 
     mod str {
-        use super::i8 as i8;
-        use super::i32_ as i32;
-        use super::i64_ as i64;
-        use super::u8_ as u8;
-        use super::f_ as f64;
-        use super::u16_ as u16;
-        use super::u32_ as u32;
-        use super::u64_ as u64;
-        use super::bool_ as bool;
-        use super::{bool_ as str};
-        use super::char_ as char;
+        use super::{
+            bool_ as bool, bool_ as str, char_ as char, f_ as f64, i8, i32_ as i32, i64_ as i64,
+            u8_ as u8, u16_ as u16, u32_ as u32, u64_ as u64,
+        };
     }
 }
 
@@ -49,7 +43,9 @@ trait isize_ {
     type isize;
 }
 
-fn usize<'usize>(usize: &'usize usize) -> &'usize usize { usize }
+fn usize<'usize>(usize: &'usize usize) -> &'usize usize {
+    usize
+}
 
 mod reuse {
     use std::mem::size_of;
@@ -68,9 +64,10 @@ mod reuse {
 mod guard {
     pub fn check() {
         use std::u8; // bring module u8 in scope
-        fn f() -> u8 { // OK, resolves to primitive u8, not to std::u8
+        fn f() -> u8 {
+            // OK, resolves to primitive u8, not to std::u8
             u8::max_value() // OK, resolves to associated function <u8>::max_value,
-                            // not to non-existent std::u8::max_value
+            // not to non-existent std::u8::max_value
         }
         assert_eq!(f(), u8::MAX); // OK, resolves to std::u8::MAX
     }
@@ -79,7 +76,13 @@ mod guard {
 fn main() {
     let bool = true;
     let _ = match bool {
-        str @ true => if str { i32 as i64 } else { i64 },
+        str @ true => {
+            if str {
+                i32 as i64
+            } else {
+                i64
+            }
+        }
         false => i64,
     };
 
diff --git a/tests/ui/runtime/on-broken-pipe/with-rustc_main.rs b/tests/ui/runtime/on-broken-pipe/with-rustc_main.rs
deleted file mode 100644
index c40590ad87f4..000000000000
--- a/tests/ui/runtime/on-broken-pipe/with-rustc_main.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ run-pass
-//@ aux-build:sigpipe-utils.rs
-//@ compile-flags: -Zon-broken-pipe=kill
-//@ only-unix because SIGPIPE is a unix thing
-
-#![feature(rustc_attrs)]
-
-#[rustc_main]
-fn rustc_main() {
-    extern crate sigpipe_utils;
-
-    // `-Zon-broken-pipe=kill` is active, so SIGPIPE handler shall be
-    // SIG_DFL. Note that we have a #[rustc_main], but it should still work.
-    sigpipe_utils::assert_sigpipe_handler(sigpipe_utils::SignalHandler::Default);
-}
diff --git a/tests/ui/scalable-vectors/invalid.rs b/tests/ui/scalable-vectors/invalid.rs
index beb3ad66b78b..90e9839c9e11 100644
--- a/tests/ui/scalable-vectors/invalid.rs
+++ b/tests/ui/scalable-vectors/invalid.rs
@@ -48,7 +48,7 @@ type Foo = u32;
 #[rustc_scalable_vector(4)]
 //~^ ERROR: `#[rustc_scalable_vector]` attribute cannot be used on enums
 enum Bar<#[rustc_scalable_vector(4)] T> {
-//~^ ERROR: `#[rustc_scalable_vector]` attribute cannot be used on function params
+//~^ ERROR: `#[rustc_scalable_vector]` attribute cannot be used on type parameters
     #[rustc_scalable_vector(4)]
 //~^ ERROR: `#[rustc_scalable_vector]` attribute cannot be used on enum variants
     Baz(std::marker::PhantomData<T>),
diff --git a/tests/ui/scalable-vectors/invalid.stderr b/tests/ui/scalable-vectors/invalid.stderr
index 43be84a8b005..d73b5abf7030 100644
--- a/tests/ui/scalable-vectors/invalid.stderr
+++ b/tests/ui/scalable-vectors/invalid.stderr
@@ -92,7 +92,7 @@ LL | #[rustc_scalable_vector(4)]
    |
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
-error: `#[rustc_scalable_vector]` attribute cannot be used on function params
+error: `#[rustc_scalable_vector]` attribute cannot be used on type parameters
   --> $DIR/invalid.rs:50:10
    |
 LL | enum Bar<#[rustc_scalable_vector(4)] T> {
diff --git a/tests/ui/self/self-in-method-body-resolves.rs b/tests/ui/self/self-in-method-body-resolves.rs
new file mode 100644
index 000000000000..636922cd87ce
--- /dev/null
+++ b/tests/ui/self/self-in-method-body-resolves.rs
@@ -0,0 +1,16 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/24389>
+//@ check-pass
+#![allow(dead_code)]
+
+struct Foo;
+
+impl Foo {
+    fn new() -> Self {
+        Foo
+    }
+    fn bar() {
+        Self::new();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/single-use-lifetime/issue-104440.rs b/tests/ui/single-use-lifetime/issue-104440.rs
index 0795e95303a1..cecd17fb930b 100644
--- a/tests/ui/single-use-lifetime/issue-104440.rs
+++ b/tests/ui/single-use-lifetime/issue-104440.rs
@@ -8,7 +8,7 @@ mod type_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($T:ident) {
         fn g<$T: Clone>(t1: $T, t2: T) -> (T, $T) {
             (t1.clone(), t2.clone())
@@ -40,7 +40,7 @@ mod lifetime_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($a:lifetime) {
         fn g<$a>(t1: &$a(), t2: &'a ()) -> (&'a (), &$a ()) {
             (t1, t2)
@@ -72,7 +72,7 @@ mod const_params {
         }
     }
 
-    #[rustc_macro_transparency = "semitransparent"]
+    #[rustc_macro_transparency = "semiopaque"]
     macro n($C:ident) {
         fn g<const $C: usize>(t1: [(); $C], t2: [(); C]) -> ([(); C], [(); $C]) {
             (t1, t2)
diff --git a/tests/ui/specialization/const_trait_impl.stderr b/tests/ui/specialization/const_trait_impl.stderr
deleted file mode 100644
index 93ed7234e563..000000000000
--- a/tests/ui/specialization/const_trait_impl.stderr
+++ /dev/null
@@ -1,59 +0,0 @@
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:33:9
-   |
-LL | impl<T: [const] Debug> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:39:9
-   |
-LL | impl<T: [const] Debug + [const] Sup> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:45:9
-   |
-LL | impl<T: [const] Debug + [const] Sub> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:39:9
-   |
-LL | impl<T: [const] Debug + [const] Sup> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:33:9
-   |
-LL | impl<T: [const] Debug> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `const` traits
-  --> $DIR/const_trait_impl.rs:45:9
-   |
-LL | impl<T: [const] Debug + [const] Sub> const A for T {
-   |         ^^^^^^^ can't be applied to `Debug`
-   |
-note: `Debug` can't be used with `[const]` because it isn't `const`
-  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 6 previous errors
-
diff --git a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
index edea6f75444f..538b0c2b1d46 100644
--- a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
+++ b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
@@ -1,6 +1,6 @@
 // Regression test for #140571. The compiler used to ICE
 
-#![feature(associated_const_equality, min_generic_const_args, specialization)]
+#![feature(min_generic_const_args, specialization)]
 //~^ WARN the feature `specialization` is incomplete
 //~| WARN the feature `min_generic_const_args` is incomplete
 
diff --git a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
index bf15d0fae4e5..6159c2ed331a 100644
--- a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
+++ b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
@@ -1,17 +1,17 @@
 warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:39
+  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:12
    |
-LL | #![feature(associated_const_equality, min_generic_const_args, specialization)]
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^
+LL | #![feature(min_generic_const_args, specialization)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
 warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:63
+  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:36
    |
-LL | #![feature(associated_const_equality, min_generic_const_args, specialization)]
-   |                                                               ^^^^^^^^^^^^^^
+LL | #![feature(min_generic_const_args, specialization)]
+   |                                    ^^^^^^^^^^^^^^
    |
    = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
    = help: consider using `min_specialization` instead, which is more stable and complete
diff --git a/tests/ui/static/static-initializer-acyclic-issue-146787.rs b/tests/ui/static/static-initializer-acyclic-issue-146787.rs
new file mode 100644
index 000000000000..715133bd5d3c
--- /dev/null
+++ b/tests/ui/static/static-initializer-acyclic-issue-146787.rs
@@ -0,0 +1,29 @@
+//@ add-minicore
+//@ needs-llvm-components: nvptx
+//@ compile-flags: --target nvptx64-nvidia-cuda --emit link
+//@ ignore-backends: gcc
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+struct Foo(&'static Foo);
+impl Sync for Foo {}
+
+static A: Foo = Foo(&A); //~ ERROR static initializer forms a cycle involving `A`
+
+static B0: Foo = Foo(&B1); //~ ERROR static initializer forms a cycle involving `B0`
+static B1: Foo = Foo(&B0);
+
+static C0: Foo = Foo(&C1); //~ ERROR static initializer forms a cycle involving `C0`
+static C1: Foo = Foo(&C2);
+static C2: Foo = Foo(&C0);
+
+struct Bar(&'static u32);
+impl Sync for Bar {}
+
+static BAR: Bar = Bar(&INT);
+static INT: u32 = 42u32;
diff --git a/tests/ui/static/static-initializer-acyclic-issue-146787.stderr b/tests/ui/static/static-initializer-acyclic-issue-146787.stderr
new file mode 100644
index 000000000000..af2e4e0f5df8
--- /dev/null
+++ b/tests/ui/static/static-initializer-acyclic-issue-146787.stderr
@@ -0,0 +1,32 @@
+error: static initializer forms a cycle involving `C0`
+  --> $DIR/static-initializer-acyclic-issue-146787.rs:21:1
+   |
+LL | static C0: Foo = Foo(&C1);
+   | ^^^^^^^^^^^^^^ part of this cycle
+LL | static C1: Foo = Foo(&C2);
+   | -------------- part of this cycle
+LL | static C2: Foo = Foo(&C0);
+   | -------------- part of this cycle
+   |
+   = note: cyclic static initializers are not supported for target `nvptx64-nvidia-cuda`
+
+error: static initializer forms a cycle involving `B0`
+  --> $DIR/static-initializer-acyclic-issue-146787.rs:18:1
+   |
+LL | static B0: Foo = Foo(&B1);
+   | ^^^^^^^^^^^^^^ part of this cycle
+LL | static B1: Foo = Foo(&B0);
+   | -------------- part of this cycle
+   |
+   = note: cyclic static initializers are not supported for target `nvptx64-nvidia-cuda`
+
+error: static initializer forms a cycle involving `A`
+  --> $DIR/static-initializer-acyclic-issue-146787.rs:16:1
+   |
+LL | static A: Foo = Foo(&A);
+   | ^^^^^^^^^^^^^ part of this cycle
+   |
+   = note: cyclic static initializers are not supported for target `nvptx64-nvidia-cuda`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/suggestions/fn-trait-notation.stderr b/tests/ui/suggestions/fn-trait-notation.stderr
index 9b47c8c02a78..9d0845478527 100644
--- a/tests/ui/suggestions/fn-trait-notation.stderr
+++ b/tests/ui/suggestions/fn-trait-notation.stderr
@@ -32,7 +32,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/fn-trait-notation.rs:4:8
    |
 LL |     F: Fn<i32, Output = i32>,
-   |        ^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   |        ^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -47,7 +47,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/fn-trait-notation.rs:9:5
    |
 LL |     f(3);
-   |     ^^^^ the trait `Tuple` is not implemented for `i32`
+   |     ^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error[E0308]: mismatched types
   --> $DIR/fn-trait-notation.rs:17:5
diff --git a/tests/ui/suggestions/multi-suggestion.ascii.stderr b/tests/ui/suggestions/multi-suggestion.ascii.stderr
index c2ae19b1ae9a..2da0f9bd12c2 100644
--- a/tests/ui/suggestions/multi-suggestion.ascii.stderr
+++ b/tests/ui/suggestions/multi-suggestion.ascii.stderr
@@ -5,6 +5,7 @@ LL |     let _ = std::collections::HashMap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+  ::: $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    |
    = note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL |     let _ = std::collections::HashMap::new();
    |                                      +++++
 LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::new_in(_);
+   |
+LL -     let _ = std::collections::HashMap();
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   |
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    |
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
   --> $DIR/multi-suggestion.rs:19:13
    |
 LL |     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    |
 LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::new_in(_);
+   |
+LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   |
-LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/suggestions/multi-suggestion.rs b/tests/ui/suggestions/multi-suggestion.rs
index 99d2407aa212..6d822a8e5aff 100644
--- a/tests/ui/suggestions/multi-suggestion.rs
+++ b/tests/ui/suggestions/multi-suggestion.rs
@@ -17,6 +17,6 @@ fn main() {
     let _ = std::collections::HashMap();
     //[ascii]~^ ERROR expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
     let _ = std::collections::HashMap {};
-    //[ascii]~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+    //[ascii]~^ ERROR cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
     let _ = Box {}; //[ascii]~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
 }
diff --git a/tests/ui/suggestions/multi-suggestion.unicode.stderr b/tests/ui/suggestions/multi-suggestion.unicode.stderr
index fc187cac91d1..69529b67b775 100644
--- a/tests/ui/suggestions/multi-suggestion.unicode.stderr
+++ b/tests/ui/suggestions/multi-suggestion.unicode.stderr
@@ -5,6 +5,7 @@ LL │     let _ = std::collections::HashMap();
    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━
    ╰╴
    ╭▸ $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+   ⸬  $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    │
    ╰ note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL │     let _ = std::collections::HashMap::new();
    ├╴                                     +++++
 LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::new_in(_);
+   ├╴
+LL -     let _ = std::collections::HashMap();
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    ├╴
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   ├╴
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
-   ╰╴
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
+   │
+   ╰ and 4 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL │     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    ╰╴
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
    ╭▸ $DIR/multi-suggestion.rs:19:13
    │
 LL │     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    ├╴
 LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::new_in(_);
+   ├╴
+LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::with_capacity(_);
    ├╴
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
-   ├╴
-LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
-   ╰╴
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
+   │
+   ╰ and 4 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/thir-print/offset_of.stdout b/tests/ui/thir-print/offset_of.stdout
index ab924091ba7a..dcf60a86af9b 100644
--- a/tests/ui/thir-print/offset_of.stdout
+++ b/tests/ui/thir-print/offset_of.stdout
@@ -68,7 +68,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).10))
-                                            span: $DIR/offset_of.rs:37:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:37:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -117,7 +117,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).20))
-                                            span: $DIR/offset_of.rs:38:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:38:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -166,7 +166,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).30))
-                                            span: $DIR/offset_of.rs:39:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:39:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -215,7 +215,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).40))
-                                            span: $DIR/offset_of.rs:40:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:40:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -264,7 +264,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).50))
-                                            span: $DIR/offset_of.rs:41:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:41:5: 1440:57 (#0)
                                         }
                                     }
                                 ]
@@ -864,7 +864,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).12))
-                                            span: $DIR/offset_of.rs:45:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:45:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -913,7 +913,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).24))
-                                            span: $DIR/offset_of.rs:46:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:46:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -962,7 +962,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).36))
-                                            span: $DIR/offset_of.rs:47:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:47:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -1011,7 +1011,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).48))
-                                            span: $DIR/offset_of.rs:48:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:48:5: 1440:57 (#0)
                                         }
                                     }
                                 ]
diff --git a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.rs b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.rs
index d8fd1d44a985..37fa01692053 100644
--- a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.rs
+++ b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.rs
@@ -9,3 +9,11 @@ fn main() {
     //~| HELP try using a fully qualified path to specify the expected types
     //~| HELP consider removing this method call, as the receiver has type `Bar` and `Bar: From<Bar>` trivially holds
 }
+
+// regression test for https://github.com/rust-lang/rust/issues/149487.
+fn quux() {
+    let mut tx_heights: std::collections::BTreeMap<(), Option<()>> = <_>::default();
+    tx_heights.get(&()).unwrap_or_default();
+    //~^ ERROR the trait bound `&Option<()>: Default` is not satisfied
+    //~| HELP: the trait `Default` is implemented for `Option<T>`
+}
diff --git a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
index 7d795581ea9d..f0c993125279 100644
--- a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
+++ b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
@@ -23,6 +23,18 @@ LL -     qux(Bar.into());
 LL +     qux(Bar);
    |
 
-error: aborting due to 1 previous error
+error[E0277]: the trait bound `&Option<()>: Default` is not satisfied
+  --> $DIR/argument-with-unnecessary-method-call.rs:16:25
+   |
+LL |     tx_heights.get(&()).unwrap_or_default();
+   |                         ^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&Option<()>`
+   |
+help: the trait `Default` is implemented for `Option<T>`
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+note: required by a bound in `Option::<T>::unwrap_or_default`
+  --> $SRC_DIR/core/src/option.rs:LL:COL
 
-For more information about this error, try `rustc --explain E0283`.
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0277, E0283.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/recursive-trait-bound-on-type-param.rs b/tests/ui/traits/bound/recursive-trait-bound-on-type-param.rs
new file mode 100644
index 000000000000..41ae91afad49
--- /dev/null
+++ b/tests/ui/traits/bound/recursive-trait-bound-on-type-param.rs
@@ -0,0 +1,12 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/19601>
+//@ check-pass
+
+trait A<T> {}
+struct B<T>
+where
+    B<T>: A<B<T>>,
+{
+    t: T,
+}
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
index 0bc25ce5f650..e61ae2760aab 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
@@ -1,15 +1,15 @@
-//@ known-bug: #110395
-#![feature(derive_const)]
+#![feature(const_default, derive_const)]
 
 pub struct A;
 
-impl std::fmt::Debug for A {
-    fn fmt(&self, _: &mut std::fmt::Formatter<'_>)  -> Result<(), std::fmt::Error> {
-        panic!()
+impl Default for A {
+    fn default() -> A {
+        A
     }
 }
 
-#[derive_const(Debug)]
+#[derive_const(Default)]
 pub struct S(A);
+//~^ ERROR: cannot call non-const associated function
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
index 93638801895d..558957985328 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
@@ -1,20 +1,13 @@
-error: const `impl` for trait `Debug` which is not `const`
-  --> $DIR/derive-const-non-const-type.rs:12:16
+error[E0015]: cannot call non-const associated function `<A as Default>::default` in constant functions
+  --> $DIR/derive-const-non-const-type.rs:12:14
    |
-LL | #[derive_const(Debug)]
-   |                ^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error[E0015]: cannot call non-const method `Formatter::<'_>::debug_tuple_field1_finish` in constant functions
-  --> $DIR/derive-const-non-const-type.rs:12:16
-   |
-LL | #[derive_const(Debug)]
-   |                ^^^^^
+LL | #[derive_const(Default)]
+   |                ------- in this derive macro expansion
+LL | pub struct S(A);
+   |              ^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/rustc-impl-const-stability.rs b/tests/ui/traits/const-traits/rustc-impl-const-stability.rs
similarity index 63%
rename from tests/ui/consts/rustc-impl-const-stability.rs
rename to tests/ui/traits/const-traits/rustc-impl-const-stability.rs
index 93a5e8e4f458..7d30342d11ca 100644
--- a/tests/ui/consts/rustc-impl-const-stability.rs
+++ b/tests/ui/traits/const-traits/rustc-impl-const-stability.rs
@@ -1,5 +1,4 @@
-//@ compile-flags: -Znext-solver
-//@ known-bug: #110395
+//@ check-pass
 
 #![crate_type = "lib"]
 #![feature(staged_api, const_trait_impl, const_default)]
@@ -12,8 +11,8 @@ pub struct Data {
 
 #[stable(feature = "potato", since = "1.27.0")]
 #[rustc_const_unstable(feature = "data_foo", issue = "none")]
-impl const std::fmt::Debug for Data {
-    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        Ok(())
+impl const Default for Data {
+    fn default() -> Data {
+        Data { _data: 0xbeef }
     }
 }
diff --git a/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.rs b/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.rs
index 5125d2580238..f771107ec068 100644
--- a/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.rs
+++ b/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.rs
@@ -1,7 +1,5 @@
 // Tests that trait bounds on specializing trait impls must be `[const]` if the
 // same bound is present on the default impl and is `[const]` there.
-//@ known-bug: #110395
-// FIXME(const_trait_impl) ^ should error
 
 #![feature(const_trait_impl)]
 #![feature(rustc_attrs)]
@@ -23,9 +21,9 @@ where
     default fn bar() {}
 }
 
-impl<T> Bar for T
+impl<T> Bar for T //~ ERROR conflicting implementations of trait `Bar`
 where
-    T: Foo, //FIXME ~ ERROR missing `[const]` qualifier
+    T: Foo,
     T: Specialize,
 {
     fn bar() {}
@@ -42,7 +40,7 @@ where
     default fn baz() {}
 }
 
-impl<T> const Baz for T //FIXME ~ ERROR conflicting implementations of trait `Baz`
+impl<T> const Baz for T //~ ERROR conflicting implementations of trait `Baz`
 where
     T: Foo,
     T: Specialize,
diff --git a/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.stderr b/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.stderr
index 85e9fda5c2a3..ff27559c8ec6 100644
--- a/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.stderr
+++ b/tests/ui/traits/const-traits/specialization/const-default-bound-non-const-specialized-bound.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `Bar`
-  --> $DIR/const-default-bound-non-const-specialized-bound.rs:26:1
+  --> $DIR/const-default-bound-non-const-specialized-bound.rs:24:1
    |
 LL | / impl<T> const Bar for T
 LL | | where
@@ -8,19 +8,19 @@ LL | |     T: [const] Foo,
 ...
 LL | / impl<T> Bar for T
 LL | | where
-LL | |     T: Foo, //FIXME ~ ERROR missing `[const]` qualifier
+LL | |     T: Foo,
 LL | |     T: Specialize,
    | |__________________^ conflicting implementation
 
 error[E0119]: conflicting implementations of trait `Baz`
-  --> $DIR/const-default-bound-non-const-specialized-bound.rs:45:1
+  --> $DIR/const-default-bound-non-const-specialized-bound.rs:43:1
    |
 LL | / impl<T> const Baz for T
 LL | | where
 LL | |     T: [const] Foo,
    | |___________________- first implementation here
 ...
-LL | / impl<T> const Baz for T //FIXME ~ ERROR conflicting implementations of trait `Baz`
+LL | / impl<T> const Baz for T
 LL | | where
 LL | |     T: Foo,
 LL | |     T: Specialize,
diff --git a/tests/ui/specialization/const_trait_impl.rs b/tests/ui/traits/const-traits/specialization/pass.rs
similarity index 70%
rename from tests/ui/specialization/const_trait_impl.rs
rename to tests/ui/traits/const-traits/specialization/pass.rs
index adfef77a15ca..0ba4e40ee30a 100644
--- a/tests/ui/specialization/const_trait_impl.rs
+++ b/tests/ui/traits/const-traits/specialization/pass.rs
@@ -1,8 +1,6 @@
-//@ known-bug: #110395
-
-#![feature(const_trait_impl, min_specialization, rustc_attrs)]
-
-use std::fmt::Debug;
+//@ check-pass
+#![feature(const_trait_impl, const_default, min_specialization, rustc_attrs)]
+#![allow(internal_features)]
 
 #[rustc_specialization_trait]
 pub const unsafe trait Sup {
@@ -30,19 +28,19 @@ pub const trait A {
     fn a() -> u32;
 }
 
-impl<T: [const] Debug> const A for T {
+impl<T: [const] Default> const A for T {
     default fn a() -> u32 {
         2
     }
 }
 
-impl<T: [const] Debug + [const] Sup> const A for T {
+impl<T: [const] Default + [const] Sup> const A for T {
     default fn a() -> u32 {
         3
     }
 }
 
-impl<T: [const] Debug + [const] Sub> const A for T {
+impl<T: [const] Default + [const] Sub> const A for T {
     fn a() -> u32 {
         T::foo()
     }
diff --git a/tests/ui/traits/const-traits/specializing-constness-2.rs b/tests/ui/traits/const-traits/specialization/specializing-constness-2.rs
similarity index 81%
rename from tests/ui/traits/const-traits/specializing-constness-2.rs
rename to tests/ui/traits/const-traits/specialization/specializing-constness-2.rs
index 455dd111603d..78cfbe361d91 100644
--- a/tests/ui/traits/const-traits/specializing-constness-2.rs
+++ b/tests/ui/traits/const-traits/specialization/specializing-constness-2.rs
@@ -1,5 +1,6 @@
 #![feature(const_trait_impl, min_specialization, rustc_attrs)]
-//@ known-bug: #110395
+#![allow(internal_features)]
+
 #[rustc_specialization_trait]
 pub const trait Sup {}
 
@@ -23,7 +24,7 @@ impl<T: Default + [const] Sup> const A for T {
 
 const fn generic<T: Default>() {
     <T as A>::a();
-    //FIXME ~^ ERROR: the trait bound `T: [const] Sup` is not satisfied
+    //~^ ERROR: the trait bound `T: [const] A` is not satisfied
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/specializing-constness-2.stderr b/tests/ui/traits/const-traits/specialization/specializing-constness-2.stderr
similarity index 88%
rename from tests/ui/traits/const-traits/specializing-constness-2.stderr
rename to tests/ui/traits/const-traits/specialization/specializing-constness-2.stderr
index bd6ffa544d0e..bb1c9ac78531 100644
--- a/tests/ui/traits/const-traits/specializing-constness-2.stderr
+++ b/tests/ui/traits/const-traits/specialization/specializing-constness-2.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `T: [const] A` is not satisfied
-  --> $DIR/specializing-constness-2.rs:25:6
+  --> $DIR/specializing-constness-2.rs:26:6
    |
 LL |     <T as A>::a();
    |      ^
diff --git a/tests/ui/traits/const-traits/specializing-constness.rs b/tests/ui/traits/const-traits/specialization/specializing-constness.rs
similarity index 100%
rename from tests/ui/traits/const-traits/specializing-constness.rs
rename to tests/ui/traits/const-traits/specialization/specializing-constness.rs
diff --git a/tests/ui/traits/const-traits/specializing-constness.stderr b/tests/ui/traits/const-traits/specialization/specializing-constness.stderr
similarity index 100%
rename from tests/ui/traits/const-traits/specializing-constness.stderr
rename to tests/ui/traits/const-traits/specialization/specializing-constness.stderr
diff --git a/tests/ui/traits/ignore-err-impls.stderr b/tests/ui/traits/ignore-err-impls.stderr
index 68077c435135..46a2a7d55a2e 100644
--- a/tests/ui/traits/ignore-err-impls.stderr
+++ b/tests/ui/traits/ignore-err-impls.stderr
@@ -4,10 +4,10 @@ error[E0425]: cannot find type `Type` in this scope
 LL | impl Generic<Type> for S {}
    |              ^^^^ not found in this scope
    |
-help: you might be missing a type parameter
+help: consider importing this struct
+   |
+LL + use std::mem::type_info::Type;
    |
-LL | impl<Type> Generic<Type> for S {}
-   |     ++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/issue-77982.stderr b/tests/ui/traits/issue-77982.stderr
index edc7f56ea467..4bc24e81215a 100644
--- a/tests/ui/traits/issue-77982.stderr
+++ b/tests/ui/traits/issue-77982.stderr
@@ -10,7 +10,7 @@ LL |     opts.get(opt.as_ref());
            - impl Borrow<str> for String;
            - impl<T> Borrow<T> for T
              where T: ?Sized;
-note: required by a bound in `HashMap::<K, V, S>::get`
+note: required by a bound in `HashMap::<K, V, S, A>::get`
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 help: consider specifying the generic argument
    |
diff --git a/tests/ui/traits/next-solver/dont-ice-on-assoc-projection.stderr b/tests/ui/traits/next-solver/dont-ice-on-assoc-projection.stderr
index db7d2dd3e3a3..8334fdae9485 100644
--- a/tests/ui/traits/next-solver/dont-ice-on-assoc-projection.stderr
+++ b/tests/ui/traits/next-solver/dont-ice-on-assoc-projection.stderr
@@ -4,8 +4,8 @@ error[E0658]: associated const equality is incomplete
 LL | impl<T> Foo for T where T: Bar<ASSOC = 0> {}
    |                                ^^^^^^^^^
    |
-   = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
-   = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0119]: conflicting implementations of trait `Foo` for type `()`
diff --git a/tests/ui/traits/next-solver/well-formed-in-relate.stderr b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
index d79e465b3e38..264ab9bebbb9 100644
--- a/tests/ui/traits/next-solver/well-formed-in-relate.stderr
+++ b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
@@ -9,11 +9,11 @@ LL |     x = unconstrained_map();
    |
    = note: multiple `impl`s satisfying `_: Fn()` found in the following crates: `alloc`, `core`:
            - impl<A, F> Fn<A> for &F
-             where A: Tuple, F: Fn<A>, F: ?Sized;
+             where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
-             where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+             where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
            - impl<F, Args> Fn<Args> for Exclusive<F>
-             where F: Sync, F: Fn<Args>, Args: Tuple;
+             where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
 note: required by a bound in `unconstrained_map`
   --> $DIR/well-formed-in-relate.rs:21:25
    |
diff --git a/tests/ui/transmutability/non_scalar_alignment_value.rs b/tests/ui/transmutability/non_scalar_alignment_value.rs
new file mode 100644
index 000000000000..45c9e61fcfe2
--- /dev/null
+++ b/tests/ui/transmutability/non_scalar_alignment_value.rs
@@ -0,0 +1,30 @@
+#![feature(min_generic_const_args)]
+//~^ WARN the feature `min_generic_const_args` is incomplete
+
+#![feature(transmutability)]
+
+mod assert {
+    use std::mem::{Assume, TransmuteFrom};
+    struct Dst {}
+    fn is_maybe_transmutable()
+    where
+        Dst: TransmuteFrom<
+            (),
+            {
+                Assume {
+                    alignment: Assume {},
+                    //~^ ERROR struct expression with missing field initialiser for `alignment`
+                    //~| ERROR struct expression with missing field initialiser for `lifetimes`
+                    //~| ERROR struct expression with missing field initialiser for `safety`
+                    //~| ERROR struct expression with missing field initialiser for `validity`
+                    lifetimes: const { true },
+                    safety: const { true },
+                    validity: const { true },
+                }
+            },
+        >,
+    {
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmutability/non_scalar_alignment_value.stderr b/tests/ui/transmutability/non_scalar_alignment_value.stderr
new file mode 100644
index 000000000000..d22c6d0b27e8
--- /dev/null
+++ b/tests/ui/transmutability/non_scalar_alignment_value.stderr
@@ -0,0 +1,35 @@
+warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/non_scalar_alignment_value.rs:1:12
+   |
+LL | #![feature(min_generic_const_args)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error: struct expression with missing field initialiser for `alignment`
+  --> $DIR/non_scalar_alignment_value.rs:15:32
+   |
+LL |                     alignment: Assume {},
+   |                                ^^^^^^^^^
+
+error: struct expression with missing field initialiser for `lifetimes`
+  --> $DIR/non_scalar_alignment_value.rs:15:32
+   |
+LL |                     alignment: Assume {},
+   |                                ^^^^^^^^^
+
+error: struct expression with missing field initialiser for `safety`
+  --> $DIR/non_scalar_alignment_value.rs:15:32
+   |
+LL |                     alignment: Assume {},
+   |                                ^^^^^^^^^
+
+error: struct expression with missing field initialiser for `validity`
+  --> $DIR/non_scalar_alignment_value.rs:15:32
+   |
+LL |                     alignment: Assume {},
+   |                                ^^^^^^^^^
+
+error: aborting due to 4 previous errors; 1 warning emitted
+
diff --git a/tests/ui/try-trait/bad-question-mark-on-trait-object.rs b/tests/ui/try-trait/bad-question-mark-on-trait-object.rs
index 2a0d14b17503..270ec2c532ac 100644
--- a/tests/ui/try-trait/bad-question-mark-on-trait-object.rs
+++ b/tests/ui/try-trait/bad-question-mark-on-trait-object.rs
@@ -1,6 +1,5 @@
 struct E;
 //~^ NOTE `E` needs to implement `std::error::Error`
-//~| NOTE alternatively, `E` needs to implement `Into<X>`
 struct X; //~ NOTE `X` needs to implement `From<E>`
 
 fn foo() -> Result<(), Box<dyn std::error::Error>> { //~ NOTE required `E: std::error::Error` because of this
diff --git a/tests/ui/try-trait/bad-question-mark-on-trait-object.stderr b/tests/ui/try-trait/bad-question-mark-on-trait-object.stderr
index dd380850c9ec..7639489b891a 100644
--- a/tests/ui/try-trait/bad-question-mark-on-trait-object.stderr
+++ b/tests/ui/try-trait/bad-question-mark-on-trait-object.stderr
@@ -1,5 +1,5 @@
 error[E0277]: `?` couldn't convert the error: `E: std::error::Error` is not satisfied
-  --> $DIR/bad-question-mark-on-trait-object.rs:7:13
+  --> $DIR/bad-question-mark-on-trait-object.rs:6:13
    |
 LL | fn foo() -> Result<(), Box<dyn std::error::Error>> {
    |             -------------------------------------- required `E: std::error::Error` because of this
@@ -17,7 +17,7 @@ LL | struct E;
    = note: required for `Box<dyn std::error::Error>` to implement `From<E>`
 
 error[E0277]: `?` couldn't convert the error to `X`
-  --> $DIR/bad-question-mark-on-trait-object.rs:18:13
+  --> $DIR/bad-question-mark-on-trait-object.rs:17:13
    |
 LL | fn bat() -> Result<(), X> {
    |             ------------- expected `X` because of this
@@ -27,15 +27,10 @@ LL |     Ok(bar()?)
    |        this can't be annotated with `?` because it has type `Result<_, E>`
    |
 note: `X` needs to implement `From<E>`
-  --> $DIR/bad-question-mark-on-trait-object.rs:4:1
+  --> $DIR/bad-question-mark-on-trait-object.rs:3:1
    |
 LL | struct X;
    | ^^^^^^^^
-note: alternatively, `E` needs to implement `Into<X>`
-  --> $DIR/bad-question-mark-on-trait-object.rs:1:1
-   |
-LL | struct E;
-   | ^^^^^^^^
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/tuple/builtin-fail.stderr b/tests/ui/tuple/builtin-fail.stderr
index 44e79578f4c9..0dec88ded7ce 100644
--- a/tests/ui/tuple/builtin-fail.stderr
+++ b/tests/ui/tuple/builtin-fail.stderr
@@ -2,7 +2,7 @@ error[E0277]: `T` is not a tuple
   --> $DIR/builtin-fail.rs:8:23
    |
 LL |     assert_is_tuple::<T>();
-   |                       ^ the trait `Tuple` is not implemented for `T`
+   |                       ^ the trait `std::marker::Tuple` is not implemented for `T`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -18,7 +18,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/builtin-fail.rs:13:23
    |
 LL |     assert_is_tuple::<i32>();
-   |                       ^^^ the trait `Tuple` is not implemented for `i32`
+   |                       ^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -30,7 +30,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/builtin-fail.rs:15:24
    |
 LL |     assert_is_tuple::<(i32)>();
-   |                        ^^^ the trait `Tuple` is not implemented for `i32`
+   |                        ^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -44,7 +44,7 @@ error[E0277]: `TupleStruct` is not a tuple
 LL |     assert_is_tuple::<TupleStruct>();
    |                       ^^^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `Tuple` is not implemented for `TupleStruct`
+help: the trait `std::marker::Tuple` is not implemented for `TupleStruct`
   --> $DIR/builtin-fail.rs:5:1
    |
 LL | struct TupleStruct(i32, i32);
diff --git a/tests/ui/typeck/issue-57404.stderr b/tests/ui/typeck/issue-57404.stderr
index 4c1bfc0cbf77..f1d28e475a07 100644
--- a/tests/ui/typeck/issue-57404.stderr
+++ b/tests/ui/typeck/issue-57404.stderr
@@ -2,7 +2,7 @@ error[E0277]: `&mut ()` is not a tuple
   --> $DIR/issue-57404.rs:6:41
    |
 LL |     handlers.unwrap().as_mut().call_mut(&mut ());
-   |                                -------- ^^^^^^^ the trait `Tuple` is not implemented for `&mut ()`
+   |                                -------- ^^^^^^^ the trait `std::marker::Tuple` is not implemented for `&mut ()`
    |                                |
    |                                required by a bound introduced by this call
    |
diff --git a/tests/ui/typeck/tuple-ref-order-distinct-impls.rs b/tests/ui/typeck/tuple-ref-order-distinct-impls.rs
new file mode 100644
index 000000000000..fdede8a1d9c4
--- /dev/null
+++ b/tests/ui/typeck/tuple-ref-order-distinct-impls.rs
@@ -0,0 +1,12 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/11384>
+//@ check-pass
+
+trait Common {
+    fn dummy(&self) {}
+}
+
+impl<'t, T> Common for (T, &'t T) {}
+
+impl<'t, T> Common for (&'t T, T) {}
+
+fn main() {}
diff --git a/tests/ui/ufcs/ufcs-trait-object-format.rs b/tests/ui/ufcs/ufcs-trait-object-format.rs
new file mode 100644
index 000000000000..7d50a2444806
--- /dev/null
+++ b/tests/ui/ufcs/ufcs-trait-object-format.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+//! Regression test for <https://github.com/rust-lang/rust/issues/20676>.
+//! Error was that we didn't support
+//! UFCS-style calls to a method in `Trait` where `Self` was bound to a
+//! trait object of type `Trait`.
+//! See also <https://github.com/rust-lang/rust/blob/ec2cc76/tests/ui/traits/ufcs-object.rs>.
+
+use std::fmt;
+
+fn main() {
+    let a: &dyn fmt::Debug = &1;
+    let _ = format!("{:?}", a);
+}
diff --git a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
index 0d4265ddf8bd..621a533dd1c5 100644
--- a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
+++ b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/non-tupled-arg-mismatch.rs:3:9
    |
 LL | fn a<F: Fn<usize>>(f: F) {}
-   |         ^^^^^^^^^ the trait `Tuple` is not implemented for `usize`
+   |         ^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `usize`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.rs b/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.rs
new file mode 100644
index 000000000000..5f2d6680efac
--- /dev/null
+++ b/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Zunpretty=hir
+//@ check-pass
+
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+#![allow(dead_code)]
+
+use std::marker::ConstParamTy;
+
+struct Point(u32, u32);
+
+struct Point3();
+
+struct Point1 {
+    a: u32,
+    b: u32,
+}
+
+struct Point2 {}
+
+fn with_point<const P: Point>() {}
+fn with_point1<const P: Point1>() {}
+fn with_point2<const P: Point2>() {}
+fn with_point3<const P: Point3>() {}
+
+fn test<const N: u32>() {
+    with_point::<{ Point(N, N) }>();
+    with_point1::<{ Point1 { a: N, b: N } }>();
+    with_point2::<{ Point2 {} }>();
+    with_point3::<{ Point3() }>();
+}
+
+fn main() {}
diff --git a/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.stdout b/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.stdout
new file mode 100644
index 000000000000..fc0fbe8ef237
--- /dev/null
+++ b/tests/ui/unpretty/struct-exprs-tuple-call-pretty-printing.stdout
@@ -0,0 +1,39 @@
+//@ compile-flags: -Zunpretty=hir
+//@ check-pass
+
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+#![allow(dead_code)]
+#[attr = MacroUse {arguments: UseAll}]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+
+use std::marker::ConstParamTy;
+
+struct Point(u32, u32);
+
+struct Point3();
+
+struct Point1 {
+    a: u32,
+    b: u32,
+}
+
+struct Point2 {
+}
+
+fn with_point<const P: Point>() { }
+fn with_point1<const P: Point1>() { }
+fn with_point2<const P: Point2>() { }
+fn with_point3<const P: Point3>() { }
+
+fn test<const N:
+    u32>() {
+    with_point::<Point(N, N)>();
+    with_point1::<Point1 { a: N, b: N}>();
+    with_point2::<Point2 {}>();
+    with_point3::<Point3()>();
+}
+
+fn main() { }
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
index 519e913480ec..f2b9f037ea5f 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
@@ -4,7 +4,6 @@ trait Foo<const N: Bar<2>> {
     //~^ WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
     //~| ERROR cycle detected when computing type of `Foo::N`
-    //~| ERROR cycle detected when computing type of `Foo::N`
     fn func() {}
 }
 
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
index 0ecb3e74eb57..4024f57af4ff 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
@@ -13,7 +13,7 @@ LL | trait Foo<const N: dyn Bar<2>> {
    |                    +++
 
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:20
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:20
    |
 LL | trait Bar<const M: Foo<2>> {}
    |                    ^^^^^^
@@ -32,7 +32,7 @@ LL | trait Foo<const N: Bar<2>> {
    |           ^^^^^^^^^^^^^^^
    |
 note: ...which requires computing type of `Bar::M`...
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:11
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:11
    |
 LL | trait Bar<const M: Foo<2>> {}
    |           ^^^^^^^^^^^^^^^
@@ -44,26 +44,6 @@ LL | trait Foo<const N: Bar<2>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0391]: cycle detected when computing type of `Foo::N`
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:3:11
-   |
-LL | trait Foo<const N: Bar<2>> {
-   |           ^^^^^^^^^^^^^^^
-   |
-note: ...which requires computing type of `Bar::M`...
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:11
-   |
-LL | trait Bar<const M: Foo<2>> {}
-   |           ^^^^^^^^^^^^^^^
-   = note: ...which again requires computing type of `Foo::N`, completing the cycle
-note: cycle used when checking that `Foo` is well-formed
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:3:1
-   |
-LL | trait Foo<const N: Bar<2>> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/triagebot.toml b/triagebot.toml
index fb6660b9dd03..89118fdb5948 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -240,7 +240,7 @@ trigger_files = [
     "src/rustdoc-json-types",
 
     # Tests
-    "tests/rustdoc",
+    "tests/rustdoc-html",
     "tests/rustdoc-ui",
     "tests/rustdoc-gui",
     "tests/rustdoc-js/",
@@ -315,7 +315,7 @@ trigger_labels = [
 ]
 trigger_files = [
     "src/librustdoc/html/",
-    "tests/rustdoc/",
+    "tests/rustdoc-html/",
     "tests/rustdoc-gui/",
     "tests/rustdoc-js/",
     "tests/rustdoc-js-std/",
@@ -1003,6 +1003,13 @@ cc = ["@lcnr"]
 message = "HIR ty lowering was modified"
 cc = ["@fmease"]
 
+[mentions."library/core/src/mem/type_info.rs"]
+message = """
+The reflection data structures are tied exactly to the implementation
+in the compiler. Make sure to also adjust `rustc_const_eval/src/const_eval/type_info.rs
+"""
+cc = ["@oli-obk"]
+
 [mentions."compiler/rustc_error_codes/src/lib.rs"]
 message = "Some changes occurred in diagnostic error codes"
 cc = ["@GuillaumeGomez"]
@@ -1059,6 +1066,14 @@ gets adapted for the changes, if necessary.
 """
 cc = ["@rust-lang/miri", "@RalfJung", "@oli-obk", "@lcnr"]
 
+[mentions."library/core/src/num/{dec2flt,flt2dec}"]
+message = "Some changes occurred in float parsing"
+cc = ["@tgross35"]
+
+[mentions."library/core/src/fmt/num.rs"]
+message = "Some changes occurred in integer formatting"
+cc = ["@tgross35"]
+
 [mentions."library/portable-simd"]
 message = """
 Portable SIMD is developed in its own repository. If possible, consider \
@@ -1350,11 +1365,11 @@ message = "The rustc-dev-guide subtree was changed. If this PR *only* touches th
 cc = ["@BoxyUwU", "@jieyouxu", "@kobzol", "@tshepang"]
 
 [mentions."compiler/rustc_passes/src/check_attr.rs"]
-cc = ["@jdonszelmann"]
+cc = ["@jdonszelmann", "@JonathanBrouwer"]
 [mentions."compiler/rustc_attr_parsing"]
-cc = ["@jdonszelmann"]
+cc = ["@jdonszelmann", "@JonathanBrouwer"]
 [mentions."compiler/rustc_hir/src/attrs"]
-cc = ["@jdonszelmann"]
+cc = ["@jdonszelmann", "@JonathanBrouwer"]
 
 [mentions."src/tools/enzyme"]
 cc = ["@ZuseZ4"]
@@ -1626,7 +1641,7 @@ dep-bumps = [
 "/src/stage0" =                                          ["bootstrap"]
 "/tests/run-make" =                                      ["compiler"]
 "/tests/run-make-cargo" =                                ["compiler"]
-"/tests/rustdoc" =                                       ["rustdoc"]
+"/tests/rustdoc-html" =                                  ["rustdoc"]
 "/tests/rustdoc-gui" =                                   ["rustdoc"]
 "/tests/rustdoc-js-std" =                                ["rustdoc"]
 "/tests/rustdoc-js/" =                                   ["rustdoc"]