Unrolled build for #163742 in rollup 163767

Rollup merge of #163742 - jlpetz:movdir64b-target-feature, r=folkertdev

Add the `movdir64b` and `movdiri` x86 target features

Adds the unstable `movdir64b` and `movdiri` x86 target features, gated behind `#![feature(movdir64b_target_feature)]` and `#![feature(movdiri_target_feature)]`, and runtime detection with `is_x86_feature_detected!("movdir64b")` / `is_x86_feature_detected!("movdiri")` (CPUID.(EAX=7,ECX=0):ECX[28] and ECX[27]).

`MOVDIR64B` moves 64 bytes from memory to a 64-byte aligned destination as a single direct store; `MOVDIRI` stores a 32- or 64-bit integer as a direct store. Both are on Intel Tiger Lake / Alder Lake and later, Sapphire Rapids and later Xeons, and AMD Zen 5. They're standalone CPUID features that aren't part of any psABI microarchitecture level, so they need their own feature flags.

**This is the compiler half of a two-PR feature, like `clflushopt` in #157098.** The `_movdir64b`, `_directstoreu_u32` and `_directstoreu_u64` intrinsics (rust-lang/stdarch#2239) can't compile until these target features exist, so the stdarch PR is blocked on this one merging and syncing into stdarch's pinned toolchain.

- Tracking issue: #163741
- Unblocks intrinsics: rust-lang/stdarch#2239

Today the only way to emit these instructions from Rust is `asm!`, which also hides them from LLVM: a copy loop through `llvm.x86.movdir64b` gets unrolled and the source address becomes a displacement, while the `asm!` version stays one instruction per iteration with both addresses in registers.

`movdir64b` and `movdiri` are LLVM's feature names, so they map 1:1 through `to_llvm_features` with no remap entry. I ran the two new feature-gate tests, `check-cfg/target_feature` and `target-feature/invalid-attribute`, the std_detect tests (which report both features as `true` on a Xeon 6975P-C), and tidy locally on x86_64-pc-windows-msvc.

r? @folkertdev

Author: bors

compiler/rustc_feature/src/unstable.rs

