Merge remote-tracking branch 'origin/master' into affine

.github/workflows/build-and-test.yml

@@ -5,6 +5,8 @@ on:
     branches: [ master ]
   pull_request:
     branches: [ master ]
+  schedule:
+    - cron: '10 5 * * *'
 
 env:
   CARGO_TERM_COLOR: always

.vscode/agb.code-workspace

@@ -23,6 +23,12 @@
 		},
 		{
 			"path": "../examples/hyperspace-roll"
+		},
+		{
+			"path": "../.github"
+		},
+		{
+			"path": "../template"
 		}
 	]
 }

CHANGELOG.md

@@ -10,9 +10,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Custom allocator support using the `Allocator` trait for `HashMap`. This means the `HashMap` can be used with `InternalAllocator` to allocate to IWRAM or the `ExternalAllocator` to explicitly allocate to EWRAM.
 - Support for using windows on the GBA. Windows are used to selectively enable rendering of certain layers or effects.
 - Support for the blend mode of the GBA. Blending allows for alpha blending between layers and fading to black and white.
+- Added a new agb::sync module that contains GBA-specific synchronization primitives.
 
-## Fixed
+### Changes
+- Many of the places that originally disabled IRQs now use the `sync` module, reducing the chance of missed interrupts.
+
+### Fixed
 - Fixed the fast magnitude function in agb_fixnum. This is also used in fast_normalise. Previously only worked for positive (x, y).
+- Fixed formatting of fixed point numbers in the range (-1, 0), which previously appeared positive.
+
+## Changed
+- `testing` is now a default feature, so you no longer need to add a separate `dev-dependencies` line for `agb` in order to enable unit tests for your project.
 
 ## [0.11.1] - 2022/08/02
 

agb-fixnum/src/lib.rs

