diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 32a9d081ed8..88edaec9169 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -72,6 +72,8 @@ macro_rules! declare_features {
     (accepted, cfg_doctest, "1.40.0", Some(62210), None),
     /// Allows `cfg(target_feature = "...")`.
     (accepted, cfg_target_feature, "1.27.0", Some(29717), None),
+    /// Allows `cfg(target_has_atomic = "...")`.
+    (accepted, cfg_target_has_atomic, "1.60.0", Some(32976), None),
     /// Allows `cfg(target_vendor = "...")`.
     (accepted, cfg_target_vendor, "1.33.0", Some(29718), None),
     /// Allows implementing `Clone` for closures where possible (RFC 2132).
diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
index 0248d3235df..fab22e4e6cf 100644
--- a/compiler/rustc_feature/src/active.rs
+++ b/compiler/rustc_feature/src/active.rs
@@ -309,8 +309,8 @@ pub fn set(&self, features: &mut Features, span: Span) {
     (active, cfg_sanitize, "1.41.0", Some(39699), None),
     /// Allows `cfg(target_abi = "...")`.
     (active, cfg_target_abi, "1.55.0", Some(80970), None),
-    /// Allows `cfg(target_has_atomic = "...")`.
-    (active, cfg_target_has_atomic, "1.9.0", Some(32976), None),
+    /// Allows `cfg(target_has_atomic_equal_alignment = "...")`.
+    (active, cfg_target_has_atomic_equal_alignment, "1.60.0", Some(93822), None),
     /// Allows `cfg(target_thread_local)`.
     (active, cfg_target_thread_local, "1.7.0", Some(29594), None),
     /// Allow conditional compilation depending on rust version
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 599ac7f3310..69ce21d231f 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -26,12 +26,10 @@ macro_rules! cfg_fn {
     // (name in cfg, feature, function to check if the feature is enabled)
     (sym::target_abi, sym::cfg_target_abi, cfg_fn!(cfg_target_abi)),
     (sym::target_thread_local, sym::cfg_target_thread_local, cfg_fn!(cfg_target_thread_local)),
-    (sym::target_has_atomic, sym::cfg_target_has_atomic, cfg_fn!(cfg_target_has_atomic)),
-    (sym::target_has_atomic_load_store, sym::cfg_target_has_atomic, cfg_fn!(cfg_target_has_atomic)),
     (
         sym::target_has_atomic_equal_alignment,
-        sym::cfg_target_has_atomic,
-        cfg_fn!(cfg_target_has_atomic),
+        sym::cfg_target_has_atomic_equal_alignment,
+        cfg_fn!(cfg_target_has_atomic_equal_alignment),
     ),
     (sym::sanitize, sym::cfg_sanitize, cfg_fn!(cfg_sanitize)),
     (sym::version, sym::cfg_version, cfg_fn!(cfg_version)),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 6a9c260f1c0..cab1d4e21c9 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -421,6 +421,7 @@
         cfg_target_abi,
         cfg_target_feature,
         cfg_target_has_atomic,
+        cfg_target_has_atomic_equal_alignment,
         cfg_target_thread_local,
         cfg_target_vendor,
         cfg_version,
diff --git a/compiler/rustc_target/src/spec/aarch64_unknown_hermit.rs b/compiler/rustc_target/src/spec/aarch64_unknown_hermit.rs
index 44beb2f6ad8..f8e1e1b02f5 100644
--- a/compiler/rustc_target/src/spec/aarch64_unknown_hermit.rs
+++ b/compiler/rustc_target/src/spec/aarch64_unknown_hermit.rs
@@ -3,6 +3,7 @@
 pub fn target() -> Target {
     let mut base = super::hermit_base::opts();
     base.max_atomic_width = Some(128);
+    base.features = "+strict-align,+neon,+fp-armv8".to_string();
 
     Target {
         llvm_target: "aarch64-unknown-hermit".to_string(),
diff --git a/compiler/rustc_target/src/spec/aarch64_unknown_none_hermitkernel.rs b/compiler/rustc_target/src/spec/aarch64_unknown_none_hermitkernel.rs
new file mode 100644
index 00000000000..6e9d6c6221c
--- /dev/null
+++ b/compiler/rustc_target/src/spec/aarch64_unknown_none_hermitkernel.rs
@@ -0,0 +1,16 @@
+use crate::spec::Target;
+
+pub fn target() -> Target {
+    let mut base = super::hermit_kernel_base::opts();
+    base.max_atomic_width = Some(128);
+    base.abi = "softfloat".to_string();
+    base.features = "+strict-align,-neon,-fp-armv8".to_string();
+
+    Target {
+        llvm_target: "aarch64-unknown-hermit".to_string(),
+        pointer_width: 64,
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        arch: "aarch64".to_string(),
+        options: base,
+    }
+}
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 4407f22b905..d735f3d41fd 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -964,6 +964,7 @@ fn $module() {
     ("aarch64-unknown-hermit", aarch64_unknown_hermit),
     ("x86_64-unknown-hermit", x86_64_unknown_hermit),
 
+    ("aarch64-unknown-none-hermitkernel", aarch64_unknown_none_hermitkernel),
     ("x86_64-unknown-none-hermitkernel", x86_64_unknown_none_hermitkernel),
 
     ("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf),
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index 0ad2242f667..aa054043c4e 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -2281,8 +2281,27 @@ pub fn res_to_ty(
                 assert_eq!(opt_self_ty, None);
                 self.prohibit_generics(path.segments);
                 // Try to evaluate any array length constants.
-                let normalized_ty = self.normalize_ty(span, tcx.at(span).type_of(def_id));
-                if forbid_generic && normalized_ty.needs_subst() {
+                let ty = tcx.at(span).type_of(def_id);
+                // HACK(min_const_generics): Forbid generic `Self` types
+                // here as we can't easily do that during nameres.
+                //
+                // We do this before normalization as we otherwise allow
+                // ```rust
+                // trait AlwaysApplicable { type Assoc; }
+                // impl<T: ?Sized> AlwaysApplicable for T { type Assoc = usize; }
+                //
+                // trait BindsParam<T> {
+                //     type ArrayTy;
+                // }
+                // impl<T> BindsParam<T> for <T as AlwaysApplicable>::Assoc {
+                //    type ArrayTy = [u8; Self::MAX];
+                // }
+                // ```
+                // Note that the normalization happens in the param env of
+                // the anon const, which is empty. This is why the
+                // `AlwaysApplicable` impl needs a `T: ?Sized` bound for
+                // this to compile if we were to normalize here.
+                if forbid_generic && ty.needs_subst() {
                     let mut err = tcx.sess.struct_span_err(
                         path.span,
                         "generic `Self` types are currently not permitted in anonymous constants",
@@ -2297,7 +2316,7 @@ pub fn res_to_ty(
                     err.emit();
                     tcx.ty_error()
                 } else {
-                    normalized_ty
+                    self.normalize_ty(span, ty)
                 }
             }
             Res::Def(DefKind::AssocTy, def_id) => {
diff --git a/config.toml.example b/config.toml.example
index 98688ca65b7..ad48cc881f3 100644
--- a/config.toml.example
+++ b/config.toml.example
@@ -157,6 +157,9 @@ changelog-seen = 2
 # Whether to build the clang compiler.
 #clang = false
 
+# Custom CMake defines to set when building LLVM.
+#build-config = {}
+
 # =============================================================================
 # General build configuration options
 # =============================================================================
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index a07071cb6fb..ab9f0b9d737 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -140,7 +140,7 @@
 #![feature(associated_type_bounds)]
 #![feature(box_syntax)]
 #![feature(cfg_sanitize)]
-#![feature(cfg_target_has_atomic)]
+#![cfg_attr(bootstrap, feature(cfg_target_has_atomic))]
 #![feature(const_deref)]
 #![feature(const_fn_trait_bound)]
 #![feature(const_mut_refs)]
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index e52d52e954c..72d8e1b3903 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -155,7 +155,8 @@
 #![feature(allow_internal_unstable)]
 #![feature(associated_type_bounds)]
 #![feature(auto_traits)]
-#![feature(cfg_target_has_atomic)]
+#![cfg_attr(bootstrap, feature(cfg_target_has_atomic))]
+#![cfg_attr(not(bootstrap), feature(cfg_target_has_atomic_equal_alignment))]
 #![feature(const_fn_floating_point_arithmetic)]
 #![feature(const_fn_fn_ptr_basics)]
 #![feature(const_fn_trait_bound)]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index a993def0a81..1c512471c95 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -7,7 +7,7 @@
 #![feature(box_syntax)]
 #![feature(cell_update)]
 #![feature(cfg_panic)]
-#![feature(cfg_target_has_atomic)]
+#![cfg_attr(bootstrap, feature(cfg_target_has_atomic))]
 #![feature(const_assume)]
 #![feature(const_black_box)]
 #![feature(const_bool_to_option)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 4f44a3183a6..2aae29f2154 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -242,7 +242,7 @@
 #![feature(c_variadic)]
 #![feature(cfg_accessible)]
 #![feature(cfg_eval)]
-#![feature(cfg_target_has_atomic)]
+#![cfg_attr(bootstrap, feature(cfg_target_has_atomic))]
 #![feature(cfg_target_thread_local)]
 #![feature(char_error_internals)]
 #![feature(char_internals)]
diff --git a/library/std/src/sys/itron/condvar.rs b/library/std/src/sys/itron/condvar.rs
index dac4b8abfc4..2992a6a5429 100644
--- a/library/std/src/sys/itron/condvar.rs
+++ b/library/std/src/sys/itron/condvar.rs
@@ -15,10 +15,12 @@ unsafe impl Sync for Condvar {}
 pub type MovableCondvar = Condvar;
 
 impl Condvar {
+    #[inline]
     pub const fn new() -> Condvar {
         Condvar { waiters: SpinMutex::new(waiter_queue::WaiterQueue::new()) }
     }
 
+    #[inline]
     pub unsafe fn init(&mut self) {}
 
     pub unsafe fn notify_one(&self) {
@@ -190,7 +192,7 @@ pub unsafe fn insert(&mut self, mut waiter_ptr: NonNull<Waiter>) {
                     let insert_after = {
                         let mut cursor = head.last;
                         loop {
-                            if waiter.priority <= cursor.as_ref().priority {
+                            if waiter.priority >= cursor.as_ref().priority {
                                 // `cursor` and all previous waiters have the same or higher
                                 // priority than `current_task_priority`. Insert the new
                                 // waiter right after `cursor`.
@@ -206,7 +208,7 @@ pub unsafe fn insert(&mut self, mut waiter_ptr: NonNull<Waiter>) {
 
                     if let Some(mut insert_after) = insert_after {
                         // Insert `waiter` after `insert_after`
-                        let insert_before = insert_after.as_ref().prev;
+                        let insert_before = insert_after.as_ref().next;
 
                         waiter.prev = Some(insert_after);
                         insert_after.as_mut().next = Some(waiter_ptr);
@@ -214,6 +216,8 @@ pub unsafe fn insert(&mut self, mut waiter_ptr: NonNull<Waiter>) {
                         waiter.next = insert_before;
                         if let Some(mut insert_before) = insert_before {
                             insert_before.as_mut().prev = Some(waiter_ptr);
+                        } else {
+                            head.last = waiter_ptr;
                         }
                     } else {
                         // Insert `waiter` to the front
@@ -240,11 +244,11 @@ pub unsafe fn remove(&mut self, mut waiter_ptr: NonNull<Waiter>) -> bool {
                     match (waiter.prev, waiter.next) {
                         (Some(mut prev), Some(mut next)) => {
                             prev.as_mut().next = Some(next);
-                            next.as_mut().next = Some(prev);
+                            next.as_mut().prev = Some(prev);
                         }
                         (None, Some(mut next)) => {
                             head.first = next;
-                            next.as_mut().next = None;
+                            next.as_mut().prev = None;
                         }
                         (Some(mut prev), None) => {
                             prev.as_mut().next = None;
@@ -271,6 +275,7 @@ pub unsafe fn is_queued(&self, waiter: NonNull<Waiter>) -> bool {
             unsafe { waiter.as_ref().task != 0 }
         }
 
+        #[inline]
         pub fn pop_front(&mut self) -> Option<abi::ID> {
             unsafe {
                 let head = self.head.as_mut()?;
diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs
index 683cfc630e7..d6f77fe6cd6 100644
--- a/src/bootstrap/config.rs
+++ b/src/bootstrap/config.rs
@@ -108,6 +108,7 @@ pub struct Config {
     pub llvm_polly: bool,
     pub llvm_clang: bool,
     pub llvm_from_ci: bool,
+    pub llvm_build_config: HashMap<String, String>,
 
     pub use_lld: bool,
     pub lld_enabled: bool,
@@ -477,6 +478,7 @@ struct Llvm {
         polly: Option<bool>,
         clang: Option<bool>,
         download_ci_llvm: Option<StringOrBool>,
+        build_config: Option<HashMap<String, String>>,
     }
 }
 
@@ -807,6 +809,7 @@ pub fn parse(args: &[String]) -> Config {
             config.llvm_allow_old_toolchain = llvm.allow_old_toolchain.unwrap_or(false);
             config.llvm_polly = llvm.polly.unwrap_or(false);
             config.llvm_clang = llvm.clang.unwrap_or(false);
+            config.llvm_build_config = llvm.build_config.clone().unwrap_or(Default::default());
             config.llvm_from_ci = match llvm.download_ci_llvm {
                 Some(StringOrBool::String(s)) => {
                     assert!(s == "if-available", "unknown option `{}` for download-ci-llvm", s);
@@ -876,6 +879,7 @@ pub fn parse(args: &[String]) -> Config {
                 check_ci_llvm!(llvm.allow_old_toolchain);
                 check_ci_llvm!(llvm.polly);
                 check_ci_llvm!(llvm.clang);
+                check_ci_llvm!(llvm.build_config);
                 check_ci_llvm!(llvm.plugins);
 
                 // CI-built LLVM can be either dynamic or static.
diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs
index 4a754e6da12..14de1531f73 100644
--- a/src/bootstrap/native.rs
+++ b/src/bootstrap/native.rs
@@ -353,6 +353,10 @@ fn run(self, builder: &Builder<'_>) -> PathBuf {
 
         configure_cmake(builder, target, &mut cfg, true);
 
+        for (key, val) in &builder.config.llvm_build_config {
+            cfg.define(key, val);
+        }
+
         // FIXME: we don't actually need to build all LLVM tools and all LLVM
         //        libraries here, e.g., we just want a few components and a few
         //        tools. Figure out how to filter them down and only build the right
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 2cf26603273..aecd892ce8b 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -17,6 +17,7 @@
     - [aarch64-apple-ios-sim](platform-support/aarch64-apple-ios-sim.md)
     - [armv7-unknown-linux-uclibceabi](platform-support/armv7-unknown-linux-uclibceabi.md)
     - [armv7-unknown-linux-uclibceabihf](platform-support/armv7-unknown-linux-uclibceabihf.md)
+    - [aarch64-unknown-none-hermitkernel](platform-support/aarch64-unknown-none-hermitkernel.md)
     - [\*-kmc-solid_\*](platform-support/kmc-solid.md)
     - [*-unknown-openbsd](platform-support/openbsd.md)
     - [x86_64-unknown-none](platform-support/x86_64-unknown-none.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index b6ae8c9333f..d4a5f0e5a98 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -204,7 +204,8 @@ target | std | host | notes
 `aarch64-apple-tvos` | * |  | ARM64 tvOS
 [`aarch64-kmc-solid_asp3`](platform-support/kmc-solid.md) | ✓ |  | ARM64 SOLID with TOPPERS/ASP3
 `aarch64-unknown-freebsd` | ✓ | ✓ | ARM64 FreeBSD
-`aarch64-unknown-hermit` | ? |  |
+`aarch64-unknown-hermit` | ✓ |  | ARM64 HermitCore
+[`aarch64-unknown-none-hermitkernel`](platform-support/aarch64-unknown-none-hermitkernel.md) | * |  | ARM64 HermitCore kernel
 `aarch64-unknown-uefi` | * |  | ARM64 UEFI
 `aarch64-unknown-linux-gnu_ilp32` | ✓ | ✓ | ARM64 Linux (ILP32 ABI)
 `aarch64-unknown-netbsd` | ✓ | ✓ |
@@ -286,10 +287,10 @@ target | std | host | notes
 `x86_64-sun-solaris` | ? |  | Deprecated target for 64-bit Solaris 10/11, illumos
 `x86_64-unknown-dragonfly` | ✓ | ✓ | 64-bit DragonFlyBSD
 `x86_64-unknown-haiku` | ✓ | ✓ | 64-bit Haiku
-`x86_64-unknown-hermit` | ? |  |
+`x86_64-unknown-hermit` | ✓ |  | HermitCore
 `x86_64-unknown-l4re-uclibc` | ? |  |
 [`x86_64-unknown-none`](platform-support/x86_64-unknown-none.md) | * |  | Freestanding/bare-metal x86_64, softfloat
-`x86_64-unknown-none-hermitkernel` | ? |  | HermitCore kernel
+`x86_64-unknown-none-hermitkernel` | * |  | HermitCore kernel
 `x86_64-unknown-none-linuxkernel` | * |  | Linux kernel modules
 [`x86_64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | 64-bit OpenBSD
 `x86_64-unknown-uefi` | * |  | 64-bit UEFI
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none-hermitkernel.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none-hermitkernel.md
new file mode 100644
index 00000000000..b8967f63187
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none-hermitkernel.md
@@ -0,0 +1,77 @@
+# `aarch64-unknown-none-hermitkernel`
+
+**Tier: 3**
+
+Required to build the kernel for [HermitCore](https://github.com/hermitcore/hermit-playground)
+or [RustyHermit](https://github.com/hermitcore/rusty-hermit).
+The result is a bare-metal aarch64 binary in ELF format.
+
+## Target maintainers
+
+- Stefan Lankes, https://github.com/stlankes
+
+## Requirements
+
+This target is cross-compiled. There is no support for `std`, but the
+library operating system provides a simple allocator to use `alloc`.
+
+By default, Rust code generated for this target does not use any vector or
+floating-point registers. This allows the generated code to build the library
+operaring system, which may need to avoid the use of such
+registers or which may have special considerations about the use of such
+registers (e.g. saving and restoring them to avoid breaking userspace code
+using the same registers). In contrast to `aarch64-unknown-none-softfloat`,
+the target is completly relocatable, which is a required feature of RustyHermit.
+
+By default, code generated with this target should run on any `aarch64`
+hardware; enabling additional target features may raise this baseline.
+On `aarch64-unknown-none-hermitkernel`, `extern "C"` uses the [standard System V calling
+convention](https://github.com/ARM-software/abi-aa/releases/download/2021Q3/sysvabi64.pdf),
+without red zones.
+
+This target generated binaries in the ELF format.
+
+## Building the target
+
+Typical you should not use the target directly. The target `aarch64-unknown-hermit`
+builds the _user space_ of RustyHermit and supports red zones and floating-point
+operations.
+To build and link the kernel to the application, the crate
+[hermit-sys](https://github.com/hermitcore/rusty-hermit/tree/master/hermit-sys)
+should be used by adding the following lines to the `Cargo.toml` file of
+your application.
+
+```toml
+[target.'cfg(target_os = "hermit")'.dependencies]
+hermit-sys = "0.1.*"
+```
+
+The crate `hermit-sys` uses the target `aarch64-unknown-none-hermitkernel`
+to build the kernel.
+
+## Building Rust programs
+
+Rust does not yet ship pre-compiled artifacts for this target. To compile for
+this target, you need to build the crate `hermit-sys` (see
+"Building the target" above).
+
+## Testing
+
+As `aarch64-unknown-none-hermitkernel` does not support `std`
+and does not support running any Rust testsuite.
+
+## Cross-compilation toolchains and C code
+
+If you want to compile C code along with Rust you will need an
+appropriate `aarch64` toolchain.
+
+Rust *may* be able to use an `aarch64-linux-gnu-` toolchain with appropriate
+standalone flags to build for this toolchain (depending on the assumptions of
+that toolchain, see below), or you may wish to use a separate
+`aarch64-unknown-none` (or `aarch64-elf-`) toolchain.
+
+On some `aarch64` hosts that use ELF binaries, you *may* be able to use the host
+C toolchain, if it does not introduce assumptions about the host environment
+that don't match the expectations of a standalone environment. Otherwise, you
+may need a separate toolchain for standalone/freestanding development, just as
+when cross-compiling from a non-`aarch64` platform.
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index a40181352f6..1c0448828a2 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -565,7 +565,7 @@ fn next(&mut self) -> Option<Self::Item> {
             self.buf.push_back((Event::Html(format!("</a></h{}>", level).into()), 0..0));
 
             let start_tags = format!(
-                "<h{level} id=\"{id}\" class=\"section-header\">\
+                "<h{level} id=\"{id}\">\
                     <a href=\"#{id}\">",
                 id = id,
                 level = level
diff --git a/src/librustdoc/html/markdown/tests.rs b/src/librustdoc/html/markdown/tests.rs
index ea6575d179d..5c0bf0ed942 100644
--- a/src/librustdoc/html/markdown/tests.rs
+++ b/src/librustdoc/html/markdown/tests.rs
@@ -159,25 +159,22 @@ fn t(input: &str, expect: &str) {
         assert_eq!(output, expect, "original: {}", input);
     }
 
-    t(
-        "# Foo bar",
-        "<h2 id=\"foo-bar\" class=\"section-header\"><a href=\"#foo-bar\">Foo bar</a></h2>",
-    );
+    t("# Foo bar", "<h2 id=\"foo-bar\"><a href=\"#foo-bar\">Foo bar</a></h2>");
     t(
         "## Foo-bar_baz qux",
-        "<h3 id=\"foo-bar_baz-qux\" class=\"section-header\">\
+        "<h3 id=\"foo-bar_baz-qux\">\
          <a href=\"#foo-bar_baz-qux\">Foo-bar_baz qux</a></h3>",
     );
     t(
         "### **Foo** *bar* baz!?!& -_qux_-%",
-        "<h4 id=\"foo-bar-baz--qux-\" class=\"section-header\">\
+        "<h4 id=\"foo-bar-baz--qux-\">\
             <a href=\"#foo-bar-baz--qux-\"><strong>Foo</strong> \
             <em>bar</em> baz!?!&amp; -<em>qux</em>-%</a>\
          </h4>",
     );
     t(
         "#### **Foo?** & \\*bar?!*  _`baz`_ ❤ #qux",
-        "<h5 id=\"foo--bar--baz--qux\" class=\"section-header\">\
+        "<h5 id=\"foo--bar--baz--qux\">\
              <a href=\"#foo--bar--baz--qux\"><strong>Foo?</strong> &amp; *bar?!*  \
              <em><code>baz</code></em> ❤ #qux</a>\
          </h5>",
@@ -201,36 +198,12 @@ fn t(map: &mut IdMap, input: &str, expect: &str) {
         assert_eq!(output, expect, "original: {}", input);
     }
 
-    t(
-        &mut map,
-        "# Example",
-        "<h2 id=\"example\" class=\"section-header\"><a href=\"#example\">Example</a></h2>",
-    );
-    t(
-        &mut map,
-        "# Panics",
-        "<h2 id=\"panics\" class=\"section-header\"><a href=\"#panics\">Panics</a></h2>",
-    );
-    t(
-        &mut map,
-        "# Example",
-        "<h2 id=\"example-1\" class=\"section-header\"><a href=\"#example-1\">Example</a></h2>",
-    );
-    t(
-        &mut map,
-        "# Search",
-        "<h2 id=\"search-1\" class=\"section-header\"><a href=\"#search-1\">Search</a></h2>",
-    );
-    t(
-        &mut map,
-        "# Example",
-        "<h2 id=\"example-2\" class=\"section-header\"><a href=\"#example-2\">Example</a></h2>",
-    );
-    t(
-        &mut map,
-        "# Panics",
-        "<h2 id=\"panics-1\" class=\"section-header\"><a href=\"#panics-1\">Panics</a></h2>",
-    );
+    t(&mut map, "# Example", "<h2 id=\"example\"><a href=\"#example\">Example</a></h2>");
+    t(&mut map, "# Panics", "<h2 id=\"panics\"><a href=\"#panics\">Panics</a></h2>");
+    t(&mut map, "# Example", "<h2 id=\"example-1\"><a href=\"#example-1\">Example</a></h2>");
+    t(&mut map, "# Search", "<h2 id=\"search-1\"><a href=\"#search-1\">Search</a></h2>");
+    t(&mut map, "# Example", "<h2 id=\"example-2\"><a href=\"#example-2\">Example</a></h2>");
+    t(&mut map, "# Panics", "<h2 id=\"panics-1\"><a href=\"#panics-1\">Panics</a></h2>");
 }
 
 #[test]
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index f3e65df6b14..1c3f9b56b47 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -2402,33 +2402,156 @@ fn sidebar_enum(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, e: &clean:
     }
 }
 
-fn item_ty_to_strs(ty: ItemType) -> (&'static str, &'static str) {
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+enum ItemSection {
+    Reexports,
+    PrimitiveTypes,
+    Modules,
+    Macros,
+    Structs,
+    Enums,
+    Constants,
+    Statics,
+    Traits,
+    Functions,
+    TypeDefinitions,
+    Unions,
+    Implementations,
+    TypeMethods,
+    Methods,
+    StructFields,
+    Variants,
+    AssociatedTypes,
+    AssociatedConstants,
+    ForeignTypes,
+    Keywords,
+    OpaqueTypes,
+    AttributeMacros,
+    DeriveMacros,
+    TraitAliases,
+}
+
+impl ItemSection {
+    const ALL: &'static [Self] = {
+        use ItemSection::*;
+        // NOTE: The order here affects the order in the UI.
+        &[
+            Reexports,
+            PrimitiveTypes,
+            Modules,
+            Macros,
+            Structs,
+            Enums,
+            Constants,
+            Statics,
+            Traits,
+            Functions,
+            TypeDefinitions,
+            Unions,
+            Implementations,
+            TypeMethods,
+            Methods,
+            StructFields,
+            Variants,
+            AssociatedTypes,
+            AssociatedConstants,
+            ForeignTypes,
+            Keywords,
+            OpaqueTypes,
+            AttributeMacros,
+            DeriveMacros,
+            TraitAliases,
+        ]
+    };
+
+    fn id(self) -> &'static str {
+        match self {
+            Self::Reexports => "reexports",
+            Self::Modules => "modules",
+            Self::Structs => "structs",
+            Self::Unions => "unions",
+            Self::Enums => "enums",
+            Self::Functions => "functions",
+            Self::TypeDefinitions => "types",
+            Self::Statics => "statics",
+            Self::Constants => "constants",
+            Self::Traits => "traits",
+            Self::Implementations => "impls",
+            Self::TypeMethods => "tymethods",
+            Self::Methods => "methods",
+            Self::StructFields => "fields",
+            Self::Variants => "variants",
+            Self::Macros => "macros",
+            Self::PrimitiveTypes => "primitives",
+            Self::AssociatedTypes => "associated-types",
+            Self::AssociatedConstants => "associated-consts",
+            Self::ForeignTypes => "foreign-types",
+            Self::Keywords => "keywords",
+            Self::OpaqueTypes => "opaque-types",
+            Self::AttributeMacros => "attributes",
+            Self::DeriveMacros => "derives",
+            Self::TraitAliases => "trait-aliases",
+        }
+    }
+
+    fn name(self) -> &'static str {
+        match self {
+            Self::Reexports => "Re-exports",
+            Self::Modules => "Modules",
+            Self::Structs => "Structs",
+            Self::Unions => "Unions",
+            Self::Enums => "Enums",
+            Self::Functions => "Functions",
+            Self::TypeDefinitions => "Type Definitions",
+            Self::Statics => "Statics",
+            Self::Constants => "Constants",
+            Self::Traits => "Traits",
+            Self::Implementations => "Implementations",
+            Self::TypeMethods => "Type Methods",
+            Self::Methods => "Methods",
+            Self::StructFields => "Struct Fields",
+            Self::Variants => "Variants",
+            Self::Macros => "Macros",
+            Self::PrimitiveTypes => "Primitive Types",
+            Self::AssociatedTypes => "Associated Types",
+            Self::AssociatedConstants => "Associated Constants",
+            Self::ForeignTypes => "Foreign Types",
+            Self::Keywords => "Keywords",
+            Self::OpaqueTypes => "Opaque Types",
+            Self::AttributeMacros => "Attribute Macros",
+            Self::DeriveMacros => "Derive Macros",
+            Self::TraitAliases => "Trait Aliases",
+        }
+    }
+}
+
+fn item_ty_to_section(ty: ItemType) -> ItemSection {
     match ty {
-        ItemType::ExternCrate | ItemType::Import => ("reexports", "Re-exports"),
-        ItemType::Module => ("modules", "Modules"),
-        ItemType::Struct => ("structs", "Structs"),
-        ItemType::Union => ("unions", "Unions"),
-        ItemType::Enum => ("enums", "Enums"),
-        ItemType::Function => ("functions", "Functions"),
-        ItemType::Typedef => ("types", "Type Definitions"),
-        ItemType::Static => ("statics", "Statics"),
-        ItemType::Constant => ("constants", "Constants"),
-        ItemType::Trait => ("traits", "Traits"),
-        ItemType::Impl => ("impls", "Implementations"),
-        ItemType::TyMethod => ("tymethods", "Type Methods"),
-        ItemType::Method => ("methods", "Methods"),
-        ItemType::StructField => ("fields", "Struct Fields"),
-        ItemType::Variant => ("variants", "Variants"),
-        ItemType::Macro => ("macros", "Macros"),
-        ItemType::Primitive => ("primitives", "Primitive Types"),
-        ItemType::AssocType => ("associated-types", "Associated Types"),
-        ItemType::AssocConst => ("associated-consts", "Associated Constants"),
-        ItemType::ForeignType => ("foreign-types", "Foreign Types"),
-        ItemType::Keyword => ("keywords", "Keywords"),
-        ItemType::OpaqueTy => ("opaque-types", "Opaque Types"),
-        ItemType::ProcAttribute => ("attributes", "Attribute Macros"),
-        ItemType::ProcDerive => ("derives", "Derive Macros"),
-        ItemType::TraitAlias => ("trait-aliases", "Trait aliases"),
+        ItemType::ExternCrate | ItemType::Import => ItemSection::Reexports,
+        ItemType::Module => ItemSection::Modules,
+        ItemType::Struct => ItemSection::Structs,
+        ItemType::Union => ItemSection::Unions,
+        ItemType::Enum => ItemSection::Enums,
+        ItemType::Function => ItemSection::Functions,
+        ItemType::Typedef => ItemSection::TypeDefinitions,
+        ItemType::Static => ItemSection::Statics,
+        ItemType::Constant => ItemSection::Constants,
+        ItemType::Trait => ItemSection::Traits,
+        ItemType::Impl => ItemSection::Implementations,
+        ItemType::TyMethod => ItemSection::TypeMethods,
+        ItemType::Method => ItemSection::Methods,
+        ItemType::StructField => ItemSection::StructFields,
+        ItemType::Variant => ItemSection::Variants,
+        ItemType::Macro => ItemSection::Macros,
+        ItemType::Primitive => ItemSection::PrimitiveTypes,
+        ItemType::AssocType => ItemSection::AssociatedTypes,
+        ItemType::AssocConst => ItemSection::AssociatedConstants,
+        ItemType::ForeignType => ItemSection::ForeignTypes,
+        ItemType::Keyword => ItemSection::Keywords,
+        ItemType::OpaqueTy => ItemSection::OpaqueTypes,
+        ItemType::ProcAttribute => ItemSection::AttributeMacros,
+        ItemType::ProcDerive => ItemSection::DeriveMacros,
+        ItemType::TraitAlias => ItemSection::TraitAliases,
         ItemType::Generic => unreachable!(),
     }
 }
@@ -2436,44 +2559,13 @@ fn item_ty_to_strs(ty: ItemType) -> (&'static str, &'static str) {
 fn sidebar_module(buf: &mut Buffer, items: &[clean::Item]) {
     let mut sidebar = String::new();
 
-    // Re-exports are handled a bit differently because they can be extern crates or imports.
-    if items.iter().any(|it| {
-        it.name.is_some()
-            && (it.type_() == ItemType::ExternCrate
-                || (it.type_() == ItemType::Import && !it.is_stripped()))
-    }) {
-        let (id, name) = item_ty_to_strs(ItemType::Import);
-        sidebar.push_str(&format!("<li><a href=\"#{}\">{}</a></li>", id, name));
-    }
-
-    // ordering taken from item_module, reorder, where it prioritized elements in a certain order
-    // to print its headings
-    for &myty in &[
-        ItemType::Primitive,
-        ItemType::Module,
-        ItemType::Macro,
-        ItemType::Struct,
-        ItemType::Enum,
-        ItemType::Constant,
-        ItemType::Static,
-        ItemType::Trait,
-        ItemType::Function,
-        ItemType::Typedef,
-        ItemType::Union,
-        ItemType::Impl,
-        ItemType::TyMethod,
-        ItemType::Method,
-        ItemType::StructField,
-        ItemType::Variant,
-        ItemType::AssocType,
-        ItemType::AssocConst,
-        ItemType::ForeignType,
-        ItemType::Keyword,
-    ] {
-        if items.iter().any(|it| !it.is_stripped() && it.type_() == myty && it.name.is_some()) {
-            let (id, name) = item_ty_to_strs(myty);
-            sidebar.push_str(&format!("<li><a href=\"#{}\">{}</a></li>", id, name));
-        }
+    let item_sections_in_use: FxHashSet<_> = items
+        .iter()
+        .filter(|it| !it.is_stripped() && it.name.is_some())
+        .map(|it| item_ty_to_section(it.type_()))
+        .collect();
+    for &sec in ItemSection::ALL.iter().filter(|sec| item_sections_in_use.contains(sec)) {
+        sidebar.push_str(&format!("<li><a href=\"#{}\">{}</a></li>", sec.id(), sec.name()));
     }
 
     if !sidebar.is_empty() {
@@ -2567,7 +2659,7 @@ fn render_call_locations(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item) {
         w,
         "<div class=\"docblock scraped-example-list\">\
           <span></span>\
-          <h5 id=\"{id}\" class=\"section-header\">\
+          <h5 id=\"{id}\">\
              <a href=\"#{id}\">Examples found in repository</a>\
           </h5>",
         id = id
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 6592a56ba46..2ae7626b886 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -16,10 +16,10 @@
 use rustc_target::abi::{Layout, Primitive, TagEncoding, Variants};
 
 use super::{
-    collect_paths_for_type, document, ensure_trailing_slash, item_ty_to_strs, notable_traits_decl,
-    render_assoc_item, render_assoc_items, render_attributes_in_code, render_attributes_in_pre,
-    render_impl, render_stability_since_raw, write_srclink, AssocItemLink, Context,
-    ImplRenderingParameters,
+    collect_paths_for_type, document, ensure_trailing_slash, item_ty_to_section,
+    notable_traits_decl, render_assoc_item, render_assoc_items, render_attributes_in_code,
+    render_attributes_in_pre, render_impl, render_stability_since_raw, write_srclink,
+    AssocItemLink, Context, ImplRenderingParameters,
 };
 use crate::clean;
 use crate::formats::item_type::ItemType;
@@ -221,7 +221,9 @@ fn cmp(
     ) -> Ordering {
         let ty1 = i1.type_();
         let ty2 = i2.type_();
-        if ty1 != ty2 {
+        if item_ty_to_section(ty1) != item_ty_to_section(ty2)
+            || (ty1 != ty2 && (ty1 == ItemType::ExternCrate || ty2 == ItemType::ExternCrate))
+        {
             return (reorder(ty1), idx1).cmp(&(reorder(ty2), idx2));
         }
         let s1 = i1.stability(tcx).as_ref().map(|s| s.level);
@@ -270,7 +272,7 @@ fn cmp(
     });
 
     debug!("{:?}", indices);
-    let mut curty = None;
+    let mut last_section = None;
 
     for &idx in &indices {
         let myitem = &items[idx];
@@ -278,24 +280,20 @@ fn cmp(
             continue;
         }
 
-        let myty = Some(myitem.type_());
-        if curty == Some(ItemType::ExternCrate) && myty == Some(ItemType::Import) {
-            // Put `extern crate` and `use` re-exports in the same section.
-            curty = myty;
-        } else if myty != curty {
-            if curty.is_some() {
+        let my_section = item_ty_to_section(myitem.type_());
+        if Some(my_section) != last_section {
+            if last_section.is_some() {
                 w.write_str(ITEM_TABLE_CLOSE);
             }
-            curty = myty;
-            let (short, name) = item_ty_to_strs(myty.unwrap());
+            last_section = Some(my_section);
             write!(
                 w,
                 "<h2 id=\"{id}\" class=\"small-section-header\">\
                     <a href=\"#{id}\">{name}</a>\
                  </h2>\n{}",
                 ITEM_TABLE_OPEN,
-                id = cx.derive_id(short.to_owned()),
-                name = name
+                id = cx.derive_id(my_section.id().to_owned()),
+                name = my_section.name(),
             );
         }
 
@@ -407,7 +405,7 @@ fn cmp(
         }
     }
 
-    if curty.is_some() {
+    if last_section.is_some() {
         w.write_str(ITEM_TABLE_CLOSE);
     }
 }
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 04112c9779b..78e7c97d71d 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1141,16 +1141,6 @@ a.test-arrow {
 a.test-arrow:hover{
 	text-decoration: none;
 }
-.section-header:hover a:before {
-	position: absolute;
-	left: -25px;
-	padding-right: 10px; /* avoid gap that causes hover to disappear */
-	content: '\2002\00a7\2002';
-}
-
-.section-header:hover a {
-	text-decoration: none;
-}
 
 .code-attribute {
 	font-weight: 300;
@@ -1196,17 +1186,6 @@ h3.variant {
 	margin-top: 3px;
 }
 
-.top-doc .docblock > .section-header:first-child {
-	margin-left: 15px;
-}
-.top-doc .docblock > .section-header:first-child:hover > a:before {
-	left: -10px;
-}
-
-.docblock > .section-header:first-child {
-	margin-top: 0;
-}
-
 :target > code, :target > .code-header {
 	opacity: 1;
 }
diff --git a/src/test/run-make-fulldeps/atomic-lock-free/atomic_lock_free.rs b/src/test/run-make-fulldeps/atomic-lock-free/atomic_lock_free.rs
index bc7951a04da..e9b28504a90 100644
--- a/src/test/run-make-fulldeps/atomic-lock-free/atomic_lock_free.rs
+++ b/src/test/run-make-fulldeps/atomic-lock-free/atomic_lock_free.rs
@@ -1,4 +1,4 @@
-#![feature(cfg_target_has_atomic, no_core, intrinsics, lang_items)]
+#![feature(no_core, intrinsics, lang_items)]
 #![crate_type="rlib"]
 #![no_core]
 
diff --git a/src/test/rustdoc-gui/anchors.goml b/src/test/rustdoc-gui/anchors.goml
index 26e4503a5d0..ddfb23a4f86 100644
--- a/src/test/rustdoc-gui/anchors.goml
+++ b/src/test/rustdoc-gui/anchors.goml
@@ -31,46 +31,4 @@ assert-css: ("h2#implementations a.anchor", {"color": "rgb(0, 0, 0)"})
 move-cursor-to: "#impl"
 assert-css: ("#impl a.anchor", {"color": "rgb(0, 0, 0)"})
 
-// Now we check the positions: only the first heading of the top doc comment should
-// have a different position.
-move-cursor-to: ".top-doc .docblock .section-header:first-child"
-assert-css: (
-    ".top-doc .docblock .section-header:first-child > a::before",
-    {"left": "-10px", "padding-right": "10px"},
-)
-// We also check that the heading itself has a different indent.
-assert-css: (".top-doc .docblock .section-header:first-child", {"margin-left": "15px"})
-
-move-cursor-to: ".top-doc .docblock .section-header:not(:first-child)"
-assert-css: (
-    ".top-doc .docblock .section-header:not(:first-child) > a::before",
-    {"left": "-25px", "padding-right": "10px"},
-)
-assert-css: (".top-doc .docblock .section-header:not(:first-child)", {"margin-left": "0px"})
-
-// Now let's check some other docblock headings...
-// First the impl block docs.
-move-cursor-to: "#title-for-struct-impl-doc"
-assert-css: (
-    "#title-for-struct-impl-doc > a::before",
-    {"left": "-25px", "padding-right": "10px"},
-)
-assert-css: ("#title-for-struct-impl-doc", {"margin-left": "0px"})
-// Now a method docs.
-move-cursor-to: "#title-for-struct-impl-item-doc"
-assert-css: (
-    "#title-for-struct-impl-item-doc > a::before",
-    {"left": "-25px", "padding-right": "10px"},
-)
 assert-css: ("#title-for-struct-impl-item-doc", {"margin-left": "0px"})
-
-// Finally, we want to ensure that if the first element of the doc block isn't a heading,
-// if there is a heading afterwards, it won't have the indent.
-goto: file://|DOC_PATH|/test_docs/enum.WhoLetTheDogOut.html
-
-move-cursor-to: ".top-doc .docblock .section-header"
-assert-css: (
-    ".top-doc .docblock .section-header > a::before",
-    {"left": "-25px", "padding-right": "10px"},
-)
-assert-css: (".top-doc .docblock .section-header", {"margin-left": "0px"})
diff --git a/src/test/rustdoc-gui/headers-color.goml b/src/test/rustdoc-gui/headers-color.goml
index d58ca13a629..cf9caa2d586 100644
--- a/src/test/rustdoc-gui/headers-color.goml
+++ b/src/test/rustdoc-gui/headers-color.goml
@@ -40,7 +40,8 @@ goto: file://|DOC_PATH|/test_docs/index.html
 assert-css: (".small-section-header a", {"color": "rgb(197, 197, 197)"}, ALL)
 
 goto: file://|DOC_PATH|/test_docs/struct.HeavilyDocumentedStruct.html
-assert-css: (".section-header a", {"color": "rgb(57, 175, 215)"}, ALL)
+// We select headings (h2, h3, h...).
+assert-css: (".docblock > :not(p) > a", {"color": "rgb(57, 175, 215)"}, ALL)
 
 // Dark theme
 local-storage: {
@@ -78,7 +79,8 @@ goto: file://|DOC_PATH|/test_docs/index.html
 assert-css: (".small-section-header a", {"color": "rgb(221, 221, 221)"}, ALL)
 
 goto: file://|DOC_PATH|/test_docs/struct.HeavilyDocumentedStruct.html
-assert-css: (".section-header a", {"color": "rgb(210, 153, 29)"}, ALL)
+// We select headings (h2, h3, h...).
+assert-css: (".docblock > :not(p) > a", {"color": "rgb(210, 153, 29)"}, ALL)
 
 // Light theme
 local-storage: {"rustdoc-theme": "light", "rustdoc-use-system-theme": "false"}
@@ -111,4 +113,5 @@ goto: file://|DOC_PATH|/test_docs/index.html
 assert-css: (".small-section-header a", {"color": "rgb(0, 0, 0)"}, ALL)
 
 goto: file://|DOC_PATH|/test_docs/struct.HeavilyDocumentedStruct.html
-assert-css: (".section-header a", {"color": "rgb(56, 115, 173)"}, ALL)
+// We select headings (h2, h3, h...).
+assert-css: (".docblock > :not(p) > a", {"color": "rgb(56, 115, 173)"}, ALL)
diff --git a/src/test/rustdoc/trait_alias.rs b/src/test/rustdoc/trait_alias.rs
index dec7fe3f6a5..a0c657d9a05 100644
--- a/src/test/rustdoc/trait_alias.rs
+++ b/src/test/rustdoc/trait_alias.rs
@@ -8,7 +8,7 @@
 // @has foo/all.html '//a[@href="traitalias.Alias2.html"]' 'Alias2'
 // @has foo/all.html '//a[@href="traitalias.Foo.html"]' 'Foo'
 
-// @has foo/index.html '//h2[@id="trait-aliases"]' 'Trait aliases'
+// @has foo/index.html '//h2[@id="trait-aliases"]' 'Trait Aliases'
 // @has foo/index.html '//a[@class="traitalias"]' 'CopyAlias'
 // @has foo/index.html '//a[@class="traitalias"]' 'Alias2'
 // @has foo/index.html '//a[@class="traitalias"]' 'Foo'
diff --git a/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.rs b/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.rs
new file mode 100644
index 00000000000..e1cf7b579aa
--- /dev/null
+++ b/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.rs
@@ -0,0 +1,15 @@
+trait AlwaysApplicable {
+    type Assoc;
+}
+impl<T: ?Sized> AlwaysApplicable for T {
+    type Assoc = usize;
+}
+
+trait BindsParam<T> {
+    type ArrayTy;
+}
+impl<T> BindsParam<T> for <T as AlwaysApplicable>::Assoc {
+    type ArrayTy = [u8; Self::MAX]; //~ ERROR generic `Self` types
+}
+
+fn main() {}
diff --git a/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr b/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr
new file mode 100644
index 00000000000..bda88597006
--- /dev/null
+++ b/src/test/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr
@@ -0,0 +1,14 @@
+error: generic `Self` types are currently not permitted in anonymous constants
+  --> $DIR/forbid-self-no-normalize.rs:12:25
+   |
+LL |     type ArrayTy = [u8; Self::MAX];
+   |                         ^^^^
+   |
+note: not a concrete type
+  --> $DIR/forbid-self-no-normalize.rs:11:27
+   |
+LL | impl<T> BindsParam<T> for <T as AlwaysApplicable>::Assoc {
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.rs b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.rs
new file mode 100644
index 00000000000..3d692a07001
--- /dev/null
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.rs
@@ -0,0 +1,14 @@
+fn main() {
+    cfg!(target_has_atomic_equal_alignment = "8");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+    cfg!(target_has_atomic_equal_alignment = "16");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+    cfg!(target_has_atomic_equal_alignment = "32");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+    cfg!(target_has_atomic_equal_alignment = "64");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+    cfg!(target_has_atomic_equal_alignment = "128");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+    cfg!(target_has_atomic_equal_alignment = "ptr");
+    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+}
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.stderr b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.stderr
new file mode 100644
index 00000000000..8ad3b034aa5
--- /dev/null
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.stderr
@@ -0,0 +1,57 @@
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:2:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "8");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:4:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "16");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:6:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "32");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:8:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "64");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:10:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "128");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-target-has-atomic-equal-alignment.rs:12:10
+   |
+LL |     cfg!(target_has_atomic_equal_alignment = "ptr");
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93822 <https://github.com/rust-lang/rust/issues/93822> for more information
+   = help: add `#![feature(cfg_target_has_atomic_equal_alignment)]` to the crate attributes to enable
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs
deleted file mode 100644
index 049fdd84d8c..00000000000
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-#![feature(intrinsics, lang_items, no_core, rustc_attrs)]
-
-#![crate_type="rlib"]
-#![no_core]
-
-extern "rust-intrinsic" {
-    fn atomic_xadd<T>(dst: *mut T, src: T) -> T;
-}
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-#[cfg(target_has_atomic = "8")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_u8(x: *mut u8) {
-    atomic_xadd(x, 1);
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "8")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_i8(x: *mut i8) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "16")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_u16(x: *mut u16) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "16")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_i16(x: *mut i16) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "32")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_u32(x: *mut u32) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "32")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_i32(x: *mut i32) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "64")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_u64(x: *mut u64) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "64")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_i64(x: *mut i64) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "128")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_u128(x: *mut u128) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "128")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_i128(x: *mut i128) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "ptr")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_usize(x: *mut usize) {
-    atomic_xadd(x, 1);
-}
-#[cfg(target_has_atomic = "ptr")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-pub unsafe fn atomic_isize(x: *mut isize) {
-    atomic_xadd(x, 1);
-}
-
-fn main() {
-    cfg!(target_has_atomic = "8");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic = "16");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic = "32");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic = "64");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic = "128");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic = "ptr");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "8");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "16");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "32");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "64");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "128");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_load_store = "ptr");
-    //~^ ERROR `cfg(target_has_atomic_load_store)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "8");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "16");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "32");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "64");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "128");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-    cfg!(target_has_atomic_equal_alignment = "ptr");
-    //~^ ERROR `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-}
-
-#[macro_export]
-#[rustc_builtin_macro]
-macro_rules! cfg { () => () }
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr
deleted file mode 100644
index 16e1dc64400..00000000000
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr
+++ /dev/null
@@ -1,273 +0,0 @@
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:15:7
-   |
-LL | #[cfg(target_has_atomic = "8")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:21:7
-   |
-LL | #[cfg(target_has_atomic = "8")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:26:7
-   |
-LL | #[cfg(target_has_atomic = "16")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:31:7
-   |
-LL | #[cfg(target_has_atomic = "16")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:36:7
-   |
-LL | #[cfg(target_has_atomic = "32")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:41:7
-   |
-LL | #[cfg(target_has_atomic = "32")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:46:7
-   |
-LL | #[cfg(target_has_atomic = "64")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:51:7
-   |
-LL | #[cfg(target_has_atomic = "64")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:56:7
-   |
-LL | #[cfg(target_has_atomic = "128")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:61:7
-   |
-LL | #[cfg(target_has_atomic = "128")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:66:7
-   |
-LL | #[cfg(target_has_atomic = "ptr")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:71:7
-   |
-LL | #[cfg(target_has_atomic = "ptr")]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:78:10
-   |
-LL |     cfg!(target_has_atomic = "8");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:80:10
-   |
-LL |     cfg!(target_has_atomic = "16");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:82:10
-   |
-LL |     cfg!(target_has_atomic = "32");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:84:10
-   |
-LL |     cfg!(target_has_atomic = "64");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:86:10
-   |
-LL |     cfg!(target_has_atomic = "128");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:88:10
-   |
-LL |     cfg!(target_has_atomic = "ptr");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:90:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "8");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:92:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "16");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:94:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "32");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:96:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "64");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:98:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "128");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_load_store)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:100:10
-   |
-LL |     cfg!(target_has_atomic_load_store = "ptr");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:102:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "8");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:104:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "16");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:106:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "32");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:108:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "64");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:110:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "128");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error[E0658]: `cfg(target_has_atomic_equal_alignment)` is experimental and subject to change
-  --> $DIR/feature-gate-cfg-target-has-atomic.rs:112:10
-   |
-LL |     cfg!(target_has_atomic_equal_alignment = "ptr");
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #32976 <https://github.com/rust-lang/rust/issues/32976> for more information
-   = help: add `#![feature(cfg_target_has_atomic)]` to the crate attributes to enable
-
-error: aborting due to 30 previous errors
-
-For more information about this error, try `rustc --explain E0658`.