On 2/1/2015 3:22 AM, Johannes Pfau wrote:
Am Sun, 01 Feb 2015 02:11:42 -0800
schrieb Walter Bright <[email protected]>:
core.bitop.volatileLoad() and volatileStore() are implemented, and do
the job. They are compiler intrinsics that result in single
instructions. They support 8, 16, 32 and 64 bit loads and stores.
I think everybody agreed that these low-level primitives can't be used
in end-user code.
I apparently missed that discussion. (In any case, dealing with memory mapped
I/O is not a usual programming task, I expect a programmer doing it will be more
sophisticated.)
We can generate nice wrappers (nicer than C code),
which perform as well as C code, but only with force-inline _and_
enabled optimizations (we essentially need heavy constant folding).
The compiler intrinsics participate in all optimizations.
We also need a pragma(address) to complement pragma(mangle).
What would that do?
* Using only part of druntime is ugly. The one thing most people would
probably like to strip out is the GC, but keep exception handling,
threads, ... But the GC is everywhere: core.demangle doesn't work
without, backtraces, exceptions, threads. Right now you either use
all of druntime or nothing but it's not possible to use parts of
druntime only, it's not modular enough.
De-Modularity is one of those things that one has to continually fight, like
mildew in the shower. Turn your back on it for a moment, and interdependence
creeps back in.