@@ -537,6 +537,11 @@ impl<I: FixedWidthUnsignedInteger, const N: usize> Display for Num<I, N> {
         // So we have to add 1 to the integral bit, and take 1 - fractional bit
         if fractional != I::zero() && integral < I::zero() {
             integral = integral + I::one();
+            if integral == I::zero() {
+                // If the number is in the range (-1, 0), then we just bumped `integral` from -1 to 0,
+                // so we need to compensate for the missing negative sign.
+                write!(f, "-")?;
+            }
             fractional = (I::one() << N) - fractional;
         }
 
@@ -1029,15 +1034,17 @@ mod tests {
     #[test]
     fn formats_fractions_correctly() {
         let a = Num::<i32, 8>::new(5);
-        let two = Num::<i32, 8>::new(4);
+        let four = Num::<i32, 8>::new(4);
         let minus_one = Num::<i32, 8>::new(-1);
 
-        let b: Num<i32, 8> = a / two;
+        let b: Num<i32, 8> = a / four;
         let c: Num<i32, 8> = b * minus_one;
+        let d: Num<i32, 8> = minus_one / four;
 
         assert_eq!(b + c, 0.into());
         assert_eq!(format!("{}", b), "1.25");
         assert_eq!(format!("{}", c), "-1.25");
+        assert_eq!(format!("{}", d), "-0.25");
     }
 
     #[test]

agb-sound-converter/Cargo.toml

@@ -23,7 +23,7 @@ freq18157 = []
 freq32768 = []
 
 [dependencies]
-hound = "3.4"
+hound = "3.5"
 syn = "1"
 proc-macro2 = "1"
 quote = "1"

agb/Cargo.toml

@@ -16,7 +16,7 @@ lto = true
 debug = true
 
 [features]
-default = []
+default = ["testing"]
 freq18157 = ["agb_sound_converter/freq18157"]
 freq32768 = ["agb_sound_converter/freq32768"]
 testing = []

agb/build.rs

@@ -36,7 +36,7 @@ fn main() {
             .arg("-mthumb-interwork")
             .arg("-mcpu=arm7tdmi")
             .arg("-g")
-            .args(&["-o", out_file_path.as_str()])
+            .args(["-o", out_file_path.as_str()])
             .arg(a)
             .output()
             .unwrap_or_else(|_| panic!("failed to compile {}", a));

agb/examples/output.rs

@@ -1,19 +1,17 @@
 #![no_std]
 #![no_main]
 
-use core::cell::RefCell;
+use agb::sync::Static;
-
-use bare_metal::{CriticalSection, Mutex};
 
 #[agb::entry]
 fn main(_gba: agb::Gba) -> ! {
-    let count = Mutex::new(RefCell::new(0));
+    let count = Static::new(0);
     let _a = agb::interrupt::add_interrupt_handler(
         agb::interrupt::Interrupt::VBlank,
-        |key: CriticalSection| {
+        |_| {
-            let mut count = count.borrow(key).borrow_mut();
+            let cur_count = count.read();
-            agb::println!("Hello, world, frame = {}", *count);
+            agb::println!("Hello, world, frame = {}", cur_count);
-            *count += 1;
+            count.write(cur_count + 1);
         },
     );
     loop {}

agb/src/interrupt.rs

@@ -288,7 +288,7 @@ pub fn add_interrupt_handler<'a>(
 /// [`CriticalSection`]
 ///
 /// [`CriticalSection`]: bare_metal::CriticalSection
-pub fn free<F, R>(f: F) -> R
+pub fn free<F, R>(mut f: F) -> R
 where
     F: FnOnce(CriticalSection) -> R,
 {
@@ -296,7 +296,13 @@ where
 
     disable_interrupts();
 
-    let r = f(unsafe { CriticalSection::new() });
+    // prevents the contents of the function from being reordered before IME is disabled.
+    crate::sync::memory_write_hint(&mut f);
+
+    let mut r = f(unsafe { CriticalSection::new() });
+
+    // prevents the contents of the function from being reordered after IME is re-enabled.
+    crate::sync::memory_write_hint(&mut r);
 
     INTERRUPTS_ENABLED.set(enabled);
     r

agb/src/lib.rs

@@ -13,6 +13,7 @@
 #![feature(alloc_error_handler)]
 #![feature(allocator_api)]
 #![feature(asm_const)]
+#![feature(isa_attribute)]
 #![warn(clippy::all)]
 #![deny(clippy::must_use_candidate)]
 #![deny(clippy::trivially_copy_pass_by_ref)]
@@ -170,6 +171,8 @@ pub mod rng;
 mod single;
 /// Implements sound output.
 pub mod sound;
+/// A module containing functions and utilities useful for synchronizing state.
+pub mod sync;
 /// System BIOS calls / syscalls.
 pub mod syscall;
 /// Interactions with the internal timers
@@ -247,22 +250,16 @@ impl Gba {
 /// In order to use this, you need to enable the unstable `custom_test_framework` feature and copy-paste
 /// the following into the top of your application:
 ///
-/// ```
+/// ```rust,ignore
 /// #![cfg_attr(test, feature(custom_test_frameworks))]
 /// #![cfg_attr(test, reexport_test_harness_main = "test_main")]
 /// #![cfg_attr(test, test_runner(agb::test_runner::test_runner))]
 /// ```
 ///
-/// And ensure you add agb with the `testing` feature to your `dev-dependencies`
-/// ```toml
-/// [dev-dependencies]
-/// agb = { version = "<same as in dependencies>", features = ["testing"] }
-/// ```
-///
 /// With this support, you will be able to write tests which you can run using `mgba-test-runner`.
 /// Tests are written using `#[test_case]` rather than `#[test]`.
 ///
-/// ```
+/// ```rust,ignore
 /// #[test_case]
 /// fn test_ping_pong(_gba: &mut Gba) {
 ///     assert_eq!(1, 1);

agb/src/sync/locks.rs

@@ -0,0 +1,203 @@
+use crate::sync::Static;
+use core::cell::UnsafeCell;
+use core::mem::MaybeUninit;
+use core::ops::{Deref, DerefMut};
+use core::ptr;
+use core::sync::atomic::{compiler_fence, Ordering};
+
+#[inline(never)]
+fn already_locked() -> ! {
+    panic!("IRQ and main thread are attempting to access the same Mutex!")
+}
+
+/// A mutex that prevents code from running in both an IRQ and normal code at
+/// the same time.
+///
+/// Note that this does not support blocking like a typical mutex, and instead
+/// mainly exists for memory safety reasons.
+pub struct RawMutex(Static<bool>);
+impl RawMutex {
+    /// Creates a new lock.
+    #[must_use]
+    pub const fn new() -> Self {
+        RawMutex(Static::new(false))
+    }
+
+    /// Locks the mutex and returns whether a lock was successfully acquired.
+    fn raw_lock(&self) -> bool {
+        if self.0.replace(true) {
+            // value was already true, opps.
+            false
+        } else {
+            // prevent any weird reordering, and continue
+            compiler_fence(Ordering::Acquire);
+            true
+        }
+    }
+
+    /// Unlocks the mutex.
+    fn raw_unlock(&self) {
+        compiler_fence(Ordering::Release);
+        if !self.0.replace(false) {
+            panic!("Internal error: Attempt to unlock a `RawMutex` which is not locked.")
+        }
+    }
+
+    /// Returns a guard for this lock, or panics if there is another lock active.
+    pub fn lock(&self) -> RawMutexGuard<'_> {
+        self.try_lock().unwrap_or_else(|| already_locked())
+    }
+
+    /// Returns a guard for this lock, or `None` if there is another lock active.
+    pub fn try_lock(&self) -> Option<RawMutexGuard<'_>> {
+        if self.raw_lock() {
+            Some(RawMutexGuard(self))
+        } else {
+            None
+        }
+    }
+}
+unsafe impl Send for RawMutex {}
+unsafe impl Sync for RawMutex {}
+
+/// A guard representing an active lock on an [`RawMutex`].
+pub struct RawMutexGuard<'a>(&'a RawMutex);
+impl<'a> Drop for RawMutexGuard<'a> {
+    fn drop(&mut self) {
+        self.0.raw_unlock();
+    }
+}
+
+/// A mutex that protects an object from being accessed in both an IRQ and
+/// normal code at once.
+///
+/// Note that this does not support blocking like a typical mutex, and instead
+/// mainly exists for memory safety reasons.
+pub struct Mutex<T> {
+    raw: RawMutex,
+    data: UnsafeCell<T>,
+}
+impl<T> Mutex<T> {
+    /// Creates a new lock containing a given value.
+    #[must_use]
+    pub const fn new(t: T) -> Self {
+        Mutex { raw: RawMutex::new(), data: UnsafeCell::new(t) }
+    }
+
+    /// Returns a guard for this lock, or panics if there is another lock active.
+    pub fn lock(&self) -> MutexGuard<'_, T> {
+        self.try_lock().unwrap_or_else(|| already_locked())
+    }
+
+    /// Returns a guard for this lock or `None` if there is another lock active.
+    pub fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+        if self.raw.raw_lock() {
+            Some(MutexGuard { underlying: self, ptr: self.data.get() })
+        } else {
+            None
+        }
+    }
+}
+unsafe impl<T> Send for Mutex<T> {}
+unsafe impl<T> Sync for Mutex<T> {}
+
+/// A guard representing an active lock on an [`Mutex`].
+pub struct MutexGuard<'a, T> {
+    underlying: &'a Mutex<T>,
+    ptr: *mut T,
+}
+impl<'a, T> Drop for MutexGuard<'a, T> {
+    fn drop(&mut self) {
+        self.underlying.raw.raw_unlock();
+    }
+}
+impl<'a, T> Deref for MutexGuard<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.ptr }
+    }
+}
+impl<'a, T> DerefMut for MutexGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *self.ptr }
+    }
+}
+
+enum Void {}
+
+/// A helper type that ensures a particular value is only initialized once.
+pub struct InitOnce<T> {
+    is_initialized: Static<bool>,
+    value: UnsafeCell<MaybeUninit<T>>,
+}
+impl<T> InitOnce<T> {
+    /// Creates a new uninitialized object.
+    #[must_use]
+    pub const fn new() -> Self {
+        InitOnce {
+            is_initialized: Static::new(false),
+            value: UnsafeCell::new(MaybeUninit::uninit()),
+        }
+    }
+
+    /// Gets the contents of this state, or initializes it if it has not already
+    /// been initialized.
+    ///
+    /// The initializer function is guaranteed to only be called once.
+    ///
+    /// This function disables IRQs while it is initializing the inner value.
+    /// While this can cause audio skipping and other similar issues, it is
+    /// not normally a problem as interrupts will only be disabled once per
+    /// `InitOnce` during the life cycle of the program.
+    pub fn get(&self, initializer: impl FnOnce() -> T) -> &T {
+        match self.try_get(|| -> Result<T, Void> { Ok(initializer()) }) {
+            Ok(v) => v,
+            _ => unimplemented!(),
+        }
+    }
+
+    /// Gets the contents of this state, or initializes it if it has not already
+    /// been initialized.
+    ///
+    /// The initializer function is guaranteed to only be called once if it
+    /// returns `Ok`. If it returns `Err`, it will be called again in the
+    /// future until an attempt at initialization succeeds.
+    ///
+    /// This function disables IRQs while it is initializing the inner value.
+    /// While this can cause audio skipping and other similar issues, it is
+    /// not normally a problem as interrupts will only be disabled once per
+    /// `InitOnce` during the life cycle of the program.
+    pub fn try_get<E>(&self, initializer: impl FnOnce() -> Result<T, E>) -> Result<&T, E> {
+        unsafe {
+            if !self.is_initialized.read() {
+                // We disable interrupts to make this simpler, since this is likely to
+                // only occur once in a program anyway.
+                crate::interrupt::free(|_| -> Result<(), E> {
+                    // We check again to make sure this function wasn't called in an
+                    // interrupt between the first check and when interrupts were
+                    // actually disabled.
+                    if !self.is_initialized.read() {
+                        // Do the actual initialization.
+                        ptr::write_volatile((*self.value.get()).as_mut_ptr(), initializer()?);
+                        self.is_initialized.write(true);
+                    }
+                    Ok(())
+                })?;
+            }
+            compiler_fence(Ordering::Acquire);
+            Ok(&*(*self.value.get()).as_mut_ptr())
+        }
+    }
+}
+impl<T> Drop for InitOnce<T> {
+    fn drop(&mut self) {
+        if self.is_initialized.read() {
+            // drop the value inside the `MaybeUninit`
+            unsafe {
+                ptr::read((*self.value.get()).as_ptr());
+            }
+        }
+    }
+}
+unsafe impl<T: Send> Send for InitOnce<T> {}
+unsafe impl<T: Sync> Sync for InitOnce<T> {}

