I have read example code of the form

namespace
{
    bool register()
    {
       // blah - do something useful in here
    }

    bool registered = register();

Note that i sent a defect report about that wording: It seems to
intend to allow the same for objects of class scope, but the wording
currently doesn't. Still, your environment would behave as if the
standard allows it, i suppose :) So you couldn't just stuff the
variable as a static data member of a class :)

Note that "static initialization" can refer to two things:
initialization of static-storage objects, and static initialization of
such objects. The latter is one way of initialization of static
objects, intended to be used for things that don't need to run code
(like, initialization with constant values). The other way is dynamic
initialization, which is the case in your example (because of the
function call).

Static initialization in your example *may* apply, but it doesn't have
to. If the compiler can compute that the function always returns true/
fase, and can compute that the static initialization satisfies some
other properties (no change of other statics, ...), it can actually do
static initialization for it. I suspect in your code, this isn't the
case, anyway.

Firstly, unlike initialisation with a constant which is done at
compile time, this requires runtime initialisation in code before main
().

The second issue is to do with libraries and the C++ standard does not
deal with libraries or linking (at least beyond the level of
'compilation unit').
In practice, linkers only pull in object files from libraries to
satisfy references to symbols from already linked code. Since there is
no reference to anything in the compilation unit including the example
code the linker sees no need to include it and hence no need to
include code to do the initialisation.
To get around this you must include the .o file directly in the link
command rather than via a library (unless your linker has an option to
force linking of the entire library)