1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
/**
* 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);
}
}
|
