constexpr function which is shared in multiple modules

This program ill-formed: X and Y have internal linkage since they are const variables at namespace scope. This means that both definitions of constexpr int get_product() (which is implicitly inline) violate the one definition rule:

There can be more than one definition in a program of each of the following: [...], inline function, [...], as long as all the following is true:

• [...]
• name lookup from within each definition finds the same entities (after overload-resolution), except that
  • constants with internal or no linkage may refer to different objects as long as they are not odr-used and have the same values in every definition

And obviously these constants have different values.

What's happening is both mod_a and mod_b are calling get_product at runtime. get_product is implicitly inline, so one of the definitions is chosen and the other is discarded. What gcc seems to do is take the first definition found:

$ g++ mod_a.cpp mod_b.cpp main.cpp && ./a.out
mod_a(): 12
mod_b(): 12
$ g++ mod_b.cpp mod_a.cpp main.cpp && ./a.out
mod_a(): 42
mod_b(): 42
$ g++ -c mod_a.cpp
$ g++ -c mod_b.cpp
$ g++ mod_a.o mod_b.o main.cpp && ./a.out
mod_a(): 12
mod_b(): 12
$ g++ mod_b.o mod_a.o main.cpp && ./a.out
mod_a(): 42
mod_b(): 42

It's as if get_product isn't constexpr, since it is getting called at runtime.

But if you were to enable optimisations (or force get_product() to be called at compile time, like with constexpr int result = get_product(); return result;), the results are as you would "expect":

$ g++ -O1 mod_a.cpp mod_b.cpp main.cpp && ./a.out
mod_a(): 12
mod_b(): 42

(Though this is still UB, and the correct fix is to make the functions static)

This code violates the One Definition Rule (language lawyers please correct me if I'm wrong).

If I compile the code separately, I get the behavior that you expect:

g++ -O1 -c main.cpp
g++ -O1 -c mod_a.cpp
g++ -O1 -c mod_b.cpp
g++ *.o
./a.out
> mod_a(): 12
> mod_b(): 42

If I compile all at once or activate link-time optimization, the UB becomes apparent.

g++ -O1 *.cpp
./a.out
> mod_a(): 12
> mod_b(): 12

How to fix this

You are on the right track with declaring them static. More C++-esce would be an anonymous namespace. You should also declare the constants static or put them in a namespace, not just the function.

mod_a.cpp:

namespace {
constexpr int X = 3;
constexpr int Y = 4;
}

#include "common.h"

int mod_a()
{
    return get_product();
}

common.h:

namespace {
constexpr int get_product()
{
    return X * Y;
}
} /* namespace anonymous */

Even better, in my opinion: Include the common.h within an opened namespace. That makes the connection between the declarations more apparent and would allow you to have multiple public get_products, one per namespace. Something like this:

mod_a.cpp:

namespace {
constexpr int X = 3;
constexpr int Y = 4;

#include "common.h"
} /* namespace anonymous */

int mod_a()
{
    return get_product();
}