Consider the following translation unit:

template <typename T> void foo(T t) {}

template <> void foo<int>(int i) {}
// Explicit specialization

template void foo<double>(double d);
// Explicit instantiation

When compiling this unit with GCC or Clang, the compiler generates an
object file with bodies for `foo<int>` and `foo<double>`, all as
expected. However, explicit specialization results in a "strong" symbol
for `foo<int>`, while explicit instantiation for `foo<double>` produces
a weak symbol.

See https://godbolt.org/z/xxM7jn858

A "strong" symbol for `foo<int>` makes perfect sense. But why a weak
symbol for `foo<double>`? Why not a "strong" one as well?

For example, a program that includes two copies of translation unit like
this

template <typename T> void foo(T t) {}
template void foo<double>(double d);

is formally invalid, since it is illegal to have two explicit
instantiation definitions for the same set of template parameters (see
http://eel.is/c++draft/temp.spec#general-5.1). Yet, nether GCC nor Clang
is able to detect this error, since they generate weak symbols for
`foo<double>` in both translation units.

The standard also does not require diagnostic for this error, even
though to my naive eye it seems to be as easy to diagnose as any
ordinary "multiple definition" error. Just make the explicit
instantiation a "strong" symbol and the linker will catch the error.

But apparently there's a reason the standard require no diagnostic, and
there's a reason GCC and Clang make it a weak symbol. Anyone has any
idea what that reason might be?

All I could find on the Net is this:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87380. But this seems to be
too niche.

--
Best regards,
Andrey