Update documentation for unsafe_op_in_unsafe_fn

For the documentation side, we probably want to show the Rust 2024
style.

Author: ehuss

crates/core_arch/src/core_arch_docs.md

@@ -131,7 +131,7 @@ unsafe fn foo_avx2() {
     #[cfg(target_arch = "x86_64")]
     use std::arch::x86_64::_mm256_add_epi64;
 
-    _mm256_add_epi64(...);
+    unsafe { _mm256_add_epi64(...); }
 }
 ```
 
@@ -287,47 +287,49 @@ unsafe fn hex_encode_sse41(mut src: &[u8], dst: &mut [u8]) {
     #[cfg(target_arch = "x86_64")]
     use std::arch::x86_64::*;
 
-    let ascii_zero = _mm_set1_epi8(b'0' as i8);
-    let nines = _mm_set1_epi8(9);
-    let ascii_a = _mm_set1_epi8((b'a' - 9 - 1) as i8);
-    let and4bits = _mm_set1_epi8(0xf);
-
-    let mut i = 0_isize;
-    while src.len() >= 16 {
-        let invec = _mm_loadu_si128(src.as_ptr() as *const _);
-
-        let masked1 = _mm_and_si128(invec, and4bits);
-        let masked2 = _mm_and_si128(_mm_srli_epi64(invec, 4), and4bits);
-
-        // return 0xff corresponding to the elements > 9, or 0x00 otherwise
-        let cmpmask1 = _mm_cmpgt_epi8(masked1, nines);
-        let cmpmask2 = _mm_cmpgt_epi8(masked2, nines);
-
-        // add '0' or the offset depending on the masks
-        let masked1 = _mm_add_epi8(
-            masked1,
-            _mm_blendv_epi8(ascii_zero, ascii_a, cmpmask1),
-        );
-        let masked2 = _mm_add_epi8(
-            masked2,
-            _mm_blendv_epi8(ascii_zero, ascii_a, cmpmask2),
-        );
-
-        // interleave masked1 and masked2 bytes
-        let res1 = _mm_unpacklo_epi8(masked2, masked1);
-        let res2 = _mm_unpackhi_epi8(masked2, masked1);
-
-        _mm_storeu_si128(dst.as_mut_ptr().offset(i * 2) as *mut _, res1);
-        _mm_storeu_si128(
-            dst.as_mut_ptr().offset(i * 2 + 16) as *mut _,
-            res2,
-        );
-        src = &src[16..];
-        i += 16;
-    }
+    unsafe {
+        let ascii_zero = _mm_set1_epi8(b'0' as i8);
+        let nines = _mm_set1_epi8(9);
+        let ascii_a = _mm_set1_epi8((b'a' - 9 - 1) as i8);
+        let and4bits = _mm_set1_epi8(0xf);
+
+        let mut i = 0_isize;
+        while src.len() >= 16 {
+            let invec = _mm_loadu_si128(src.as_ptr() as *const _);
+
+            let masked1 = _mm_and_si128(invec, and4bits);
+            let masked2 = _mm_and_si128(_mm_srli_epi64(invec, 4), and4bits);
+
+            // return 0xff corresponding to the elements > 9, or 0x00 otherwise
+            let cmpmask1 = _mm_cmpgt_epi8(masked1, nines);
+            let cmpmask2 = _mm_cmpgt_epi8(masked2, nines);
+
+            // add '0' or the offset depending on the masks
+            let masked1 = _mm_add_epi8(
+                masked1,
+                _mm_blendv_epi8(ascii_zero, ascii_a, cmpmask1),
+            );
+            let masked2 = _mm_add_epi8(
+                masked2,
+                _mm_blendv_epi8(ascii_zero, ascii_a, cmpmask2),
+            );
+
+            // interleave masked1 and masked2 bytes
+            let res1 = _mm_unpacklo_epi8(masked2, masked1);
+            let res2 = _mm_unpackhi_epi8(masked2, masked1);
+
+            _mm_storeu_si128(dst.as_mut_ptr().offset(i * 2) as *mut _, res1);
+            _mm_storeu_si128(
+                dst.as_mut_ptr().offset(i * 2 + 16) as *mut _,
+                res2,
+            );
+            src = &src[16..];
+            i += 16;
+        }
 
-    let i = i as usize;
-    hex_encode_fallback(src, &mut dst[i * 2..]);
+        let i = i as usize;
+        hex_encode_fallback(src, &mut dst[i * 2..]);
+    }
 }
 
 fn hex_encode_fallback(src: &[u8], dst: &mut [u8]) {

crates/core_arch/src/x86/mod.rs

@@ -47,11 +47,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "sse2")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let all_bytes_zero = _mm_setzero_si128();
     /// let all_bytes_one = _mm_set1_epi8(1);
     /// let four_i32 = _mm_set_epi32(1, 2, 3, 4);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("sse2") { unsafe { foo() } }
     /// # }
     /// ```
@@ -89,11 +89,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "sse")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let four_zeros = _mm_setzero_ps();
     /// let four_ones = _mm_set1_ps(1.0);
     /// let four_floats = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("sse") { unsafe { foo() } }
     /// # }
     /// ```
@@ -131,11 +131,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "sse")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let two_zeros = _mm_setzero_pd();
     /// let two_ones = _mm_set1_pd(1.0);
     /// let two_floats = _mm_set_pd(1.0, 2.0);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("sse") { unsafe { foo() } }
     /// # }
     /// ```
@@ -177,11 +177,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "avx")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let all_bytes_zero = _mm256_setzero_si256();
     /// let all_bytes_one = _mm256_set1_epi8(1);
     /// let eight_i32 = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("avx") { unsafe { foo() } }
     /// # }
     /// ```
@@ -219,11 +219,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "avx")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let eight_zeros = _mm256_setzero_ps();
     /// let eight_ones = _mm256_set1_ps(1.0);
     /// let eight_floats = _mm256_set_ps(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("avx") { unsafe { foo() } }
     /// # }
     /// ```
@@ -261,11 +261,11 @@ types! {
     ///
     /// # fn main() {
     /// # #[target_feature(enable = "avx")]
-    /// # unsafe fn foo() {
+    /// # unsafe fn foo() { unsafe {
     /// let four_zeros = _mm256_setzero_pd();
     /// let four_ones = _mm256_set1_pd(1.0);
     /// let four_floats = _mm256_set_pd(1.0, 2.0, 3.0, 4.0);
-    /// # }
+    /// # }}
     /// # if is_x86_feature_detected!("avx") { unsafe { foo() } }
     /// # }
     /// ```

crates/core_arch/src/x86/sse41.rs

@@ -177,13 +177,13 @@ pub unsafe fn _mm_blend_ps<const IMM4: i32>(a: __m128, b: __m128) -> __m128 {
 /// # fn main() {
 /// #    if is_x86_feature_detected!("sse4.1") {
 /// #       #[target_feature(enable = "sse4.1")]
-/// #       unsafe fn worker() {
+/// #       unsafe fn worker() { unsafe {
 /// let mut float_store = vec![1.0, 1.0, 2.0, 3.0];
 /// let simd_floats = _mm_set_ps(2.5, 5.0, 7.5, 10.0);
 /// let x: i32 = _mm_extract_ps::<2>(simd_floats);
 /// float_store.push(f32::from_bits(x as u32));
 /// assert_eq!(float_store, vec![1.0, 1.0, 2.0, 3.0, 5.0]);
-/// #       }
+/// #       }}
 /// #       unsafe { worker() }
 /// #   }
 /// # }