agb/src/sync/mod.rs

@@ -0,0 +1,48 @@
+mod locks;
+mod statics;
+
+pub use locks::*;
+pub use statics::*;
+
+use core::arch::asm;
+
+/// Marks that a pointer is read without actually reading from this.
+///
+/// This uses an [`asm!`] instruction that marks the parameter as being read,
+/// requiring the compiler to treat this function as if anything could be
+/// done to it.
+#[inline(always)]
+pub fn memory_read_hint<T>(val: *const T) {
+    unsafe { asm!("/* {0} */", in(reg) val, options(readonly, nostack)) }
+}
+
+/// Marks that a pointer is read or written to without actually writing to it.
+///
+/// This uses an [`asm!`] instruction that marks the parameter as being read
+/// and written, requiring the compiler to treat this function as if anything
+/// could be done to it.
+#[inline(always)]
+pub fn memory_write_hint<T>(val: *mut T) {
+    unsafe { asm!("/* {0} */", in(reg) val, options(nostack)) }
+}
+
+/// An internal function used as a temporary hack to get `compiler_fence`
+/// working. While this call is not properly inlined, working is better than not
+/// working at all.
+///
+/// This seems to be a problem caused by Rust issue #62256:
+/// <https://github.com/rust-lang/rust/issues/62256>
+///
+/// **WARNING FOR ANYONE WHO FINDS THIS**: This implementation will *only* be
+/// correct on the GBA, and should not be used on any other platform. The GBA
+/// is very old, and has no atomics to begin with - only a main thread and
+/// interrupts. On any more recent CPU, this implementation is extremely
+/// unlikely to be sound.
+///
+/// Not public API, obviously.
+#[doc(hidden)]
+#[deprecated]
+#[allow(dead_code)]
+#[no_mangle]
+#[inline(always)]
+pub unsafe extern "C" fn __sync_synchronize() {}

