Auto merge of rust-lang#150357 - ZuseZ4:zusez4-stdarch-push, r=sayantan

stdarch subtree update

Subtree update of `stdarch` to rust-lang/stdarch@6111906.

Created using https://github.com/rust-lang/josh-sync.

r? `@sayantn`

My first josh sync, it lgtm, but let me know if I missed something.
I'm especially looking forward to the amd GPU module, which we want to use for the offload project.

Author: bors

library/compiler-builtins/libm/src/math/arch/x86/detect.rs

@@ -57,7 +57,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 +72,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, .. } = unsafe { __cpuid(0x0000_0001_u32) };
+    let CpuidResult { ecx, edx, .. } = __cpuid(0x0000_0001_u32);
     let proc_info_ecx = Flags::from_bits(ecx);
     let proc_info_edx = Flags::from_bits(edx);
 
@@ -82,23 +82,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, .. } = unsafe { __cpuid(0x0000_0007_u32) };
+        let CpuidResult { ebx, edx, .. } = __cpuid(0x0000_0007_u32);
         extended_features_ebx = Flags::from_bits(ebx);
         extended_features_edx = Flags::from_bits(edx);
 
-        let CpuidResult { eax, .. } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
+        let CpuidResult { eax, .. } = __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 = unsafe { __cpuid(0x8000_0000_u32) }.eax;
+    let extended_max_basic_leaf = __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, .. } = unsafe { __cpuid(0x8000_0001_u32) };
+        let CpuidResult { ecx, .. } = __cpuid(0x8000_0001_u32);
         extended_proc_info_ecx = Flags::from_bits(ecx);
     }
 

library/std/src/sys/pal/uefi/time.rs

