Magic Static in Singleton Template

Question

I recently was reading an article labeled "Modern C++ Singleton Template". The proposed solution used C++11 feature of Magic Statics (N2660). I wanted to adapt it for an own project in "freestanding" (fno-hosted) environment.

My code looks as follows:

Singleton.hpp

namespace std
{
    template <typename T>
    class Singleton
    {
        public:
            // = initialization and termination methods
            Singleton( const Singleton& )   = delete;   // copy constructor
            Singleton(       Singleton&& )  = delete;   // move constructor
            Singleton& operator=( const Singleton& ) = delete;  // assignment operator
            Singleton& operator=(       Singleton&&) = delete;  // copy move operator
            // = accessor methods.
            static T& getInstance();
        protected:
             Singleton() {};                            // default constructor
            ~Singleton() {};                            // default destructor
             struct Token {};
        private:
    }; // end template class T

    template <typename T>
    T& Singleton<T>::getInstance()
    {
        static T    __singleInstance( Token{} );    
        return( __singleInstance );
    } // end public method 'getInstance()'
} // end namespace std

Test.hpp

#include "libs/libc++/singleton.hpp"        // declaration of template class 'Singleton'

class Test final : public TestSingelton<Test>
{
    public:
    Test(TestToken);
   ~Test();

    void use();
};

Test.cpp

Test::Test(TestToken)
{
    logTraceEvent_m( loging to file );
}

Test::~Test()
{
    logTraceEvent_m( loging to file );
}

void 
Test::use()
{
    logTraceEvent_m( loging to file );
}

Problem

In hosted environment (Linux, GCC 7.5.0) it works as presented in the article refereed to above. The static variable is initialized only once; the constructor of the derived class is called only once.

Entering main()
Entering a()
constructed
in use
Entering b()
in use
Leaving main()
destructed

However, in my "-ffreestandig" environment it is not working. "freestanding" = kernel without any standard headers; without any libraries!

Static variable ("__singleInstance") is initialized on every call to "Test::getInstance()".

______ TRACE: constructor = Test::Test(TestSingelton<Test>::TestToken), ...
______ TRACE: use = void Test::use(), file = test/Test.cpp, line = 37.
______ TRACE: constructor = Test::Test(TestSingelton<Test>::TestToken), ...
______ TRACE: use = void Test::use(), file = test/Test.cpp, line = 37.

What I'm doing wrong? Is there any advice in which direction I have to investigate?

• compiler options?
• -W -Wall -pedantic -ffreestanding -std=gnu++17 -fno-PIC -fno-exceptions -fno-rtti -fno-use-cxa-atexit -march=native -m64 -mcmodel=kernel -mno-red-zone -mno-sse3 -mno-ssse3 -mno-sse4.1 -mno-sse4.2 -mno-sse4 -mno-sse4a -mno-3dnow -mno-avx -mno-avx2
• runtime environment, that is missing something

Answer 1

Your test code doesn't match your test output. "Test.cpp" isn't even valid C++ code!

How does your massive amount of code do anything significantly different from the following eight lines?

template<class T>
struct Singleton {
    struct Token {};
    static T& getInstance() {
        static T instance(Token{});
        return instance;
    }
};

Example usage:

struct Widget { explicit Widget(Singleton<Widget>::Token); };
Widget& example = Singleton<Widget>::getInstance();

As for why the "thread-safe statics" feature doesn't work on your freestanding platform, I would suspect it's because your freestanding platform doesn't support thread-safe statics. :) Check the documentation for your toolchain to see how static variables are handled on that particular platform.

Answer 2

After further thinking and reading I suspect the behaviour is caused by my incomplete C++ ABI. My functions __xca_gaurd_aquire/__xca_guard_release are currently empty functions and I will go ahead to implement minimalistic versions and see if I get different results. Currently I belive that's the way to overcome my problem.