agb/src/sync/statics.rs

@@ -0,0 +1,329 @@
+use core::arch::asm;
+use core::cell::UnsafeCell;
+use core::mem;
+use core::ptr;
+
+/// The internal function for replacing a `Copy` (really `!Drop`) value in a
+/// [`Static`]. This uses assembly to use an `stmia` instruction to ensure
+/// an IRQ cannot occur during the write operation.
+unsafe fn transfer<T: Copy>(dst: *mut T, src: *const T) {
+    let align = mem::align_of::<T>();
+    let size = mem::size_of::<T>();
+
+    if size == 0 {
+        // Do nothing with ZSTs.
+    } else if size <= 16 && align % 4 == 0 {
+        // We can do an 4-byte aligned transfer up to 16 bytes.
+        transfer_align4_thumb(dst, src);
+    } else if size <= 40 && align % 4 == 0 {
+        // We can do the same up to 40 bytes, but we need to switch to ARM.
+        transfer_align4_arm(dst, src);
+    } else if size <= 2 && align % 2 == 0 {
+        // We can do a 2-byte aligned transfer up to 2 bytes.
+        asm!(
+            "ldrh {2},[{0}]",
+            "strh {2},[{1}]",
+            in(reg) src, in(reg) dst, out(reg) _,
+        );
+    } else if size == 1 {
+        // We can do a simple byte copy.
+        asm!(
+            "ldrb {2},[{0}]",
+            "strb {2},[{1}]",
+            in(reg) src, in(reg) dst, out(reg) _,
+        );
+    } else {
+        // When we don't have an optimized path, we just disable IRQs.
+        crate::interrupt::free(|_| ptr::write_volatile(dst, ptr::read_volatile(src)));
+    }
+}
+
+#[allow(unused_assignments)]
+unsafe fn transfer_align4_thumb<T: Copy>(mut dst: *mut T, mut src: *const T) {
+    let size = mem::size_of::<T>();
+
+    if size <= 4 {
+        // We use assembly here regardless to just do the word aligned copy. This
+        // ensures it's done with a single ldr/str instruction.
+        asm!(
+            "ldr {2},[{0}]",
+            "str {2},[{1}]",
+            inout(reg) src, in(reg) dst, out(reg) _,
+        );
+    } else if size <= 8 {
+        // Starting at size == 8, we begin using ldmia/stmia to load/save multiple
+        // words in one instruction, avoiding IRQs from interrupting our operation.
+        asm!(
+            "ldmia {0}!, {{r2-r3}}",
+            "stmia {1}!, {{r2-r3}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _,
+        );
+    } else if size <= 12 {
+        asm!(
+            "ldmia {0}!, {{r2-r4}}",
+            "stmia {1}!, {{r2-r4}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _,
+        );
+    } else if size <= 16 {
+        asm!(
+            "ldmia {0}!, {{r2-r5}}",
+            "stmia {1}!, {{r2-r5}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _,
+        );
+    } else {
+        unimplemented!("This should be done via transfer_arm.");
+    }
+}
+
+#[instruction_set(arm::a32)]
+#[allow(unused_assignments)]
+unsafe fn transfer_align4_arm<T: Copy>(mut dst: *mut T, mut src: *const T) {
+    let size = mem::size_of::<T>();
+
+    if size <= 16 {
+        unimplemented!("This should be done via transfer_thumb.");
+    } else if size <= 20 {
+        // Starting at size == 16, we have to switch to ARM due to lack of
+        // accessible registers in THUMB mode.
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7}}",
+            "stmia {1}!, {{r2-r5,r7}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+        );
+    } else if size <= 24 {
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7-r8}}",
+            "stmia {1}!, {{r2-r5,r7-r8}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+            out("r8") _,
+        );
+    } else if size <= 28 {
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7-r9}}",
+            "stmia {1}!, {{r2-r5,r7-r9}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+            out("r8") _, out("r9") _,
+        );
+    } else if size <= 32 {
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7-r10}}",
+            "stmia {1}!, {{r2-r5,r7-r10}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+            out("r8") _, out("r9") _, out("r10") _,
+        );
+    } else if size <= 36 {
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7-r10,r12}}",
+            "stmia {1}!, {{r2-r5,r7-r10,r12}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+            out("r8") _, out("r9") _, out("r10") _, out("r12") _,
+        );
+    } else if size <= 40 {
+        asm!(
+            "ldmia {0}!, {{r2-r5,r7-r10,r12,r14}}",
+            "stmia {1}!, {{r2-r5,r7-r10,r12,r14}}",
+            inout(reg) src, inout(reg) dst,
+            out("r2") _, out("r3") _, out("r4") _, out("r5") _, out("r7") _,
+            out("r8") _, out("r9") _, out("r10") _, out("r12") _, out("r14") _,
+        );
+    } else {
+        // r13 is sp, and r15 is pc. Neither are usable
+        unimplemented!("Copy too large for use of ldmia/stmia.");
+    }
+}
+
+/// The internal function for swapping the current value of a [`Static`] with
+/// another value.
+unsafe fn exchange<T>(dst: *mut T, src: *const T) -> T {
+    let align = mem::align_of::<T>();
+    let size = mem::size_of::<T>();
+    if size == 0 {
+        // Do nothing with ZSTs.
+        ptr::read(dst)
+    } else if size <= 4 && align % 4 == 0 {
+        // Swap a single word with the SWP instruction.
+        let val = ptr::read(src as *const u32);
+        let new_val = exchange_align4_arm(dst, val);
+        ptr::read(&new_val as *const _ as *const T)
+    } else if size == 1 {
+        // Swap a byte with the SWPB instruction.
+        let val = ptr::read(src as *const u8);
+        let new_val = exchange_align1_arm(dst, val);
+        ptr::read(&new_val as *const _ as *const T)
+    } else {
+        // fallback
+        crate::interrupt::free(|_| {
+            let cur = ptr::read_volatile(dst);
+            ptr::write_volatile(dst, ptr::read_volatile(src));
+            cur
+        })
+    }
+}
+
+#[instruction_set(arm::a32)]
+unsafe fn exchange_align4_arm<T>(dst: *mut T, i: u32) -> u32 {
+    let out;
+    asm!("swp {2}, {1}, [{0}]", in(reg) dst, in(reg) i, lateout(reg) out);
+    out
+}
+
+#[instruction_set(arm::a32)]
+unsafe fn exchange_align1_arm<T>(dst: *mut T, i: u8) -> u8 {
+    let out;
+    asm!("swpb {2}, {1}, [{0}]", in(reg) dst, in(reg) i, lateout(reg) out);
+    out
+}
+
+/// A helper that implements static variables.
+///
+/// It ensures that even if you use the same static variable in both an IRQ
+/// and normal code, the IRQ will never observe an invalid value of the
+/// variable.
+///
+/// This type only works with owned values. If you need to work with borrows,
+/// consider using [`sync::Mutex`](`crate::sync::Mutex`) instead.
+///
+/// ## Performance
+///
+/// Writing or reading from a static variable is efficient under the following
+/// conditions:
+///
+/// * The type is aligned to 4 bytes and can be stored in 40 bytes or less.
+/// * The type is aligned to 2 bytes and can be stored in 2 bytes.
+/// * The type is can be stored in a single byte.
+///
+/// Replacing the current value of the static variable is efficient under the
+/// following conditions:
+///
+/// * The type is aligned to 4 bytes and can be stored in 4 bytes or less.
+/// * The type is can be stored in a single byte.
+///
+/// When these conditions are not met, static variables are handled using a
+/// fallback routine that disables IRQs and does a normal copy. This can be
+/// dangerous as disabling IRQs can cause your program to miss out on important
+/// interrupts such as V-Blank.
+///
+/// Consider using [`sync::Mutex`](`crate::sync::Mutex`) instead if you need to
+/// use a large amount of operations that would cause IRQs to be disabled. Also
+/// consider using `#[repr(align(4))]` to force proper alignment for your type.
+pub struct Static<T> {
+    data: UnsafeCell<T>,
+}
+impl<T> Static<T> {
+    /// Creates a new static variable.
+    pub const fn new(val: T) -> Self {
+        Static { data: UnsafeCell::new(val) }
+    }
+
+    /// Replaces the current value of the static variable with another, and
+    /// returns the old value.
+    #[allow(clippy::needless_pass_by_value)] // critical for safety
+    pub fn replace(&self, val: T) -> T {
+        unsafe { exchange(self.data.get(), &val) }
+    }
+
+    /// Extracts the interior value of the static variable.
+    pub fn into_inner(self) -> T {
+        self.data.into_inner()
+    }
+}
+impl<T: Copy> Static<T> {
+    /// Writes a new value into this static variable.
+    pub fn write(&self, val: T) {
+        unsafe { transfer(self.data.get(), &val) }
+    }
+
+    /// Reads a value from this static variable.
+    pub fn read(&self) -> T {
+        unsafe {
+            let mut out: mem::MaybeUninit<T> = mem::MaybeUninit::uninit();
+            transfer(out.as_mut_ptr(), self.data.get());
+            out.assume_init()
+        }
+    }
+}
+impl<T: Default> Default for Static<T> {
+    fn default() -> Self {
+        Static::new(T::default())
+    }
+}
+unsafe impl<T> Send for Static<T> {}
+unsafe impl<T> Sync for Static<T> {}
+
+#[cfg(test)]
+mod test {
+    use crate::Gba;
+    use crate::interrupt::Interrupt;
+    use crate::sync::Static;
+    use crate::timer::Divider;
+
+    fn write_read_concurrency_test_impl<const COUNT: usize>(gba: &mut Gba) {
+        let sentinel = [0x12345678; COUNT];
+        let value: Static<[u32; COUNT]> = Static::new(sentinel);
+
+        // set up a timer and an interrupt that uses the timer
+        let mut timer = gba.timers.timers().timer2;
+        timer.set_cascade(false);
+        timer.set_divider(Divider::Divider1);
+        timer.set_overflow_amount(1049);
+        timer.set_interrupt(true);
+        timer.set_enabled(true);
+
+        let _int = crate::interrupt::add_interrupt_handler(Interrupt::Timer2, |_| {
+            value.write(sentinel);
+        });
+
+        // the actual main test loop
+        let mut interrupt_seen = false;
+        let mut no_interrupt_seen = false;
+        for i in 0..100000 {
+            // write to the static
+            let new_value = [i; COUNT];
+            value.write(new_value);
+
+            // check the current value
+            let current = value.read();
+            if current == new_value {
+                no_interrupt_seen = true;
+            } else if current == sentinel {
+                interrupt_seen = true;
+            } else {
+                panic!("Unexpected value found in `Static`.");
+            }
+
+            // we return as soon as we've seen both the value written by the main thread
+            // and interrupt
+            if interrupt_seen && no_interrupt_seen {
+                timer.set_enabled(false);
+                return
+            }
+
+            if i % 8192 == 0 && i != 0 {
+                timer.set_overflow_amount(1049 + (i / 64) as u16);
+            }
+        }
+        panic!("Concurrency test timed out: {}", COUNT)
+    }
+
+    #[test_case]
+    fn write_read_concurrency_test(gba: &mut Gba) {
+        write_read_concurrency_test_impl::<1>(gba);
+        write_read_concurrency_test_impl::<2>(gba);
+        write_read_concurrency_test_impl::<3>(gba);
+        write_read_concurrency_test_impl::<4>(gba);
+        write_read_concurrency_test_impl::<5>(gba);
+        write_read_concurrency_test_impl::<6>(gba);
+        write_read_concurrency_test_impl::<7>(gba);
+        write_read_concurrency_test_impl::<8>(gba);
+        write_read_concurrency_test_impl::<9>(gba);
+        write_read_concurrency_test_impl::<10>(gba);
+    }
+}

