Update probe-rs to version 0.13.0

This patch doesn't implement 64-bit support, but only inserts
conversions from u32 to u64 where necessary.

Author: jannic

CHANGELOG.md

@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 - [#317] Clarify "can't determine stack overflow" error message
 - [#314] Clarify documentation in README
 - [#293] Update snapshot tests to new TRACE output
+- Update probe-rs to 0.13.0 (does not yet implement 64-bit support)
 
 [#328]: https://github.com/knurling-rs/probe-run/pull/328
 [#326]: https://github.com/knurling-rs/probe-run/pull/326

Cargo.lock

@@ -24,8 +24,8 @@ gimli = { version = "0.26", default-features = false }
 git-version = "0.3"
 log = "0.4"
 object = { version = "0.27", default-features = false }
-probe-rs = "0.12"
-probe-rs-rtt = "0.12"
+probe-rs = "0.13"
+probe-rs-rtt = "0.13"
 signal-hook = "0.3"
 structopt = "0.3"
 

Cargo.toml

@@ -56,9 +56,13 @@ pub(crate) fn target(core: &mut Core, elf: &Elf, active_ram_region: &Option<RamR
     let mut registers = Registers::new(lr, sp, core);
 
     loop {
-        if let Some(outcome) =
-            check_hard_fault(pc, &elf.vector_table, &mut output, sp, active_ram_region)
-        {
+        if let Some(outcome) = check_hard_fault(
+            pc,
+            &elf.vector_table,
+            &mut output,
+            sp.into(),
+            active_ram_region,
+        ) {
             output.outcome = outcome;
         }
 
@@ -114,7 +118,10 @@ pub(crate) fn target(core: &mut Core, elf: &Elf, active_ram_region: &Option<RamR
             let sp = unwrap_or_return_output!(registers.get(registers::SP));
             let ram_bounds = active_ram_region
                 .as_ref()
-                .map(|ram_region| ram_region.range.clone())
+                .map(|ram_region| {
+                    ram_region.range.start.try_into().unwrap_or(u32::MAX)
+                        ..ram_region.range.end.try_into().unwrap_or(u32::MAX)
+                })
                 .unwrap_or(cortexm::VALID_RAM_ADDRESS);
             let stacked = if let Some(stacked) =
                 unwrap_or_return_output!(Stacked::read(registers.core, sp, fpu, ram_bounds))
@@ -195,7 +202,7 @@ fn overflowed_stack(sp: u32, active_ram_region: &Option<RamRegion>) -> bool {
         // NOTE stack is full descending; meaning the stack pointer can be
         // `ORIGIN(RAM) + LENGTH(RAM)`
         let range = active_ram_region.range.start..=active_ram_region.range.end;
-        !range.contains(&sp)
+        !range.contains(&sp.into())
     } else {
         log::warn!("no RAM region appears to contain the stack; probe-run can't determine if this was a stack overflow");
         false

src/backtrace/unwind.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use probe_rs::{Core, MemoryInterface, Session};
+use probe_rs::{Core, MemoryInterface, RegisterValue, Session};
 
 use crate::{registers::PC, Elf, TargetInfo, TIMEOUT};
 
@@ -116,7 +116,7 @@ impl Canary {
         }
         let mut canary = vec![0; self.size];
         let start = Instant::now();
-        core.read_8(self.address, &mut canary)?;
+        core.read_8(self.address.into(), &mut canary)?;
         let seconds = start.elapsed().as_secs_f64();
         log::trace!(
             "reading canary took {seconds:.3}s ({:.2} KiB/s)",
@@ -195,18 +195,21 @@ fn paint_stack(core: &mut Core, start: u32, end: u32) -> Result<(), probe_rs::Er
 
     // write subroutine to RAM
     // NOTE: add `SUBROUTINE_LENGTH` to `start`, to avoid the subroutine overwriting itself
-    core.write_8(start, &subroutine(start + SUBROUTINE_LENGTH as u32, end))?;
+    core.write_8(
+        start.into(),
+        &subroutine(start + SUBROUTINE_LENGTH as u32, end),
+    )?;
 
     // store current PC and set PC to beginning of subroutine
-    let previous_pc = core.read_core_reg(PC)?;
+    let previous_pc: RegisterValue = core.read_core_reg(PC)?;
     core.write_core_reg(PC, start)?;
 
     // execute the subroutine and wait for it to finish
     core.run()?;
     core.wait_for_core_halted(TIMEOUT)?;
 
     // overwrite subroutine
-    core.write_8(start, &[CANARY_VALUE; SUBROUTINE_LENGTH])?;
+    core.write_8(start.into(), &[CANARY_VALUE; SUBROUTINE_LENGTH])?;
 
     // reset PC to where it was before
     core.write_core_reg(PC, previous_pc)?;

src/canary.rs

@@ -200,8 +200,8 @@ fn extract_symbols(elf: &ObjectFile) -> anyhow::Result<Symbols> {
         main_fn_address.ok_or_else(|| anyhow!("`main` symbol not found"))?;
 
     Ok(Symbols {
-        rtt_buffer_address,
+        rtt_buffer_address: rtt_buffer_address.map(|v| v.into()),
         program_uses_heap,
-        main_fn_address: main_function_address,
+        main_fn_address: main_function_address.into(),
     })
 }

src/elf.rs

@@ -27,7 +27,7 @@ use probe_rs::{
     flashing::{self, Format},
     Core,
     DebugProbeError::ProbeSpecific,
-    MemoryInterface as _, Session,
+    MemoryInterface as _, Permissions, Session,
 };
 use probe_rs_rtt::{Rtt, ScanRegion, UpChannel};
 use signal_hook::consts::signal;
@@ -63,9 +63,9 @@ fn run_target_program(elf_path: &Path, chip_name: &str, opts: &cli::Opts) -> any
 
     let probe_target = target_info.probe_target.clone();
     let mut sess = if opts.connect_under_reset {
-        probe.attach_under_reset(probe_target)?
+        probe.attach_under_reset(probe_target, Permissions::default())?
     } else {
-        let probe_attach = probe.attach(probe_target);
+        let probe_attach = probe.attach(probe_target, Permissions::default());
         if let Err(probe_rs::Error::Probe(ProbeSpecific(e))) = &probe_attach {
             // FIXME Using `to_string().contains(...)` is a workaround as the concrete type
             // of `e` is not public and therefore does not allow downcasting.
@@ -187,7 +187,7 @@ fn start_program(sess: &mut Session, elf: &Elf) -> anyhow::Result<()> {
     let mut core = sess.core(0)?;
 
     log::debug!("starting device");
-    if core.get_available_breakpoint_units()? == 0 {
+    if core.available_breakpoint_units()? == 0 {
         if elf.rtt_buffer_address().is_some() {
             bail!("RTT not supported on device without HW breakpoints");
         } else {
@@ -199,7 +199,7 @@ fn start_program(sess: &mut Session, elf: &Elf) -> anyhow::Result<()> {
         set_rtt_to_blocking(&mut core, elf.main_fn_address(), rtt_buffer_address)?
     }
 
-    core.set_hw_breakpoint(cortexm::clear_thumb_bit(elf.vector_table.hard_fault))?;
+    core.set_hw_breakpoint(cortexm::clear_thumb_bit(elf.vector_table.hard_fault).into())?;
     core.run()?;
 
     Ok(())
@@ -212,7 +212,7 @@ fn set_rtt_to_blocking(
     rtt_buffer_address: u32,
 ) -> anyhow::Result<()> {
     // set and wait for a hardware breakpoint at the beginning of `fn main()`
-    core.set_hw_breakpoint(main_fn_address)?;
+    core.set_hw_breakpoint(main_fn_address.into())?;
     core.run()?;
     core.wait_for_core_halted(Duration::from_secs(5))?;
 
@@ -222,16 +222,16 @@ fn set_rtt_to_blocking(
 
     // read flags
     let channel_flags = &mut [0];
-    core.read_32(rtt_buffer_address, channel_flags)?;
+    core.read_32(rtt_buffer_address.into(), channel_flags)?;
     // modify flags to blocking
     const MODE_MASK: u32 = 0b11;
     const MODE_BLOCK_IF_FULL: u32 = 0b10;
     let modified_channel_flags = (channel_flags[0] & !MODE_MASK) | MODE_BLOCK_IF_FULL;
     // write flags back
-    core.write_word_32(rtt_buffer_address, modified_channel_flags)?;
+    core.write_word_32(rtt_buffer_address.into(), modified_channel_flags)?;
 
     // clear the breakpoint we set before
-    core.clear_hw_breakpoint(main_fn_address)?;
+    core.clear_hw_breakpoint(main_fn_address.into())?;
 
     Ok(())
 }