Template static member definition depends on order passed to linker - c++

Question

The following code, which has 2 definitions for a template static field member, each definition defines template1<int>::x with a different value.
One would expect the linker to reject such redefinitions as they have different values.
But compilation & linkage passes for both g++ and MSVC, and which definition is used is dependent on the order in which the sources are passed to the linker.
Is this behavior compliant to the C++ standard, undefined behavior, or a linker bug?
my_template.h
template <class T>
class template1
{
public:
static int x;
};
Src2.cpp
#include <stdio.h>
#include "my_template.h"
template <class T>
int template1<T>::x = 2;
void my_func() // definition
{
printf("my_func: template1<int>::x = %d\n", template1<int>::x); // definition of X to 2.
printf("my_func: template1<char>::x = %d\n", template1<char>::x); // definition of X to 2.
}
Main.cpp
#include <cstdio>
#include "my_template.h"
template <class T>
int template1<T>::x = 1;
void my_func();
int main()
{
printf("main: template1<int>::x = %d\n", template1<int>::x); // definition of X to 1.
my_func();
return 0;
}
Compile with g++ (MinGW.org GCC Build-20200227-1) 9.2.0+
Compile1
g++ -o prog Src2.cpp Main.cpp
Output1
main: template1<int>::x = 2
my_func: template1<int>::x = 2
my_func: template1<char>::x = 2
Compile2
g++ -o prog Main.cpp Src2.cpp
Ouput2
main: template1<int>::x = 1
my_func: template1<int>::x = 1
my_func: template1<char>::x = 2
Observed also with
Microsoft (R) C/C++ Optimizing Compiler Version 19.25.28612 for x86
When I disassembled the code with -S flag, each compilation unit defined the same symbol name.
Co-work with Nightra.

Answer 1

This violates ODR (which requires that an entity must have exactly one definition, if it's used). So the program has UB.
The compiler couldn't diagnose this, because each translation unit is fine. In theory, the linker could diagnose this, but in practice it won't do that.

Answer 2

Is this behavior compliant to the C++ standard, undefined behavior, or a linker bug?
This is undefined behaviour (UB).
From [basic.def.odr]/4 of N4659 [emphasis mine]:
Every program shall contain exactly one definition of every
non-inline function or variable that is odr-used in that program
outside of a discarded statement; no diagnostic required. The
definition can appear explicitly in the program, it can be found in
the standard or a user-defined library, or (when appropriate) it is
implicitly defined (see [class.ctor], [class.dtor] and [class.copy]).
An inline function or variable shall be defined in every translation
unit in which it is odr-used outside of a discarded statement.
Non-constexpr static member variables of templates are not implicitly inline, and thus this is UB, no diagnostic required.
We may also turn to [basic.def.odr]/6 for an even stronger statement (not even requiring ODR-use) [quoting a selected extract, emphasis mine]:
There can be more than one definition of a [...] static data member
of a class template [...] in a program provided that each definition
appears in a different translation unit, and provided the
definitions satisfy the following requirements. Given such an entity
named D defined in more than one translation unit, then
each definition of D shall consist of the same sequence of tokens; and
[...]
If the definitions of D satisfy all these requirements, then the
behavior is as if there were a single definition of D. If the
definitions of D do not satisfy these requirements, then the
behavior is undefined.
With two different definitions of D (in your case, template1<int>::x) "each definition of D shall consist of the same sequence of tokens" is not fulfilled, and it follows that we naturally cannot possibly fulfill "[...] as if there were a single definition of D"; thus UB.