agb/src/timer.rs

@@ -79,13 +79,13 @@ impl Timer {
     }
 
     pub fn set_enabled(&mut self, enabled: bool) -> &mut Self {
-        let bit = if enabled { 1 } else { 0 };
+        let bit = u16::from(enabled);
         self.control_register().set_bits(bit, 1, 7);
         self
     }
 
     pub fn set_cascade(&mut self, cascade: bool) -> &mut Self {
-        let bit = if cascade { 1 } else { 0 };
+        let bit = u16::from(cascade);
         self.control_register().set_bits(bit, 1, 2);
         self
     }

armv4t-none-eabi.json

@@ -1,23 +0,0 @@
-{
-    "arch": "arm",
-    "asm-args": [
-        "-mthumb-interwork",
-        "-march=armv4t",
-        "-mcpu=arm7tdmi",
-        "-mlittle-endian"
-    ],
-    "atomic-cas": false,
-    "data-layout": "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64",
-    "emit-debug-gdb-scripts": false,
-    "executables": true,
-    "features": "+soft-float,+strict-align",
-    "has-thumb-interworking": true,
-    "linker": "arm-none-eabi-ld",
-    "linker-flavor": "ld",
-    "linker-is-gnu": true,
-    "llvm-target": "armv4t-none-eabi",
-    "main-needs-argc-argv": false,
-    "panic-strategy": "abort",
-    "relocation-model": "static",
-    "target-pointer-width": "32"
-}

