[modules] Template specialization instantiated twice across module boundary, causing duplicate initialization of inline static data member

[Eromythic]

Summary
When a class template with an inline static data member is defined inside an anonymous namespace within a module interface unit, clang instantiates the specialization twice. As a result, the inline static data member is initialized twice at runtime, leading to duplicated side effects. MSVC does not exhibit this behavior.

Reproducer
main.cpp:

import demo;

int main() { }

demo.ixx:

module;
#include <iostream>
#include <string>
#include <typeindex>
#include <unordered_map>
export module demo;

class Registry {
public:
    static Registry& instance() {
        static Registry instance;
        return instance;
    }

    template<class Derived> void register_type() {
        const std::string type_name = typeid(Derived).name();
        if (auto it = m_type_to_typeindex.find(type_name); it != m_type_to_typeindex.end()) {
            std::cout << "Trying to re-register class: " << typeid(Derived).name()
                << " (prev: " << it->second
                << ", new: " << std::type_index(typeid(Derived)).hash_code()
                << ")" << std::endl;
            return;
        }
        m_type_to_typeindex[type_name] = std::type_index(typeid(Derived)).hash_code();
    }

private:
    std::unordered_map<std::string, size_t> m_type_to_typeindex;
};

template<class Derived>
class Registrable {
protected:
    Registrable() { (void)registered; }

private:
    static void _register() {
        Registry::instance().template register_type<Derived>();
    }
    inline static bool registered = (_register(), true);
};

namespace {
class MyClass : public Registrable<MyClass> {
public:
    MyClass() : Registrable() {}
};
}

Steps to reproduce:
clang-cl:

1. clang++ -std=c++23 -x c++-module demo.ixx --precompile -o demo.pcm
2. clang++ -std=c++23 -x c++-module -c demo.ixx -fmodule-file=demo=demo.pcm -o demo.o
3. clang++ -std=c++23 -c Main.cpp -fmodule-file=demo=demo.pcm -o Main.o
4. clang++ Main.o demo.o -o demo_app

clang:

1. clang++ -std=c++23 -x c++-module demo.ixx --precompile -o demo.pcm
2. clang++ -std=c++23 -x c++-module -c demo.ixx -fmodule-file=demo=demo.pcm -o demo.o
3. clang++ -std=c++23 -c Main.cpp -fmodule-file=demo=demo.pcm -o Main.o
4. clang++ Main.o demo.o -o demo_app
5. Run demo_app and observe "Trying to re-register class..." is printed.

Observed behavior (clang-cl):

• Registrable<MyClass> is instantiated twice.
• Each instantiation has its own inline static bool registered.
• Both registered variables are initialized at startup, so _register() runs twice, producing duplicate registration attempts in Registry.

Expected behavior:
Its inline static member registered should be initialized once, and _register() should run only once.

Notes:

• Moving MyClass out of the anonymous namespace prevents the problem.
• Replacing the "module import" with a "header include" also prevents the problem.

Version:

clang version 20.1.8 and 21.1.0
Target: x86_64-pc-windows-msvc
Thread model: posix
InstalledDir: C:\Program Files\LLVM\bin

[llvmbot]

@llvm/issue-subscribers-clang-modules

Author: None (Eromythic)

**Summary** When a class template with an inline static data member is defined inside an anonymous namespace within a module interface unit, clang-cl instantiates the specialization twice. As a result, the inline static data member is initialized twice at runtime, leading to duplicated side effects. MSVC does not exhibit this behavior.

Reproducer
main.cpp:

import demo;

int main() { }

demo.ixx:

module;
#include <iostream>
#include <string>
#include <typeindex>
#include <unordered_map>
export module demo;

class Registry {
public:
    static Registry& instance() {
        static Registry instance;
        return instance;
    }