@@ -641,6 +641,10 @@ declare_features! (
     (unstable, mips_target_feature, "1.27.0", Some(150253)),
     /// Allows qualified paths in struct expressions, struct patterns and tuple struct patterns.
     (unstable, more_qualified_paths, "1.54.0", Some(86935)),
+    /// The `movdir64b` target feature on x86.
+    (unstable, movdir64b_target_feature, "CURRENT_RUSTC_VERSION", Some(163741)),
+    /// The `movdiri` target feature on x86.
+    (unstable, movdiri_target_feature, "CURRENT_RUSTC_VERSION", Some(163741)),
     /// Allows `move(expr)` in closures.
     (incomplete, move_expr, "1.97.0", Some(155050)),
     /// The `movrs` target feature on x86.

compiler/rustc_span/src/symbol.rs

@@ -1402,6 +1402,8 @@ symbols! {
         more_qualified_paths,
         more_struct_aliases,
         movbe_target_feature,
+        movdir64b_target_feature,
+        movdiri_target_feature,
         move_expr,
         move_ref_pattern,
         move_size_limit,

compiler/rustc_target/src/target_features.rs

@@ -496,6 +496,8 @@ static X86_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("lahfsahf", Unstable(sym::lahfsahf_target_feature), &[]),
     ("lzcnt", Stable, &[]),
     ("movbe", Stable, &[]),
+    ("movdir64b", Unstable(sym::movdir64b_target_feature), &[]),
+    ("movdiri", Unstable(sym::movdiri_target_feature), &[]),
     ("movrs", Unstable(sym::movrs_target_feature), &[]),
     ("pclmulqdq", Stable, &["sse2"]),
     ("popcnt", Stable, &[]),

library/std_detect/src/detect/arch/x86.rs

@@ -111,6 +111,8 @@ features! {
     /// * `"adx"`
     /// * `"rtm"`
     /// * `"movbe"`
+    /// * `"movdir64b"`
+    /// * `"movdiri"`
     /// * `"ermsb"`
     /// * `"movrs"`
     /// * `"xop"`
@@ -271,6 +273,10 @@ features! {
     /// RTM, Intel (Restricted Transactional Memory)
     @FEATURE: #[stable(feature = "movbe_target_feature", since = "1.67.0")] movbe: "movbe";
     /// MOVBE (Move Data After Swapping Bytes)
+    @FEATURE: #[unstable(feature = "movdir64b_target_feature", issue = "163741")] movdir64b: "movdir64b";
+    /// MOVDIR64B (Move 64 Bytes as Direct Store)
+    @FEATURE: #[unstable(feature = "movdiri_target_feature", issue = "163741")] movdiri: "movdiri";
+    /// MOVDIRI (Move Doubleword as Direct Store)
     @FEATURE: #[unstable(feature = "movrs_target_feature", issue = "137976")] movrs: "movrs";
     /// MOVRS (Move data with the read-shared hint)
     @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] ermsb: "ermsb";

library/std_detect/src/detect/os/x86.rs

@@ -121,6 +121,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
         enable(extended_features_ecx, 8, Feature::gfni);
         enable(extended_features_ecx, 9, Feature::vaes);
         enable(extended_features_ecx, 10, Feature::vpclmulqdq);
+        enable(extended_features_ecx, 27, Feature::movdiri);
+        enable(extended_features_ecx, 28, Feature::movdir64b);
 
         enable(extended_features_ebx, 3, Feature::bmi1);
         enable(extended_features_ebx, 8, Feature::bmi2);

library/std_detect/tests/x86-specific.rs

@@ -5,7 +5,9 @@
     x86_amx_intrinsics,
     xop_target_feature,
     movrs_target_feature,
-    clflushopt_target_feature
+    clflushopt_target_feature,
+    movdir64b_target_feature,
+    movdiri_target_feature
 )]
 
 #[macro_use]
@@ -68,6 +70,8 @@ fn dump() {
     println!("adx: {:?}", is_x86_feature_detected!("adx"));
     println!("rtm: {:?}", is_x86_feature_detected!("rtm"));
     println!("movbe: {:?}", is_x86_feature_detected!("movbe"));
+    println!("movdir64b: {:?}", is_x86_feature_detected!("movdir64b"));
+    println!("movdiri: {:?}", is_x86_feature_detected!("movdiri"));
     println!("avxvnni: {:?}", is_x86_feature_detected!("avxvnni"));
     println!("avxvnniint8: {:?}", is_x86_feature_detected!("avxvnniint8"));
     println!("avxneconvert: {:?}", is_x86_feature_detected!("avxneconvert"));

tests/ui/check-cfg/target_feature.stderr

@@ -211,6 +211,8 @@ LL |     cfg!(target_feature = "_UNEXPECTED_VALUE");
 `miscsr`
 `mops`
 `movbe`
+`movdir64b`
+`movdiri`
 `movrs`
 `movw`
 `mp`

tests/ui/feature-gates/feature-gate-movdir64b_target_feature.rs

@@ -0,0 +1,6 @@
+//@ only-x86_64
+#[target_feature(enable = "movdir64b")]
+//~^ ERROR: currently unstable
+unsafe fn foo() {}
+
+fn main() {}

tests/ui/feature-gates/feature-gate-movdir64b_target_feature.stderr

@@ -0,0 +1,13 @@
+error[E0658]: the target feature `movdir64b` is currently unstable
+  --> $DIR/feature-gate-movdir64b_target_feature.rs:2:18
+   |
+LL | #[target_feature(enable = "movdir64b")]
+   |                  ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #163741 <https://github.com/rust-lang/rust/issues/163741> for more information
+   = help: add `#![feature(movdir64b_target_feature)]` 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
+
+For more information about this error, try `rustc --explain E0658`.

tests/ui/feature-gates/feature-gate-movdiri_target_feature.rs

@@ -0,0 +1,6 @@
+//@ only-x86_64
+#[target_feature(enable = "movdiri")]
+//~^ ERROR: currently unstable
+unsafe fn foo() {}
+
+fn main() {}