Звук `&T as *const T as *mut T` для элементов `static mut`?

1. Это немедленное неопределенное поведение, потому что вы не можете сделать &mut T из &T каким-либо образом, за исключением случаев, когда T является UnsafeCell. Вы должны написать что-то вроде этого, по крайней мере:

Wrapper(unsafe { &mut GLOBAL_SINGLETON as *mut _ })

MIRI не улавливает этот конкретный пример, но если вы запустите более простую программу, вы увидите, что:

fn main(){
    let mut val = 5;
    let ptr = &val as *const i32;
    unsafe{
        *(ptr as *mut _) = 7;
    }
}

Выход МИРИ:

error: Undefined Behavior: attempting a write access using <2665> at alloc1410[0x0], but that tag only grants SharedReadOnly permission for this location
 --> src/main.rs:6:9
  |
6 |         *(ptr as *mut _) = 7;
  |         ^^^^^^^^^^^^^^^^^^^^
  |         |
  |         attempting a write access using <2665> at alloc1410[0x0], but that tag only grants SharedReadOnly permission for this location
  |         this error occurs as part of an access at alloc1410[0x0..0x4]

См. также запись nomicon о преобразовании общих ссылок в изменяемые ссылки.

2. API Wrapper и Guard, хотя и не вызывают неопределенного поведения сами по себе, все же ненадежны. Это означает, что вы можете запускать UB из безопасного Rust, используя их.

Например, это будет UB:

fn foo(){
  let mut guard1 = WRAPPER.guard();
  *guard1 = 7;
  let mut guard2 = WRAPPER.guard();
  *guard2 = 5;
  // This access is UB
  assert_eq!(*guard1, 5);
}

Это очень легко получить, если вы вызовете любой метод T, потому что трудно отследить повторный вход. И еще хуже, если вы добавите многопоточность.

Я рекомендую просто не использовать изменчивую статику, потому что в любом случае очень неудобно обращаться к ним.

Я могу представить только этот звуковой API для изменяемой статики:

use std::sync::atomic::{AtomicUsize, Ordering};

pub fn access_mutable_static(
    // This `for <'a>` ensures that caller cannot store reference
    // to static anywhere.
    access_fn: impl for<'a> FnOnce(&'a mut i32),
) {
    static CURRENT_ACCESS_COUNT: AtomicUsize = AtomicUsize::new(0);
    static mut VALUE: i32 = 0;

    if CURRENT_ACCESS_COUNT.fetch_add(1, Ordering::Acquire) != 0 {
        // Relaxed here is OK because we haven't accessed `VALUE` yet.
        CURRENT_ACCESS_COUNT.fetch_sub(1, Ordering::Relaxed);
        panic!("Duplicate access to mutable static!");
    }

    // Use RAII because `access_fn` can panic.
    struct ReleaseAccessCount;
    impl Drop for ReleaseAccessCount {
        fn drop(&mut self) {
            CURRENT_ACCESS_COUNT.fetch_sub(1, Ordering::Release);
        }
    }

    let _guard = ReleaseAccessCount;
    unsafe {
        // SAFETY: function is safe because if static is being already accessed,
        // function would panic.
        access_fn(&mut VALUE);
    }
}

// Access like this:
let mut value_of_static: i32 = 0;
access_mutable_static(|s|value_of_static = *s);
let new_value = calc_value(value_of_static);
access_mutable_static(|s|*s = new_value);

В обоих существующих ответах указано, что это UB, поэтому я добавляю один из своих, чтобы отразить более тонкий вклад Ральфа Юнга. Если кто и знает, я думаю, это он:

Это связано с тем, что у нас нет модели псевдонимов во время компиляции, поэтому ничто не помнит, что этот указатель происходит из общей ссылки. Мы также не приняли решения о том, применяются ли правила псевдонимов даже на границе между временем компиляции и временем выполнения. Я думаю, что они здесь не очень полезны, поскольку все глобально... Но это вопрос UCG. ¹

и

Это глубоко на неопределенной/неопределенной территории. Так что, пожалуйста, не делай этого. :) ²

Так что это не определенно UB, но это также не совсем UB, и его следует избегать до принятия решения.

Ральф также создал новую проблему в репозитории UCG, чтобы решить эту проблему, так что следите за ней в будущем.

¹: https://github.com/rust-lang/miri/issues/2937#issuecomment-1600365067

²: https://github.com/rust-lang/miri/issues/2937#issuecomment-1602458297