transpile: switch __builtin_arm_yield from spin_loop to __yield

`__yield` is the more direct, unstable equivalent of `__builtin_arm_yield`.

Fixes 1st half of <#1263 (comment)>.

Author: kkysen

c2rust-transpile/src/translator/builtins.rs

@@ -380,14 +380,9 @@ impl<'c> Translation<'c> {
                 })
             }
 
-            "__builtin_ia32_pause" | "__builtin_arm_yield" => {
+            "__builtin_ia32_pause" => {
                 // `spin_loop()` is implemented as `_mm_pause()` (the `pause` instruction) on `x86`/`x86_64`,
                 // but it's the safe and cross-platform version of it, so prefer it.
-                // On `arm`, it's implemented as `yield`, although on `aarch64`,
-                // it's implemented as `isb` instead as this is more efficient.
-                // See <https://github.com/rust-lang/rust/commit/c064b6560b7ce0adeb9bbf5d7dcf12b1acb0c807>.
-                // `core::arch::aarch64::__yield()` could be used instead,
-                // but it's unstable (`#![feature(stdarch_arm_hints)]`), so it's not ideal.
                 let spin_loop = mk().abs_path_expr(vec!["core", "hint", "spin_loop"]);
                 let call = mk().call_expr(spin_loop, vec![]);
                 self.convert_side_effects_expr(
@@ -397,6 +392,26 @@ impl<'c> Translation<'c> {
                 )
             }
 
+            "__builtin_arm_yield" => {
+                let fn_name = "__yield";
+                self.use_feature("stdsimd");
+                // TODO In Rust 1.88 (probably earlier), `#![feature(stdsimd)]`
+                // has been removed and split into (at least):
+                // `#![feature("stdarch_arm_hints")]` and
+                // `#![cfg_attr(target_arch = "arm", feature(stdarch_arm_neon_intrinsics))]`.
+                // self.use_feature("stdarch_arm_hints");
+                // self.use_feature("stdarch_arm_neon_intrinsics"); // TODO need to add `cfg_attr` support.
+                self.import_arch_function("arm", fn_name);
+                self.import_arch_function("aarch64", fn_name);
+                let ident = mk().ident_expr(fn_name);
+                let call = mk().call_expr(ident, vec![]);
+                self.convert_side_effects_expr(
+                    ctx,
+                    WithStmts::new_val(call),
+                    "Builtin is not supposed to be used",
+                )
+            }
+
             // SIMD builtins:
             "__builtin_ia32_aeskeygenassist128" => {
                 self.convert_simd_builtin(ctx, "_mm_aeskeygenassist_si128", args)

c2rust-transpile/src/translator/simd.rs

@@ -147,6 +147,13 @@ impl<'c> Translation<'c> {
         })
     }
 
+    /// Import a function from [`core::arch`] with a `#[cfg(target_arch = "{arch_name})]`.
+    pub fn import_arch_function(&self, arch_name: &str, name: &str) {
+        self.with_cur_file_item_store(|item_store| {
+            add_arch_use(item_store, arch_name, name);
+        });
+    }
+
     /// Determine if a particular function name is an SIMD primitive. If so an appropriate
     /// use statement is generated, `true` is returned, and no further processing will need to be done.
     pub fn import_simd_function(&self, name: &str) -> TranslationResult<bool> {

c2rust-transpile/tests/snapshots/arch-specific/dummy2.aarch64.rs

@@ -0,0 +1,18 @@
+#![allow(
+    dead_code,
+    mutable_transmutes,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![feature(stdsimd)]
+#[cfg(target_arch = "arm")]
+pub use core::arch::arm::__yield;
+#[cfg(target_arch = "aarch64")]
+pub use core::arch::aarch64::__yield;
+#[no_mangle]
+pub unsafe extern "C" fn spin() {
+    __yield();
+}

c2rust-transpile/tests/snapshots/arch-specific/dummy2.c

@@ -0,0 +1,23 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/arch-specific/spin.aarch64.rs
+input_file: c2rust-transpile/tests/snapshots/arch-specific/spin.c
+---
+#![allow(
+    dead_code,
+    mutable_transmutes,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![feature(stdsimd)]
+#[cfg(target_arch = "arm")]
+pub use core::arch::arm::__yield;
+#[cfg(target_arch = "aarch64")]
+pub use core::arch::aarch64::__yield;
+#[no_mangle]
+pub unsafe extern "C" fn spin() {
+    __yield();
+}