book/games/pong/Cargo.lock

@@ -113,9 +113,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bytemuck"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5377c8865e74a160d21f29c2d40669f53286db6eab59b88540cbb12ffc8b835"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 
 [[package]]
 name = "byteorder"
@@ -161,7 +161,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
- "miniz_oxide 0.5.3",
+ "miniz_oxide 0.5.4",
 ]
 
 [[package]]
@@ -196,9 +196,9 @@ dependencies = [
 
 [[package]]
 name = "hound"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a164bb2ceaeff4f42542bdb847c41517c78a60f5649671b2a07312b6e117549"
+checksum = "4d13cdbd5dbb29f9c88095bbdc2590c9cba0d0a1269b983fef6b2cdd7e9f4db1"
 
 [[package]]
 name = "image"
@@ -217,9 +217,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "log"
@@ -241,9 +241,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -318,9 +318,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.13.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
+checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
 
 [[package]]
 name = "png"
@@ -343,18 +343,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278e965f1d8cf32d6e0e96de3d3e79712178ae67986d9cf9151f51e95aac89b"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
@@ -367,18 +367,18 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "serde"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7af873f2c95b99fcb0bd0fe622a43e29514658873c8ceba88c4cb88833a22500"
+checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75743a150d003dd863b51dc809bcad0d73f2102c53632f1e954e738192a3413f"
+checksum = "94ed3a816fb1d101812f83e789f888322c34e291f894f19590dc310963e87a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -393,9 +393,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "syn"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -419,9 +419,9 @@ checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c61ba63f9235225a22310255a29b806b907c9b8c964bcbd0a2c70f3f2deea7"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
 
 [[package]]
 name = "version_check"

examples/hyperspace-roll/Cargo.lock

@@ -113,9 +113,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bytemuck"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5377c8865e74a160d21f29c2d40669f53286db6eab59b88540cbb12ffc8b835"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 
 [[package]]
 name = "byteorder"
@@ -161,7 +161,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
- "miniz_oxide 0.5.3",
+ "miniz_oxide 0.5.4",
 ]
 
 [[package]]
