Dynamic initialization of namespace scope objects may be deferred until first use?

In the C++03 standard, 3.6.2/4, it says that globals may have their
initialization deferred until the first use of a function or object
from that translation unit.

That basically kills any possible way to guarantee the correctness of
the idiomatic construct-on-first-use no-locking eager-initialized
singleton using only the C++03 standard and relevant threading
standard.

class T { /*...*/ };

T& getInstance()
{ static T * t = new T;
    return *t;
}

namespace
{ struct ForceInstantiation
    { ForceInstantiation() { getInstance(); }
    } force;
}

To do the simple thread-safe lazy-initialized singleton, you still
need to eager-initialize the mutex, otherwise we don't have the mutex
constructed prior to the first possibly-concurrent call. The mutex
becomes its own construct-on-first-use no-locking eager-initialized
singleton as the alternative is the static initialization order
fiasco. Again, as we can't guarantee this eager-initialization occurs
before main, we're (potentially) screwed.

class Mutex { /*...*/ };
class Guard { public: Guard(Mutex& ); /*...*/ };
class T { /*...*/ };

namespace
{ Mutex& getMutex()
    { static Mutex * m = new Mutex;
        return *m;
    }
    struct ForceInstantiation
    { ForceInstantiation() { getMutex(); }
    } force;
}

T& getInstance()
{ Guard g(getMutex());
    static T * t = new T;
    return *t;
}

My questions are:

1- Why is that in the standard? The intent was to allow
implementations to lazy initialize translation units? Seems to be
almost an aborted attempt at shared libraries.

It would just be weird to have a global with a constructor that prints
to cout, yet not see it print to cout until I reference the
translation unit.

If I have a global whose constructor has side effects, what guarantees
do I have about the interleaving of calls of "the code in the global's
constructor" and "the code between the start of main and the code
which references the translation unit"?

#include <iostream>
struct global_t
{ global_t()
    { std::cout << " G ";
        std::cout << " LOBAL ";
    }
} global;

//different translation unit
#include <iostream>
int main()
{ std::cout << " M " << " A ";
    std::cout << " I ";
    global;
    std::cout << " N" << std::endl;
}

What can this program legally print?
" G LOBAL M A I N\n" I would expect for most compilers.
" M A G LOBAL I N\n" as the next most expected.
Various other combinations can be achieved if we treat "statements" as
atomic. However, each of those are function calls, which are then
composed of more statements.
Could I get " G M LOBAL A I N\n" or some other exotic
mixing of output?
I presume whatever the output, it's not undefined behavior, it won't
crash the program.

I just don't understand if there is any sort of limit to the possible
interleavings.

2- Do any actual compilers do this? If any actual compiler
implementation does this, hopefully they do it in a thread-safe way?

3- This all rests upon the implicit assumption that no one creates
threads before main is called. Is this a fair assumption from real
world code? It just seems that what limited guarantees we have
concerning the order of construction of globals goes out the window if
there's multiple threads before main starts.

4- I assume that when a shared library is loaded, all of the globals
are constructed before the load call returns, or it's delayed in a
thread-safe way. (Quite analogous to question 3.) Correct?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]