@@ -356,7 +356,7 @@ pub(crate) mod instant_internal {
         // Inspired by [`edk2/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c`](https://github.com/tianocore/edk2/blob/master/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c)
         let freq = FREQUENCY
             .get_or_try_init(|| {
-                let cpuid = unsafe { crate::arch::x86_64::__cpuid(0x15) };
+                let cpuid = crate::arch::x86_64::__cpuid(0x15);
                 if cpuid.eax == 0 || cpuid.ebx == 0 || cpuid.ecx == 0 {
                     return Err(());
                 }
@@ -375,7 +375,7 @@ pub(crate) mod instant_internal {
 
         let freq = FREQUENCY
             .get_or_try_init(|| {
-                let cpuid = unsafe { crate::arch::x86::__cpuid(0x15) };
+                let cpuid = crate::arch::x86::__cpuid(0x15);
                 if cpuid.eax == 0 || cpuid.ebx == 0 || cpuid.ecx == 0 {
                     return Err(());
                 }

library/std/src/sys/random/uefi.rs

@@ -107,11 +107,11 @@ mod rdrand {
         {
             // SAFETY: All Rust x86 targets are new enough to have CPUID, and we
             // check that leaf 1 is supported before using it.
-            let cpuid0 = unsafe { arch::__cpuid(0) };
+            let cpuid0 = arch::__cpuid(0);
             if cpuid0.eax < 1 {
                 return false;
             }
-            let cpuid1 = unsafe { arch::__cpuid(1) };
+            let cpuid1 = arch::__cpuid(1);
 
             let vendor_id =
                 [cpuid0.ebx.to_le_bytes(), cpuid0.edx.to_le_bytes(), cpuid0.ecx.to_le_bytes()];

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

@@ -40,10 +40,10 @@ pub(crate) fn detect_features() -> cache::Initializer {
     // leaf value for subsequent calls of `cpuinfo` in range [0,
     // 0x8000_0000]. - The vendor ID is stored in 12 u8 ascii chars,
     // returned in EBX, EDX, and   ECX (in that order):
-    let (max_basic_leaf, vendor_id) = unsafe {
+    let (max_basic_leaf, vendor_id) = {
         let CpuidResult { eax: max_basic_leaf, ebx, ecx, edx } = __cpuid(0);
         let vendor_id: [[u8; 4]; 3] = [ebx.to_ne_bytes(), edx.to_ne_bytes(), ecx.to_ne_bytes()];
-        let vendor_id: [u8; 12] = mem::transmute(vendor_id);
+        let vendor_id: [u8; 12] = unsafe { mem::transmute(vendor_id) };
         (max_basic_leaf, vendor_id)
     };
 
@@ -54,8 +54,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
 
     // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
     // Contains information about most x86 features.
-    let CpuidResult { ecx: proc_info_ecx, edx: proc_info_edx, .. } =
-        unsafe { __cpuid(0x0000_0001_u32) };
+    let CpuidResult { ecx: proc_info_ecx, edx: proc_info_edx, .. } = __cpuid(0x0000_0001_u32);
 
     // EAX = 7: Queries "Extended Features";
     // Contains information about bmi,bmi2, and avx2 support.
@@ -66,9 +65,9 @@ pub(crate) fn detect_features() -> cache::Initializer {
         extended_features_eax_leaf_1,
         extended_features_edx_leaf_1,
     ) = if max_basic_leaf >= 7 {
-        let CpuidResult { ebx, ecx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
+        let CpuidResult { ebx, ecx, edx, .. } = __cpuid(0x0000_0007_u32);
         let CpuidResult { eax: eax_1, edx: edx_1, .. } =
-            unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
+            __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32);
         (ebx, ecx, edx, eax_1, edx_1)
     } else {
         (0, 0, 0, 0, 0) // CPUID does not support "Extended Features"
@@ -77,12 +76,12 @@ pub(crate) fn detect_features() -> cache::Initializer {
     // 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 CpuidResult { eax: extended_max_basic_leaf, .. } = unsafe { __cpuid(0x8000_0000_u32) };
+    let CpuidResult { eax: extended_max_basic_leaf, .. } = __cpuid(0x8000_0000_u32);
 
     // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature
     // Bits"
     let extended_proc_info_ecx = if extended_max_basic_leaf >= 1 {
-        let CpuidResult { ecx, .. } = unsafe { __cpuid(0x8000_0001_u32) };
+        let CpuidResult { ecx, .. } = __cpuid(0x8000_0001_u32);
         ecx
     } else {
         0
@@ -132,7 +131,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
 
         // Detect if CPUID.19h available
         if bit::test(extended_features_ecx as usize, 23) {
-            let CpuidResult { ebx, .. } = unsafe { __cpuid(0x19) };
+            let CpuidResult { ebx, .. } = __cpuid(0x19);
             enable(ebx, 0, Feature::kl);
             enable(ebx, 2, Feature::widekl);
         }
@@ -223,7 +222,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
                     // ECX = 1):
                     if max_basic_leaf >= 0xd {
                         let CpuidResult { eax: proc_extended_state1_eax, .. } =
-                            unsafe { __cpuid_count(0xd_u32, 1) };
+                            __cpuid_count(0xd_u32, 1);
                         enable(proc_extended_state1_eax, 0, Feature::xsaveopt);
                         enable(proc_extended_state1_eax, 1, Feature::xsavec);
                         enable(proc_extended_state1_eax, 3, Feature::xsaves);
@@ -282,7 +281,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
 
                     if max_basic_leaf >= 0x1e {
                         let CpuidResult { eax: amx_feature_flags_eax, .. } =
-                            unsafe { __cpuid_count(0x1e_u32, 1) };
+                            __cpuid_count(0x1e_u32, 1);
 
                         enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
                         enable(amx_feature_flags_eax, 6, Feature::amx_tf32);
@@ -297,7 +296,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
 
                 let avx10_1 = enable(extended_features_edx_leaf_1, 19, Feature::avx10_1);
                 if avx10_1 {
-                    let CpuidResult { ebx, .. } = unsafe { __cpuid(0x24) };
+                    let CpuidResult { ebx, .. } = __cpuid(0x24);
                     let avx10_version = ebx & 0xff;
                     if avx10_version >= 2 {
                         value.set(Feature::avx10_2 as u32);

library/stdarch/.github/workflows/main.yml

@@ -84,6 +84,8 @@ jobs:
           os: ubuntu-latest
         - tuple: nvptx64-nvidia-cuda
           os: ubuntu-latest
+        - tuple: amdgcn-amd-amdhsa
+          os: ubuntu-latest
         - tuple: thumbv6m-none-eabi
           os: ubuntu-latest
         - tuple: thumbv7m-none-eabi
@@ -201,6 +203,10 @@ jobs:
             tuple: aarch64-apple-ios-macabi
             os: macos-15
           norun: true # https://github.com/rust-lang/stdarch/issues/1206
+        - target:
+            tuple: amdgcn-amd-amdhsa
+            os: ubuntu-latest
+          norun: true
 
     steps:
     - uses: actions/checkout@v4
@@ -212,15 +218,20 @@ jobs:
 
     - run: rustup target add ${{ matrix.target.tuple }}
       shell: bash
-      if: matrix.build_std == ''
+      if: matrix.build_std == '' && matrix.target.tuple != 'amdgcn-amd-amdhsa'
     - run: |
         rustup component add rust-src
         echo "CARGO_UNSTABLE_BUILD_STD=std" >> $GITHUB_ENV
       shell: bash
       if: matrix.build_std != ''
+    - run: |
+        rustup component add rust-src
+        echo "CARGO_UNSTABLE_BUILD_STD=core,alloc" >> $GITHUB_ENV
+      shell: bash
+      if: matrix.target.tuple == 'amdgcn-amd-amdhsa'
 
     # Configure some env vars based on matrix configuration
-    - run: echo "PROFILE=--profile=${{matrix.profile}}" >> $GITHUB_ENV
+    - run: echo "PROFILE=${{matrix.profile}}" >> $GITHUB_ENV
       shell: bash
     - run: echo "NORUN=1" >> $GITHUB_ENV
       shell: bash
@@ -233,7 +244,7 @@ jobs:
       if: matrix.disable_assert_instr != ''
     - run: echo "NOSTD=1" >> $GITHUB_ENV
       shell: bash
-      if: startsWith(matrix.target.tuple, 'thumb') || matrix.target.tuple == 'nvptx64-nvidia-cuda'
+      if: startsWith(matrix.target.tuple, 'thumb') || matrix.target.tuple == 'nvptx64-nvidia-cuda' || matrix.target.tuple == 'amdgcn-amd-amdhsa'
 
     # Windows & OSX go straight to `run.sh` ...
     - run: ./ci/run.sh
@@ -280,7 +291,7 @@ jobs:
       if: ${{ matrix.build_std }}
 
     # Configure some env vars based on matrix configuration
-    - run: echo "PROFILE=--profile=${{ matrix.profile }}" >> $GITHUB_ENV
+    - run: echo "PROFILE=${{ matrix.profile }}" >> $GITHUB_ENV
     - run: ./ci/intrinsic-test-docker.sh ${{ matrix.target }}
       if: ${{ !startsWith(matrix.target, 'thumb') }}
       env:

library/stdarch/ci/docker/amdgcn-amd-amdhsa/Dockerfile

@@ -0,0 +1,5 @@
+FROM ubuntu:25.10
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  gcc \
+  libc6-dev \
+  ca-certificates

library/stdarch/ci/docker/wasm32-wasip1/Dockerfile

@@ -11,5 +11,3 @@ ENV VERSION=v38.0.3
 
 RUN curl -L https://github.com/bytecodealliance/wasmtime/releases/download/${VERSION}/wasmtime-${VERSION}-x86_64-linux.tar.xz | tar xJf -
 ENV PATH=$PATH:/wasmtime-${VERSION}-x86_64-linux
-
-ENV CARGO_TARGET_WASM32_WASIP1_RUNNER="wasmtime -Wexceptions --dir /checkout/target/wasm32-wasip1/release/deps::."

library/stdarch/ci/dox.sh

@@ -15,6 +15,15 @@ dox() {
 
   cargo clean --target "${1}"
 
+  if [ "${1}" == "amdgcn-amd-amdhsa" ]; then
+    if [ "$CI" != "" ]; then
+      rustup component add rust-src
+    fi
+    export CARGO_UNSTABLE_BUILD_STD=core
+    # amdgpu needs a target-cpu, any is fine
+    export RUSTFLAGS="${RUSTFLAGS} -Ctarget-cpu=gfx900"
+  fi
+
   cargo build --verbose --target "${1}" --manifest-path crates/core_arch/Cargo.toml
   cargo doc --verbose --target "${1}" --manifest-path crates/core_arch/Cargo.toml
 }
@@ -33,6 +42,7 @@ if [ -z "$1" ]; then
   #dox mips64-unknown-linux-gnuabi64
   dox wasm32-unknown-unknown
   dox nvptx64-nvidia-cuda
+  dox amdgcn-amd-amdhsa
 else
   dox "${1}"
 fi

library/stdarch/ci/intrinsic-test-docker.sh

@@ -30,6 +30,7 @@ run() {
       --env CARGO_HOME=/cargo \
       --env CARGO_TARGET_DIR=/checkout/target \
       --env TARGET="${1}" \
+      --env PROFILE \
       --env "${HOST_LINKER}"="cc" \
       --env STDARCH_DISABLE_ASSERT_INSTR \
       --env NOSTD \

library/stdarch/ci/intrinsic-test.sh

@@ -6,7 +6,7 @@ set -ex
 
 export RUSTFLAGS="${RUSTFLAGS} -D warnings -Z merge-functions=disabled -Z verify-llvm-ir"
 export HOST_RUSTFLAGS="${RUSTFLAGS}"
-export PROFILE="${PROFILE:="--profile=release"}"
+export PROFILE="${PROFILE:="release"}"
 
 case ${TARGET} in
     # On 32-bit use a static relocation model which avoids some extra
@@ -56,7 +56,7 @@ case ${TARGET} in
 
     aarch64_be-unknown-linux-gnu*)
         TEST_CPPFLAGS="-fuse-ld=lld"
-        TEST_SKIP_INTRINSICS=crates/intrinsic-test/missing_aarch64.txt
+        TEST_SKIP_INTRINSICS=crates/intrinsic-test/missing_aarch64_be.txt
         TEST_CXX_COMPILER="clang++"
         TEST_RUNNER="${CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_RUNNER}"
         : "${TEST_SAMPLE_INTRINSICS_PERCENTAGE:=100}"
@@ -75,7 +75,7 @@ case ${TARGET} in
         TEST_CXX_COMPILER="clang++"
         TEST_RUNNER="${CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER}"
         TEST_SKIP_INTRINSICS=crates/intrinsic-test/missing_x86.txt
-        : "${TEST_SAMPLE_INTRINSICS_PERCENTAGE:=5}"
+        : "${TEST_SAMPLE_INTRINSICS_PERCENTAGE:=20}"
         ;;
     *)
         ;;
@@ -85,27 +85,29 @@ esac
 # Arm specific
 case "${TARGET}" in
     aarch64-unknown-linux-gnu*|armv7-unknown-linux-gnueabihf*)
-        CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=info \
-            cargo run "${INTRINSIC_TEST}" "${PROFILE}" \
+        CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=warn \
+            cargo run "${INTRINSIC_TEST}" --release  \
             --bin intrinsic-test -- intrinsics_data/arm_intrinsics.json \
             --runner "${TEST_RUNNER}" \
             --cppcompiler "${TEST_CXX_COMPILER}" \
             --skip "${TEST_SKIP_INTRINSICS}" \
             --target "${TARGET}" \
+            --profile "${PROFILE}" \
             --sample-percentage "${TEST_SAMPLE_INTRINSICS_PERCENTAGE}"
         ;;
 
     aarch64_be-unknown-linux-gnu*)
-        CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=info \
-            cargo run "${INTRINSIC_TEST}" "${PROFILE}"  \
+        CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=warn \
+            cargo run "${INTRINSIC_TEST}" --release  \
             --bin intrinsic-test -- intrinsics_data/arm_intrinsics.json \
             --runner "${TEST_RUNNER}" \
             --cppcompiler "${TEST_CXX_COMPILER}" \
             --skip "${TEST_SKIP_INTRINSICS}" \
             --target "${TARGET}" \
-            --sample-percentage "${TEST_SAMPLE_INTRINSICS_PERCENTAGE}" \
+            --profile "${PROFILE}" \
             --linker "${CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_LINKER}" \
-            --cxx-toolchain-dir "${AARCH64_BE_TOOLCHAIN}"
+            --cxx-toolchain-dir "${AARCH64_BE_TOOLCHAIN}" \
+            --sample-percentage "${TEST_SAMPLE_INTRINSICS_PERCENTAGE}"
         ;;
 
     x86_64-unknown-linux-gnu*)
@@ -114,13 +116,14 @@ case "${TARGET}" in
         # Hence the use of `env -u`.
         env -u CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER \
             CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" \
-            RUST_LOG=info RUST_BACKTRACE=1 \
-            cargo run "${INTRINSIC_TEST}" "${PROFILE}"  \
+            RUST_LOG=warn RUST_BACKTRACE=1 \
+            cargo run "${INTRINSIC_TEST}" --release \
             --bin intrinsic-test -- intrinsics_data/x86-intel.xml \
             --runner "${TEST_RUNNER}" \
             --skip "${TEST_SKIP_INTRINSICS}" \
             --cppcompiler "${TEST_CXX_COMPILER}" \
             --target "${TARGET}" \
+            --profile "${PROFILE}" \
             --sample-percentage "${TEST_SAMPLE_INTRINSICS_PERCENTAGE}"
         ;;
      *)