mirror of
https://review.haiku-os.org/buildtools
synced 2025-02-07 06:14:49 +01:00
68 lines
2.6 KiB
D
68 lines
2.6 KiB
D
/**
|
|
* This module declares intrinsics for volatile operations.
|
|
*
|
|
* Copyright: Copyright © 2019, The D Language Foundation
|
|
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
|
|
* Authors: Walter Bright, Ernesto Castellotti
|
|
* Source: $(DRUNTIMESRC core/volatile.d)
|
|
*/
|
|
|
|
module core.volatile;
|
|
|
|
nothrow:
|
|
@safe:
|
|
@nogc:
|
|
|
|
/*************************************
|
|
* 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);
|
|
}
|
|
}
|