blob: 1703450c65fb4d2e3354a17fcb48b9ac8de6a1da [file] [log] [blame]
* This module declares intrinsics for volatile operations.
* Copyright: Copyright © 2019, The D Language Foundation
* License: $(LINK2, Boost License 1.0)
* Authors: Walter Bright, Ernesto Castellotti
* Source: $(DRUNTIMESRC core/volatile.d)
module core.volatile;
* Read/write value from/to the memory location indicated by ptr.
* These functions are recognized by the compiler, and calls to them are guaranteed
* to not be removed (as dead assignment elimination or presumed to have no effect)
* or reordered in the same thread.
* These reordering guarantees are only made with regards to other
* operations done through these functions; the compiler is free to reorder regular
* loads/stores with regards to loads/stores done through these functions.
* This is useful when dealing with memory-mapped I/O (MMIO) where a store can
* have an effect other than just writing a value, or where sequential loads
* with no intervening stores can retrieve
* different values from the same location due to external stores to the location.
* These functions will, when possible, do the load/store as a single operation. In
* general, this is possible when the size of the operation is less than or equal to
* $(D (void*).sizeof), although some targets may support larger operations. If the
* load/store cannot be done as a single operation, multiple smaller operations will be used.
* These are not to be conflated with atomic operations. They do not guarantee any
* atomicity. This may be provided by coincidence as a result of the instructions
* used on the target, but this should not be relied on for portable programs.
* Further, no memory fences are implied by these functions.
* They should not be used for communication between threads.
* They may be used to guarantee a write or read cycle occurs at a specified address.
ubyte volatileLoad(ubyte * ptr);
ushort volatileLoad(ushort* ptr); /// ditto
uint volatileLoad(uint * ptr); /// ditto
ulong volatileLoad(ulong * ptr); /// ditto
void volatileStore(ubyte * ptr, ubyte value); /// ditto
void volatileStore(ushort* ptr, ushort value); /// ditto
void volatileStore(uint * ptr, uint value); /// ditto
void volatileStore(ulong * ptr, ulong value); /// ditto
@system unittest
alias TT(T...) = T;
foreach (T; TT!(ubyte, ushort, uint, ulong))
T u;
T* p = &u;
volatileStore(p, 1);
T r = volatileLoad(p);
assert(r == u);