Update all code to be edition 2024 compatible.

Author: wt

cortex-m-rt/examples/device.rs

@@ -1,6 +1,5 @@
 //! Manually create the interrupts portion of the vector table
 
-#![deny(unsafe_code)]
 #![deny(warnings)]
 #![no_main]
 #![no_std]
@@ -22,14 +21,14 @@ pub union Vector {
     reserved: usize,
 }
 
-extern "C" {
+unsafe extern "C" {
     fn WWDG();
     fn PVD();
 }
 
 #[allow(unsafe_code)]
-#[link_section = ".vector_table.interrupts"]
-#[no_mangle]
+#[unsafe(link_section = ".vector_table.interrupts")]
+#[unsafe(no_mangle)]
 pub static __INTERRUPTS: [Vector; 3] = [
     Vector { handler: WWDG },
     Vector { reserved: 0 },

cortex-m-rt/examples/main.rs

@@ -7,7 +7,7 @@
 extern crate cortex_m_rt as rt;
 extern crate panic_halt;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn main() -> ! {
     loop {}
 }

cortex-m-rt/examples/unsafety.rs

@@ -11,26 +11,26 @@ use cortex_m_rt::{entry, exception, ExceptionFrame};
 
 #[entry]
 unsafe fn main() -> ! {
-    foo();
+    unsafe { foo() };
 
     loop {}
 }
 
 #[exception]
 unsafe fn DefaultHandler(_irqn: i16) {
-    foo();
+    unsafe { foo() };
 }
 
 #[exception]
 unsafe fn HardFault(_ef: &ExceptionFrame) -> ! {
-    foo();
+    unsafe { foo() };
 
     loop {}
 }
 
 #[exception]
 unsafe fn SysTick() {
-    foo();
+    unsafe { foo() };
 }
 
 unsafe fn foo() {}

cortex-m-rt/src/lib.rs

@@ -361,13 +361,13 @@
 //!     reserved: usize,
 //! }
 //!
-//! extern "C" {
+//! unsafe extern "C" {
 //!     fn Foo();
 //!     fn Bar();
 //! }
 //!
-//! #[link_section = ".vector_table.interrupts"]
-//! #[no_mangle]
+//! #[unsafe(link_section = ".vector_table.interrupts")]
+//! #[unsafe(no_mangle)]
 //! pub static __INTERRUPTS: [Vector; 5] = [
 //!     // 0-1: Reserved
 //!     Vector { reserved: 0 },
@@ -440,14 +440,14 @@
 //!
 //! [`MaybeUninit`]: https://doc.rust-lang.org/core/mem/union.MaybeUninit.html
 //!
-//! ```no_run,edition2018
+//! ```no_run
 //! # extern crate core;
 //! use core::mem::MaybeUninit;
 //!
 //! const STACK_SIZE: usize = 8 * 1024;
 //! const NTHREADS: usize = 4;
 //!
-//! #[link_section = ".uninit.STACKS"]
+//! #[unsafe(link_section = ".uninit.STACKS")]
 //! static mut STACKS: MaybeUninit<[[u8; STACK_SIZE]; NTHREADS]> = MaybeUninit::uninit();
 //! ```
 //!
@@ -483,10 +483,10 @@
 //!
 //! You can then use something like this to place a variable into this specific section of memory:
 //!
-//! ```no_run,edition2018
+//! ```no_run
 //! # extern crate core;
 //! # use core::mem::MaybeUninit;
-//! #[link_section=".ccmram.BUFFERS"]
+//! #[unsafe(link_section=".ccmram.BUFFERS")]
 //! static mut BUF: MaybeUninit<[u8; 1024]> = MaybeUninit::uninit();
 //! ```
 //!
@@ -937,7 +937,7 @@ pub use macros::pre_init;
 // two copies of cortex-m-rt together, linking will fail. We also declare a links key in
 // Cargo.toml which is the more modern way to solve the same problem, but we have to keep
 // __ONCE__ around to prevent linking with versions before the links key was added.
-#[export_name = "error: cortex-m-rt appears more than once in the dependency graph"]
+#[unsafe(export_name = "error: cortex-m-rt appears more than once in the dependency graph")]
 #[doc(hidden)]
 pub static __ONCE__: () = ();
 
@@ -1120,7 +1120,7 @@ impl fmt::Debug for ExceptionFrame {
 /// The returned pointer is guaranteed to be 4-byte aligned.
 #[inline]
 pub fn heap_start() -> *mut u32 {
-    extern "C" {
+    unsafe extern "C" {
         static mut __sheap: u32;
     }
 
@@ -1132,27 +1132,27 @@ pub fn heap_start() -> *mut u32 {
 
 // Entry point is Reset.
 #[doc(hidden)]
-#[cfg_attr(cortex_m, link_section = ".vector_table.reset_vector")]
-#[no_mangle]
+#[cfg_attr(cortex_m, unsafe(link_section = ".vector_table.reset_vector"))]
+#[unsafe(no_mangle)]
 pub static __RESET_VECTOR: unsafe extern "C" fn() -> ! = Reset;
 
 #[doc(hidden)]
-#[cfg_attr(cortex_m, link_section = ".HardFault.default")]
-#[no_mangle]
+#[cfg_attr(cortex_m, unsafe(link_section = ".HardFault.default"))]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn HardFault_() -> ! {
     #[allow(clippy::empty_loop)]
     loop {}
 }
 
 #[doc(hidden)]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn DefaultHandler_() -> ! {
     #[allow(clippy::empty_loop)]
     loop {}
 }
 
 #[doc(hidden)]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn DefaultPreInit() {}
 
 /* Exceptions */
@@ -1187,7 +1187,7 @@ pub enum Exception {
 #[doc(hidden)]
 pub use self::Exception as exception;
 
-extern "C" {
+unsafe extern "C" {
     fn Reset() -> !;
 
     fn NonMaskableInt();
@@ -1224,8 +1224,8 @@ pub union Vector {
 }
 
 #[doc(hidden)]
-#[cfg_attr(cortex_m, link_section = ".vector_table.exceptions")]
-#[no_mangle]
+#[cfg_attr(cortex_m, unsafe(link_section = ".vector_table.exceptions"))]
+#[unsafe(no_mangle)]
 pub static __EXCEPTIONS: [Vector; 14] = [
     // Exception 2: Non Maskable Interrupt.
     Vector {
@@ -1284,10 +1284,10 @@ pub static __EXCEPTIONS: [Vector; 14] = [
 // to the default handler
 #[cfg(all(any(not(feature = "device"), test), not(armv6m), not(armv8m_main)))]
 #[doc(hidden)]
-#[cfg_attr(cortex_m, link_section = ".vector_table.interrupts")]
-#[no_mangle]
+#[cfg_attr(cortex_m, unsafe(link_section = ".vector_table.interrupts"))]
+#[unsafe(no_mangle)]
 pub static __INTERRUPTS: [unsafe extern "C" fn(); 240] = [{
-    extern "C" {
+    unsafe extern "C" {
         fn DefaultHandler();
     }
 
@@ -1297,10 +1297,10 @@ pub static __INTERRUPTS: [unsafe extern "C" fn(); 240] = [{
 // ARMv8-M Mainline can have up to 480 device specific interrupts
 #[cfg(all(not(feature = "device"), armv8m_main))]
 #[doc(hidden)]
-#[cfg_attr(cortex_m, link_section = ".vector_table.interrupts")]
-#[no_mangle]
+#[cfg_attr(cortex_m, unsafe(link_section = ".vector_table.interrupts"))]
+#[unsafe(no_mangle)]
 pub static __INTERRUPTS: [unsafe extern "C" fn(); 480] = [{
-    extern "C" {
+    unsafe extern "C" {
         fn DefaultHandler();
     }
 
@@ -1310,10 +1310,10 @@ pub static __INTERRUPTS: [unsafe extern "C" fn(); 480] = [{
 // ARMv6-M can only have a maximum of 32 device specific interrupts
 #[cfg(all(not(feature = "device"), armv6m))]
 #[doc(hidden)]
-#[link_section = ".vector_table.interrupts"]
-#[no_mangle]
+#[unsafe(link_section = ".vector_table.interrupts")]
+#[unsafe(no_mangle)]
 pub static __INTERRUPTS: [unsafe extern "C" fn(); 32] = [{
-    extern "C" {
+    unsafe extern "C" {
         fn DefaultHandler();
     }
 

cortex-m-semihosting/src/lib.rs

@@ -193,7 +193,7 @@ pub mod nr;
 /// [semihosting operation]: https://developer.arm.com/documentation/dui0471/i/semihosting/semihosting-operations?lang=en
 #[inline(always)]
 pub unsafe fn syscall<T>(nr: usize, arg: &T) -> usize {
-    syscall1(nr, arg as *const T as usize)
+    unsafe { syscall1(nr, arg as *const T as usize) }
 }
 
 /// Performs a semihosting operation, takes one integer as an argument
@@ -209,7 +209,9 @@ pub unsafe fn syscall1(_nr: usize, _arg: usize) -> usize {
             use core::arch::asm;
             let mut nr = _nr as u32;
             let arg = _arg as u32;
-            asm!("bkpt #0xab", inout("r0") nr, in("r1") arg, options(nostack, preserves_flags));
+            unsafe {
+                asm!("bkpt #0xab", inout("r0") nr, in("r1") arg, options(nostack, preserves_flags));
+            }
             nr as usize
         }
         #[cfg(all(thumb, feature = "no-semihosting"))]

cortex-m/src/asm.rs

@@ -293,7 +293,9 @@ pub unsafe fn bootstrap(msp: *const u32, rv: *const u32) -> ! {
 /// a valid reset vector as the second word.
 #[inline]
 pub unsafe fn bootload(vector_table: *const u32) -> ! {
-    let msp = core::ptr::read_volatile(vector_table);
-    let rv = core::ptr::read_volatile(vector_table.offset(1));
-    bootstrap(msp as *const u32, rv as *const u32);
+    unsafe {
+        let msp = core::ptr::read_volatile(vector_table);
+        let rv = core::ptr::read_volatile(vector_table.offset(1));
+        bootstrap(msp as *const u32, rv as *const u32);
+    }
 }

cortex-m/src/call_asm.rs

@@ -12,7 +12,7 @@ macro_rules! call_asm {
 
                 #[cfg(not(feature = "inline-asm"))]
                 () => {
-                    extern "C" {
+                    unsafe extern "C" {
                         fn $func($($args: $tys),*) $(-> $ret)?;
                     }
 

cortex-m/src/critical_section.rs

@@ -19,6 +19,6 @@ unsafe impl Impl for SingleCoreCriticalSection {
 
     unsafe fn release(restore_state: RawRestoreState) {
         // NOTE: Fence guarantees are provided by primask::write_raw(), which performs a `compiler_fence(SeqCst)`.
-        primask::write_raw(restore_state);
+        unsafe { primask::write_raw(restore_state) };
     }
 }

cortex-m/src/interrupt.rs

@@ -65,7 +65,7 @@ where
     // disable interrupts
     disable();
 
-    let r = f(unsafe { &CriticalSection::new() });
+    let r = f(&unsafe { CriticalSection::new() });
 
     unsafe {
         crate::register::primask::write_raw(primask);

cortex-m/src/itm.rs

@@ -8,50 +8,54 @@ use crate::peripheral::itm::Stim;
 
 // NOTE assumes that `bytes` is 32-bit aligned
 unsafe fn write_words(stim: &mut Stim, bytes: &[u32]) {
-    let mut p = bytes.as_ptr();
-    for _ in 0..bytes.len() {
-        while !stim.is_fifo_ready() {}
-        stim.write_u32(ptr::read(p));
-        p = p.offset(1);
+    unsafe {
+        let mut p = bytes.as_ptr();
+        for _ in 0..bytes.len() {
+            while !stim.is_fifo_ready() {}
+            stim.write_u32(ptr::read(p));
+            p = p.offset(1);
+        }
     }
 }
 
 /// Writes an aligned byte slice to the ITM.
 ///
 /// `buffer` must be 4-byte aligned.
 unsafe fn write_aligned_impl(port: &mut Stim, buffer: &[u8]) {
-    let len = buffer.len();
+    unsafe {
+        let len = buffer.len();
 
-    if len == 0 {
-        return;
-    }
+        if len == 0 {
+            return;
+        }
 
-    let split = len & !0b11;
-    #[allow(clippy::cast_ptr_alignment)]
-    write_words(
-        port,
-        slice::from_raw_parts(buffer.as_ptr() as *const u32, split >> 2),
-    );
+        let split = len & !0b11;
+        #[allow(clippy::cast_ptr_alignment)]
+        write_words(
+            port,
+            slice::from_raw_parts(buffer.as_ptr() as *const u32, split >> 2),
+        );
 
-    // 3 bytes or less left
-    let mut left = len & 0b11;
-    let mut ptr = buffer.as_ptr().add(split);
+        // 3 bytes or less left
+        let mut left = len & 0b11;
+        let mut ptr = buffer.as_ptr().add(split);
 
-    // at least 2 bytes left
-    if left > 1 {
-        while !port.is_fifo_ready() {}
+        // at least 2 bytes left
+        if left > 1 {
+            while !port.is_fifo_ready() {}
 
-        #[allow(clippy::cast_ptr_alignment)]
-        port.write_u16(ptr::read(ptr as *const u16));
+            #[allow(clippy::cast_ptr_alignment)]
+            port.write_u16(ptr::read(ptr as *const u16));
 
-        ptr = ptr.offset(2);
-        left -= 2;
-    }
+            ptr = ptr.offset(2);
+            left -= 2;
+        }
 
-    // final byte
-    if left == 1 {
-        while !port.is_fifo_ready() {}
-        port.write_u8(*ptr);
+        // final byte
+        if left == 1 {
+            while !port.is_fifo_ready() {}
+            port.write_u8(*ptr);
+        }
     }
 }