Implementing singletons across binary modules

Background

First of all, I think this question goes beyond the C++ standard. The standard deals with multiple translation units (instantiation units) and thus multiple object modules, but does not seem to acknowledge the possibility of having multiple independently compiled and linked binary modules (i.e., .so files in Linux and .dll files in Windows). After all, the latter more of less enters into the world of application binary interface (ABI) that the standard leaves to implementations to consider at present.

When only a single binary module is involved, the following code snippet illustrates an elegant and portable (standard-compliant) solution to make singletons.

inline T& get() {
  static T var{};
  return var;
}

There are two things to note about this solution. First, the inline specifier makes the function a candidate to be included in multiple translation units, which is very convenient. Note that, the standard guarantees there is only a single instance of get() and the local static variable var in the final binary module (see here).

The second thing to note is that since C++11, initialization of static local variables is properly synchronized (see the Static local variables section here). So, concurrent invocations of get() is fine.

Now, I try to extend this solution to the case when multiple binary modules are involved. I find the following variant works with VC++ on Windows.

// dllexport is used in building the library module, and
// dllimport is used in using the library in an application module.
__declspec(dllexport/dllimport) inline T& get() {
  static T var{};
  return var;
}

Since VC++ supports exporting and importing template instantiations (see here), the above solution can even be templated. For example:

template <typename T> inline
T& get() {
  static T var{};
  return var;
}

template __declspec(dllexport/dllimport) int& get<int>();

As a side note, the inline specifier is not mandatory here. See this S.O. question.

The Question

Since there is no __declspec(dllexport/import) equivalents in GCC and clang, is there a way to make a variant of the above solution that works on these two compilers?

Also, in Boost.Log, I noticed the BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT macro (see the Global logger objects section here). It is claimed to create singletons even if the application consists of multiple modules. If someone knows about the inner workings of this macro, explanations are welcome here.

Finally, if you know about any better solutions for making singletons, feel free to post it as an answer.