Modifying locals potentially broken with recent Rust #236

Activity

3. netzdoktor commented on May 22, 2020

   

   netzdoktor

   on May 22, 2020

   Author

   More actions

   Thanks for looking into assembly and confirming my hypothesis. Your code makes sense but is indeed "strange".

   I wondered if one could make the variable volatile as it is also done in the register section of the book.

   I found the volatile crate, which could be used for that. Still, a developer would not per-se make this variable volatile, as it actually is not expected to change without doing live-rewrite in the debugger. But that would at least provide similar "changability" while having less contrived code.

   Maybe leveraging volatile and explaining the details in a "note"-box would educate the reader and make the example work again.
4. yerke commented on Jul 1, 2020

   

   yerke

   on Jul 1, 2020

   Contributor

   More actions

   I also just ran into this issue. @wupdiduh thanks for finding a workaround. I had to modify it a bit:

   let mut half_period = 500_u16;
   delay.delay_ms(half_period);
   half_period = 100;
   
   loop {
   

   I had to use half_period before changing the value, so the compiler wouldn't optimize it away.

   👍React with 👍2Reacted by Sam Evaskitas and Julian Oes
5. mbrubeck commented on Nov 29, 2020

   

   mbrubeck

   on Nov 29, 2020

   More actions

   From a thread in the Rust forum:

   I believe this is a result of MIR constant propagation, which is done by rustc before it generates LLVM IR and runs LLVM's optimization passes. In recent versions of rustc, MIR constant propagation is enabled by default in debug mode because it reduces compile times. You can disable it using the -Zmir-opt-level=0 rustc flag (requires a nightly build of the Rust toolchain).
6. migueloller commented on Dec 1, 2020

   

   migueloller

   on Dec 1, 2020

   More actions

   Unfortunately using -Zmir-opt-level doesn't work. I've only been able to get around the optimization by doing what @yerke did.
7. winksaville commented on Dec 23, 2020

   

   winksaville

   on Dec 23, 2020

   Contributor

   More actions

   Here are a couple other solutions I came up with.

   1. Use the volatile crate:

   Cargo.toml to add volatile = "0.4.2" as a dependency:

   [dependencies]
   aux5 = { path = "auxiliary" }
   volatile = "0.4.2"
   

   And the main.rs is now:

   #![deny(unsafe_code)]
   #![no_main]
   #![no_std]
   
   use aux5::{entry, prelude::*, Delay, Leds};
   use volatile::Volatile;
   
   #[entry]
   fn main() -> ! {
       let (mut delay, mut leds): (Delay, Leds) = aux5::init();
   
       let mut half_period = 2000_u16;
       let v_half_period = Volatile::new(&mut half_period);
   
       loop {
           leds[0].on();
           delay.delay_ms(v_half_period.read());
   
           leds[0].off();
           delay.delay_ms(v_half_period.read());
       }
   }
   

   2. Use Atomics:

   #![deny(unsafe_code)]
   #![no_main]
   #![no_std]
   
   use aux5::{entry, prelude::*, Delay, Leds};
   use core::sync::atomic::{AtomicU16, Ordering};
   
   #[entry]
   fn main() -> ! {
       let (mut delay, mut leds): (Delay, Leds) = aux5::init();
   
       let half_period = AtomicU16::new(2000_u16);
   
       loop {
           leds[0].on();
           delay.delay_ms(half_period.load(Ordering::Relaxed));
   
           leds[0].off();
           delay.delay_ms(half_period.load(Ordering::Relaxed));
       }
   }
   

   Change half_period with:

   (gdb) set half_period = core::sync::atomic::AtomicU16::new(100)