@@ -196,9 +196,9 @@ dependencies = [
 
 [[package]]
 name = "hound"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a164bb2ceaeff4f42542bdb847c41517c78a60f5649671b2a07312b6e117549"
+checksum = "4d13cdbd5dbb29f9c88095bbdc2590c9cba0d0a1269b983fef6b2cdd7e9f4db1"
 
 [[package]]
 name = "hyperspace-roll"
@@ -225,9 +225,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "log"
@@ -249,9 +249,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.13.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
+checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
 
 [[package]]
 name = "png"
@@ -344,18 +344,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278e965f1d8cf32d6e0e96de3d3e79712178ae67986d9cf9151f51e95aac89b"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
@@ -368,18 +368,18 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "serde"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7af873f2c95b99fcb0bd0fe622a43e29514658873c8ceba88c4cb88833a22500"
+checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75743a150d003dd863b51dc809bcad0d73f2102c53632f1e954e738192a3413f"
+checksum = "94ed3a816fb1d101812f83e789f888322c34e291f894f19590dc310963e87a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -394,9 +394,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "syn"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -420,9 +420,9 @@ checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c61ba63f9235225a22310255a29b806b907c9b8c964bcbd0a2c70f3f2deea7"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
 
 [[package]]
 name = "version_check"

examples/the-hat-chooses-the-wizard/Cargo.lock

@@ -113,9 +113,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bytemuck"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5377c8865e74a160d21f29c2d40669f53286db6eab59b88540cbb12ffc8b835"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 
 [[package]]
 name = "byteorder"
@@ -161,7 +161,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
- "miniz_oxide 0.5.3",
+ "miniz_oxide 0.5.4",
 ]
 
 [[package]]
