Read to stdout doesn't trigger correct action

[IGotD-]

I've done some adaptations to druntime for another C library that 
isn't currently supported. Obtaining the FILE* structure of the 
clib is done via a function call rather than global variables. 
However this function call is never triggered when issuing a 
writeln function call. The FILE* structure is a pointer that 
points to a completely wrong location.

Reading core.stdc.stdio.stdin and core.stdc.stdio.stdout 
explicitly will trigger the function call and the correct 
addresses can be read.

The function writeln seems to obtain the std FILE* structures is 
"@property ref File makeGlobal(StdFileHandle _iob)()" in 
std.stdio.d.


// Undocumented but public because the std* handles are aliasing 
it.
@property ref File makeGlobal(StdFileHandle _iob)()
{
     __gshared File.Impl impl;
     __gshared File result;

     // Use an inline spinlock to make sure the initializer is 
only run once.
     // We assume there will be at most uint.max / 2 threads 
trying to initialize
     // `handle` at once and steal the high bit to indicate that 
the globals have
     // been initialized.
     static shared uint spinlock;
     import core.atomic : atomicLoad, atomicOp, MemoryOrder;
     if (atomicLoad!(MemoryOrder.acq)(spinlock) <= uint.max / 2)
     {
         for (;;)
         {
             if (atomicLoad!(MemoryOrder.acq)(spinlock) > uint.max 
/ 2)
                 break;
             if (atomicOp!"+="(spinlock, 1) == 1)
             {
                 with (StdFileHandle)
                     assert(_iob == stdin || _iob == stdout || 
_iob == stderr);
                 impl.handle = mixin(_iob);
                 result._p = &impl;
                 atomicOp!"+="(spinlock, uint.max / 2);
                 break;
             }
             atomicOp!"-="(spinlock, 1);
         }
     }
     return result;
}


This seems do some atomic operation preventing the D File class 
for stdio not to be initialized several times. I'm not quite sure 
if this is global or per thread but I guess it is for the entire 
process. For some reason the std File classes are never 
initialized at all. Another problem is that the function that is 
called to obtain the clib stdin/out use a structure that is lazy 
initialized per thread, so it must be called at least a first 
time for each thread in order to get the correct stdin/out. 
Removing the atomic operations so that the File initialization is 
done every time, then it works.

Question is if "File makeGlobal(StdFileHandle _iob)()" is correct 
when it comes to ensure compatibility among all the clib versions 
out there. Not too seldom are clib global variables really 
functions, like errno is often a function rather than a variable. 
The internal code the the clib (Newlib) does not have this 
"optimization" but always get stdin/out using this function call.