No way to emit volatile loads/stores

[whitequark]

I'm interested in using Rust for bare-metal embedded development. For that, Rust would need to support volatile loads and stores.

In a nutshell:

• Volatile loads and stores represent a barrier preventing compiler from reordering them across other volatile operations (reference).
• They're mainly used to represent accesses to I/O memory, where normal compiler assumptions don't hold.

C implements them with a pointer attribute. Arguably, semantically it would be a better fit to use an intrinsic function. What should Rust use?

[emberian]

We need the intrinsics, but could also probably be a smart pointer type (Volatile<T>)

[alexcrichton]

I like the idea of a smart pointer where T: Pod, but I think that this is a core-enough feature that this warrants a bit of discussion to make sure that this is the right way to go about this. I certainly agree that we need something like this, and I'd be comfortable merging as-is, but I'm curious what others' opinions are.

[emberian]

Regardless of any sugar we can't do anything without the intrinsics.

[Thiez]

The atomic instructions rustc emits are also marked volatile in LLVM (unless it has been changed since I added them?). This should probably be changed since atomics need not be volatile.

[farcaller]

Any advice how to use this on bare metal, given that bare metal implies #[no_std]?

[whitequark]

@farcaller Directly refer to intrinsics from your code, i.e. like at 1dcc986#diff-09f379e672ff7785f402be1007a06286L175

[huonw]

extern "rust-intrinsic" {
    pub extern fn volatile_load<T>(src: *T) -> T;
    pub extern fn volatile_store<T>(src: *mut T, value: T);
}

See also the intrinsics module and the brief section on compiler internals in the unsafe guide.

e: oh, @whitequark was faster.

[thestinger]

@farcaller: You can use https://github.com/thestinger/rust-core on bare metal. No need to go through the work of redefining all this stuff yourself.

[nrc]

So, we have the intrinsics now. Is there any interest in making this more user friendly? Like a smart pointer type or allow annotating variables as volatile?

[huonw]

@nick29581 there was a pull request adding a wrapper type: #12079.

[thestinger]

I'm not really sure that types make sense. You're only going to need these in rare cases, and the needs are likely quite specific to the use case.

[farcaller]

I've ended up using a modified Cell to do volatile access: https://github.com/hackndev/zinc/blob/master/src/lib/volatile_cell.rs