@@ -196,9 +196,9 @@ dependencies = [
 
 [[package]]
 name = "hound"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a164bb2ceaeff4f42542bdb847c41517c78a60f5649671b2a07312b6e117549"
+checksum = "4d13cdbd5dbb29f9c88095bbdc2590c9cba0d0a1269b983fef6b2cdd7e9f4db1"
 
 [[package]]
 name = "image"
@@ -217,15 +217,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"
+checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "log"
@@ -247,9 +247,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -324,9 +324,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.13.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
+checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
 
 [[package]]
 name = "png"
@@ -342,18 +342,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278e965f1d8cf32d6e0e96de3d3e79712178ae67986d9cf9151f51e95aac89b"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
@@ -366,24 +366,24 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "ryu"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695"
+checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
 
 [[package]]
 name = "serde"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7af873f2c95b99fcb0bd0fe622a43e29514658873c8ceba88c4cb88833a22500"
+checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75743a150d003dd863b51dc809bcad0d73f2102c53632f1e954e738192a3413f"
+checksum = "94ed3a816fb1d101812f83e789f888322c34e291f894f19590dc310963e87a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -392,9 +392,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.82"
+version = "1.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7"
+checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
 dependencies = [
  "itoa",
  "ryu",
@@ -409,9 +409,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "syn"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -444,9 +444,9 @@ checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c61ba63f9235225a22310255a29b806b907c9b8c964bcbd0a2c70f3f2deea7"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
 
 [[package]]
 name = "version_check"

examples/the-hat-chooses-the-wizard/Cargo.toml

@@ -9,9 +9,6 @@ edition = "2018"
 [dependencies]
 agb = { version = "0.11.1", path = "../../agb" }
 
-[dev-dependencies]
-agb = { version = "0.11.1", path = "../../agb", features = ["testing"] }
-
 [build-dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

examples/the-purple-night/Cargo.lock

@@ -122,9 +122,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bytemuck"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5377c8865e74a160d21f29c2d40669f53286db6eab59b88540cbb12ffc8b835"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 
 [[package]]
 name = "byteorder"
@@ -176,7 +176,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
- "miniz_oxide 0.5.3",
+ "miniz_oxide 0.5.4",
 ]
 
 [[package]]
@@ -220,9 +220,9 @@ dependencies = [
 
 [[package]]
 name = "hound"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a164bb2ceaeff4f42542bdb847c41517c78a60f5649671b2a07312b6e117549"
+checksum = "4d13cdbd5dbb29f9c88095bbdc2590c9cba0d0a1269b983fef6b2cdd7e9f4db1"
 
 [[package]]
 name = "image"
@@ -241,9 +241,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "libflate"
@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -354,9 +354,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.13.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
+checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
 
 [[package]]
 name = "png"
@@ -372,18 +372,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278e965f1d8cf32d6e0e96de3d3e79712178ae67986d9cf9151f51e95aac89b"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
@@ -402,18 +402,18 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "serde"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7af873f2c95b99fcb0bd0fe622a43e29514658873c8ceba88c4cb88833a22500"
+checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.141"
+version = "1.0.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75743a150d003dd863b51dc809bcad0d73f2102c53632f1e954e738192a3413f"
+checksum = "94ed3a816fb1d101812f83e789f888322c34e291f894f19590dc310963e87a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -428,9 +428,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "syn"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -481,9 +481,9 @@ checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c61ba63f9235225a22310255a29b806b907c9b8c964bcbd0a2c70f3f2deea7"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
 
 [[package]]
 name = "version_check"

justfile

@@ -106,12 +106,12 @@ _test-release crate:
     just _build-release {{crate}}
     (cd "{{crate}}" && cargo test --release)
 _test-release-arm crate:
-    (cd "{{crate}}" && cargo test --release --target="{{justfile_directory()+"/armv4t-none-eabi.json"}}")
+    (cd "{{crate}}" && cargo test --release --target=armv4t-none-eabi)
 _test-debug crate:
     just _build-debug {{crate}}
     (cd "{{crate}}" && cargo test)
 _test-debug-arm crate:
-    (cd "{{crate}}" && cargo test --release --target="{{justfile_directory()+"/armv4t-none-eabi.json"}}")
+    (cd "{{crate}}" && cargo test --target=armv4t-none-eabi)
 _clippy crate:
     (cd "{{crate}}" && cargo clippy --examples --tests -- {{CLIPPY_ARGUMENTS}})
 _clean crate:

mgba-test-runner/Cargo.lock

@@ -8,26 +8,20 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
-[[package]]
-name = "adler32"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
-
 [[package]]
 name = "aho-corasick"
-version = "0.7.18"
+version = "0.7.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.58"
+version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb07d2053ccdbe10e2af2995a2f116c1330396493dc1269f6a91d0ae82e19704"
+checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
 
 [[package]]
 name = "atty"
@@ -77,9 +71,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bytemuck"
-version = "1.10.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c53dfa917ec274df8ed3c572698f381a24eef2efba9492d797301b72b6db408a"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 
 [[package]]
 name = "byteorder"
@@ -124,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "3.2.10"
+version = "3.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69c5a7f9997be616e47f0577ee38c91decb33392c5be4866494f34cdf329a9aa"
+checksum = "1ed5341b2301a26ab80be5cbdced622e80ed808483c52e45e3310a877d3b37d7"
 dependencies = [
  "atty",
  "bitflags",
@@ -161,20 +155,11 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "deflate"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c86f7e25f518f4b81808a2cf1c50996a61f5c2eb394b2393bd87f2a4780a432f"
-dependencies = [
- "adler32",
-]
-
 [[package]]
 name = "either"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f107b87b6afc2a64fd13cac55fe06d6c8859f12d4b14cbcdd2c67d0976781be"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "env_logger"
@@ -189,6 +174,16 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "flate2"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "glob"
 version = "0.3.0"
@@ -197,9 +192,9 @@ checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
 
 [[package]]
 name = "hashbrown"
-version = "0.12.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "607c8a29735385251a339424dd462993c0fed8fa09d378f259377df08c126022"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hermit-abi"
@@ -218,14 +213,13 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "image"
-version = "0.24.2"
+version = "0.24.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28edd9d7bc256be2502e325ac0628bde30b7001b9b52e0abe31a1a9dc2701212"
+checksum = "7e30ca2ecf7666107ff827a8e481de6a132a9b687ed3bb20bb1c144a36c00964"
 dependencies = [
  "bytemuck",
  "byteorder",
  "color_quant",
- "num-iter",
  "num-rational",
  "num-traits",
  "png",
@@ -264,9 +258,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "libloading"
@@ -312,9 +306,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -339,17 +333,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "num-iter"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
 [[package]]
 name = "num-rational"
 version = "0.4.1"
@@ -371,10 +354,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "os_str_bytes"
+name = "once_cell"
-version = "6.1.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21326818e99cfe6ce1e524c2a805c189a99b5ae555a35d19f9a284b427d86afa"
+checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
 
 [[package]]
 name = "peeking_take_while"
@@ -384,30 +373,30 @@ checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
 
 [[package]]
 name = "png"
-version = "0.17.5"
+version = "0.17.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc38c0ad57efb786dd57b9864e5b18bae478c00c824dc55a38bbc9da95dde3ba"
+checksum = "8f0e7f4c94ec26ff209cee506314212639d6c91b80afb82984819fafce9df01c"
 dependencies = [
  "bitflags",
  "crc32fast",
- "deflate",
+ "flate2",
  "miniz_oxide",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.40"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd96a1e8ed2596c337f8eae5f24924ec83f5ad5ab21ea8e455d3566c69fbcaf7"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
@@ -464,19 +453,19 @@ checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.1"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
 
 [[package]]
 name = "which"
-version = "4.2.5"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
+checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
 dependencies = [
  "either",
- "lazy_static",
  "libc",
+ "once_cell",
 ]
 
 [[package]]

template/Cargo.toml

@@ -9,9 +9,6 @@ edition = "2018"
 [dependencies]
 agb = "0.11.1"
 
-[dev-dependencies]
-agb = { version = "0.11.1", features = ["testing"] }
-
 [profile.dev]
 opt-level = 2
 debug = true

tools/Cargo.lock

@@ -33,9 +33,9 @@ checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
 
 [[package]]
 name = "clap"
-version = "3.2.16"
+version = "3.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3dbbb6653e7c55cc8595ad3e1f7be8f32aba4eb7ff7f0fd1163d4f3d137c0a9"
+checksum = "1ed5341b2301a26ab80be5cbdced622e80ed808483c52e45e3310a877d3b37d7"
 dependencies = [
  "atty",
  "bitflags",
@@ -57,9 +57,9 @@ dependencies = [
 
 [[package]]
 name = "combine"
-version = "4.6.4"
+version = "4.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a604e93b79d1808327a6fca85a6f2d69de66461e7620f5a4cbf5fb4d1d7c948"
+checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
 dependencies = [
  "bytes",
  "memchr",
@@ -67,9 +67,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f107b87b6afc2a64fd13cac55fe06d6c8859f12d4b14cbcdd2c67d0976781be"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "hashbrown"
@@ -98,18 +98,18 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+checksum = "d8bf247779e67a9082a4790b45e71ac7cfd1321331a5c856a74a9faebdab78d0"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "libc"
-version = "0.2.127"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "505e71a4706fa491e9b1b55f51b95d4037d0821ee40131190475f692b35b009b"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
 
 [[package]]
 name = "memchr"
@@ -119,9 +119,9 @@ checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "os_str_bytes"
-version = "6.2.0"
+version = "6.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "648001efe5d5c0102d8cea768e348da85d90af8ba91f0bea908f157951493cd4"
+checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
 
 [[package]]
 name = "strsim"

tools/Cargo.toml

@@ -6,5 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-clap = "3.2.16"
+clap = "3.2"
-toml_edit = "0.14.4"
+toml_edit = "0.14"