The `percore` macro can copy values that are not safely duplicable

[balint-dobszay-arm]

#[percore]
static VALUE: ExceptionLock<RefCell<T>> = ExceptionLock::new(RefCell::new(initial_value));

This creates one initialised value on the primary core, and then copies it byte-by-byte (ldp/stp) to each secondary core's percore area. However, there is no guarantee that it is sound to duplicate T.

E.g. if T = &'static mut u64, all cores will have their own RefCell instance, so all cores can successfully borrow it at the same time, and will have mutable access to the same memory location.

Note: Codex gave me the hint for this, while I was reviewing the integration of the new percore-derive feature in RF-A

[qwandor]

I'm not quite sure how this issue can occur, do you have a complete example? How do you safely construct a &'static mut u64 in a const context?

[balint-dobszay-arm]

This is what I had in mind:

static mut FOO: u64 = 5;

#[percore]
static BAR: ExceptionLock<RefCell<&'static mut u64>> = ExceptionLock::new(RefCell::new(&mut FOO));

To be fair now I've checked and actually this only compiles in Rust 2021, because the &mut FOO is an error starting from Rust 2024.

The static mut was just an example. I'm wondering if there are any other built-in types that can be constructed in const time, but are not bit-by-bit duplicable? Or is it possible to create such type? It feels like some restriction regarding this would be necessary for T. But maybe I'm reasoning about something that doesn't exists, if that's the case then I'm okay with closing this issue as NOP.

[qwandor]

That example should require an unsafe block, which #50 fixes.

If there's a safe const expression T::new() to construct a T which is not Copy, then wouldn't the same issue apply to:

static ARRAY: [T; 2] = [const { T::new() }; 2];

[imre-kis-arm]

I believe this issue was discussed during the review. A static variable’s initializer must be valid in a constant-evaluation context. I cannot think of any value that is valid for constant evaluation but unsafe to duplicate.