    template<class Derived> void register_type() {
        const std::string type_name = typeid(Derived).name();
        if (auto it = m_type_to_typeindex.find(type_name); it != m_type_to_typeindex.end()) {
            std::cout << "Trying to re-register class: " << typeid(Derived).name()
                << " (prev: " << it->second
                << ", new: " << std::type_index(typeid(Derived)).hash_code()
                << ")" << std::endl;
            return;
        }
        m_type_to_typeindex[type_name] = std::type_index(typeid(Derived)).hash_code();
    }

private:
    std::unordered_map<std::string, size_t> m_type_to_typeindex;
};

template<class Derived>
class Registrable {
protected:
    Registrable() { (void)registered; }

private:
    static void _register() {
        Registry::instance().template register_type<Derived>();
    }
    inline static bool registered = (_register(), true);
};

namespace {
class MyClass : public Registrable<MyClass> {
public:
    MyClass() : Registrable() {}
};
}

Steps to reproduce:

1. Build demo.ixx as a module interface.
2. Build main.cpp importing that module, then link.
3. Run the program.

Observed behavior (clang-cl):

• Registrable<MyClass> is instantiated twice.
• Each instantiation has its own inline static bool registered.
• Both registered variables are initialized at startup, so _register() runs twice, producing duplicate registration attempts in Registry.

Expected behavior:
Its inline static member registered should be initialized once, and _register() should run only once.

Notes:

• Moving MyClass out of the anonymous namespace prevents the problem.
• Replacing the "module import" with a "header include" also prevents the problem.

Version:

clang version 20.1.8
Target: x86_64-pc-windows-msvc
Thread model: posix
InstalledDir: C:\Program Files\LLVM\bin

[ChuanqiXu9]

Can you try the trunk?

[Eromythic]

I tried with 21.1.0 and got the same result. I can try latest from main later today, will be AFK for a long while now.

[ChuanqiXu9]

Or you can try it with https://clang.llvm.org/docs/StandardCPlusPlusModules.html#reduced-bmi

[Eromythic]

I used the reduced bmi like so:

1. clang++ -std=c++23 -x c++-module demo.ixx -fmodules-reduced-bmi --precompile -fmodule-output=dem o.reduced.pcm -o demo.full.pcm
2. clang++ -std=c++23 -x c++-module -c demo.ixx -fmodule-file=demo=demo.full.pcm -o demo.o
3. clang++ -std=c++23 -c Main.cpp -fmodule-file=demo=demo.reduced.pcm -o Main.o
4. clang++ Main.o demo.o -o demo_app

And the issue stopped reproducing. Just to check, I re-built Main.o using demo.full.pcm instead, linked, and the issue was popping back up.

So it really seems using the reduced BMI to compile makes the issue go away.

[marakew]

clang-cl != clang

[Eromythic]

In that case I've reproduced it with both, since the original report used clang-cl and the repro with the delineated steps above used clang. (Which didn't repro when using the reduced bmi version, but it did with the full one).

Is your suggestion I remove the [clang-cl] from the title, since it's now shown to not be specific to it?

[ChuanqiXu9]

I used the reduced bmi like so:

1. clang++ -std=c++23 -x c++-module demo.ixx -fmodules-reduced-bmi --precompile -fmodule-output=dem o.reduced.pcm -o demo.full.pcm
2. clang++ -std=c++23 -x c++-module -c demo.ixx -fmodule-file=demo=demo.full.pcm -o demo.o
3. clang++ -std=c++23 -c Main.cpp -fmodule-file=demo=demo.reduced.pcm -o Main.o
4. clang++ Main.o demo.o -o demo_app

And the issue stopped reproducing. Just to check, I re-built Main.o using demo.full.pcm instead, linked, and the issue was popping back up.

So it really seems using the reduced BMI to compile makes the issue go away.

Then I think we can close this. Reduced BMI is enabled by default from clang22. And after that, in clang, the term "BMI" will refer to reduced BMI. The current BMI may be referred as "full BMI" or anything else.

[ChuanqiXu9]

clang-cl != clang

clang-cl is different with clang only in driver parts. They are the same in all other places.