Fix misoptimization of multi-return asm

See: <rust-lang/rfcs#2625>

Author: oxalica

src/lib.rs

@@ -20,6 +20,7 @@
 #![cfg_attr(feature = "unstable-asm-goto", feature(asm_goto))]
 #![cfg_attr(feature = "unstable-asm-goto", feature(asm_goto_with_outputs))]
 #![cfg_attr(not(test), no_std)]
+use core::hint::black_box;
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use core::num::NonZero;
@@ -137,6 +138,16 @@ where
     let ptr = buf.as_mut_ptr();
     let mut val: usize;
 
+    // Show the optimizer that `ordinary` may be called in both ordinary and landing paths.
+    // So it cannot assume that variables that are captured by `ordinary` are unchanged in the
+    // lander path -- they must be reloaded.
+    // This fixes <https://github.com/rust-lang/rfcs/issues/2625>.
+    if size_of::<F>() == 0 {
+        // F must not mutate local states because it captures nothing.
+    } else {
+        black_box(&ordinary);
+    }
+
     #[cfg(feature = "unstable-asm-goto")]
     unsafe {
         set_jump_raw!(val, ptr, {

tests/smoke.rs

@@ -28,3 +28,29 @@ fn smoke() {
     );
     assert_eq!(ret, 4242);
 }
+
+#[test]
+fn issue2625() {
+    #[inline(never)]
+    fn foo() -> (usize, usize) {
+        let mut x = 42usize;
+        let y = JumpPoint::set_jump(
+            |jp| {
+                // Step 0: setjmp returns 0
+                // Step 1: x is modified
+                x = 13;
+                // Step 2: jumps to Step 0 returning 1
+                unsafe { jp.long_jump(NonZero::new(1).unwrap()) };
+            },
+            |y| {
+                // Step 3: when setjmp returns 1 x has always been
+                // modified to be  == 13 so this should always return 13:
+                y.get()
+            },
+        );
+        // The optimizer must not assume `x` is unchanged in the long_jump lander path.
+        (x, y)
+    }
+
+    assert_eq!(foo(), (13, 1));
+}