在GCC 6.3.0中违反ODR，且在两个单独的转换单元中定义了类型

Question

通过以下代码示例，我们在GCC中看到了一些奇怪的行为。 奇怪的行为是在GCC 6.3.0中违反了ODR，其类型在两个单独的转换单元中定义。 它可能与递归类型定义或不完整类型有关。

我们不确定代码是否有效，或者我们是否以递归定义类型的方式依赖未定义的行为。 请查看如何在两个单独的cpp文件中定义和实例化类似变量的Dynamic类模板。

dynamic_test.h：

#pragma once

#include <algorithm>
#include <type_traits>

namespace dynamic
{
    template <class T>
    void erasure_destroy( const void *p )
    {
        reinterpret_cast<const T*>( p )->~T();
    }

    template <class T>
    void erasure_copy( void *pDest, const void *pSrc )
    {
        ::new( pDest ) T( *reinterpret_cast<const T*>( pSrc ) );
    }

    template <class T>
    struct TypeArg {};

    struct ErasureFuncs
    {
        template <class T = ErasureFuncs>
        ErasureFuncs( TypeArg<T> t = TypeArg<T>() ) :
            pDestroy( &erasure_destroy<T> ),
            pCopy( &erasure_copy<T> )
        {
            (void)t;
        }

        std::add_pointer_t<void( const void* )> pDestroy;
        std::add_pointer_t<void( void*, const void* )> pCopy;
    };

    enum class TypeValue
    {
        Null,
        Number,
        Vector
    };

    template <typename T>
    using unqual = std::remove_cv_t<std::remove_reference_t<T>>;

    template <class Base, class Derived>
    using disable_if_same_or_derived = std::enable_if_t<!std::is_base_of<Base, unqual<Derived>>::value>;

    template <template <class> class TypesT>
    struct Dynamic
    {
        using Types = TypesT<Dynamic>;

        using Null = typename Types::Null;
        using Number = typename Types::Number;
        using Vector = typename Types::Vector;

        Dynamic()
        {
            construct<Null>( nullptr );
        }

        ~Dynamic()
        {
            m_erasureFuncs.pDestroy( &m_data );
        }

        Dynamic( const Dynamic &d ) :
            m_typeValue( d.m_typeValue ),
            m_erasureFuncs( d.m_erasureFuncs )
        {
            m_erasureFuncs.pCopy( &m_data, &d.m_data );
        }

        Dynamic( Dynamic &&d ) = delete;

        template <class T, class = disable_if_same_or_derived<Dynamic, T>>
        Dynamic( T &&value )
        {
            construct<unqual<T>>( std::forward<T>( value ) );
        }

        Dynamic &operator=( const Dynamic &d ) = delete;
        Dynamic &operator=( Dynamic &&d ) = delete;

    private:
        static TypeValue to_type_value( TypeArg<Null> )
        {
            return TypeValue::Null;
        }

        static TypeValue to_type_value( TypeArg<Number> )
        {
            return TypeValue::Number;
        }

        static TypeValue to_type_value( TypeArg<Vector> )
        {
            return TypeValue::Vector;
        }

        template <class T, class...Args>
        void construct( Args&&...args )
        {
            m_typeValue = to_type_value( TypeArg<T>() );
            m_erasureFuncs = TypeArg<T>();
            new ( &m_data ) T( std::forward<Args>( args )... );
        }

    private:
        TypeValue m_typeValue;
        ErasureFuncs m_erasureFuncs;
        std::aligned_union_t<0, Null, Number, Vector> m_data;
    };
}

void test1();
void test2();

dynamic_test_1.cpp：

#include "dynamic_test.h"

#include <vector>

namespace
{
    template <class DynamicType>
    struct Types
    {
        using Null = std::nullptr_t;
        using Number = long double;
        using Vector = std::vector<DynamicType>;
    };

    using D = dynamic::Dynamic<Types>;
}

void test1()
{
    D::Vector v1;
    v1.emplace_back( D::Number( 0 ) );
}

dynamic_test_2.cpp：

#include "dynamic_test.h"

#include <vector>

namespace
{
    template <class DynamicType>
    struct Types
    {
        using Null = std::nullptr_t;
        using Number = double;
        using Vector = std::vector<DynamicType>;
    };

    using D = dynamic::Dynamic<Types>;
}

void test2()
{
    D::Vector v1;
    v1.emplace_back( D::Number( 0 ) );
}

main.cpp：

#include "dynamic_test.h"

int main( int, char* const [] )
{
    test1();
    test2();
    return 0;
}

运行此代码将导致SIGSEGV具有以下堆栈跟踪：

1 ??                                                                                                                                     0x1fa51  
2 dynamic::Dynamic<(anonymous namespace)::Types>::~Dynamic                                                        dynamic_test.h     66  0x40152b 
3 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types>>                                                   stl_construct.h    93  0x4013c1 
4 std::_Destroy_aux<false>::__destroy<dynamic::Dynamic<(anonymous namespace)::Types> *>                           stl_construct.h    103 0x40126b 
5 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types> *>                                                 stl_construct.h    126 0x400fa8 
6 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types> *, dynamic::Dynamic<(anonymous namespace)::Types>> stl_construct.h    151 0x400cd1 
7 std::vector<dynamic::Dynamic<(anonymous namespace)::Types>>::~vector                                            stl_vector.h       426 0x400b75 
8 test2                                                                                                           dynamic_test_2.cpp 20  0x401796 
9 main                                                                                                            main.cpp           6   0x400a9f 

构造Vector将我们直接带到析构函数是很奇怪的。

十分奇怪的是，当我们执行以下操作时，这些错误就会消失：

1. 在一个cpp文件中重命名“类型”，以使它们不会为类模板使用相同的名称。
2. 在每个cpp文件中使“类型”的实现相同（在每个文件中将Number更改为double）。
3. 不要将数字推送到向量。
4. 将Dynamic的实现更改为不使用此递归类型定义样式。

这是一个有效的实现的精简示例：

template <class Types>
struct Dynamic
{
    using Null = typename Types::Null;
    using Number = typename Types::Number;
    using Vector = typename Types::template Vector<Dynamic>;

...

    struct Types
{
    using Null = std::nullptr_t;
    using Number = long double;

    template <class DynamicType>
    using Vector = std::vector<DynamicType>;
};

使用链接时间优化（LTO）进行编译时，我们还会看到一些与ODR违规有关的警告：

dynamic_test.h:51: warning: type ‘struct Dynamic’ violates the C++ One Definition Rule [-Wodr]
struct Dynamic
         ^

是否有人对导致此问题的原因有一些了解？

Answer 1

好的，我花了一些时间来打开和关闭它，但最终我得到了一个非常简单的副本，成为问题的核心。 首先，考虑test1.cpp ：

#include "header.h"

#include <iostream>

namespace {

template <class T>
struct Foo {
   static int foo() { return 1; };
};

using D = Bar<Foo>;

}

void test1() {
    std::cerr << "Test1: " << D::foo() << "\n";
}

现在， test2.cpp与此完全相同，除了Foo::foo返回2，并且在底部声明的函数称为test2并输出Test2:依此类推。 接下来， header.h ：

template <template <class> class TT>
struct Bar {
    using type = TT<Bar>;

    static int foo() { return type::foo(); }
};


void test1();
void test2();

最后， main.x.cpp ：

#include "header.h"

int main() {
    test1();
    test2();
    return 0;
}

您可能会惊讶地发现该程序可以打印：

Test1: 1
Test2: 1

当然，那只是因为我使用以下命令进行编译：

g++ -std=c++14 main.x.cpp test1.cpp test2.cpp

如果我颠倒了最后两个文件的顺序，它们都将打印2。

发生的情况是，链接器最终使用它在任何需要的地方都遇到的Foo的第一个定义。 嗯，但是我们在匿名名称空间中定义了Foo ，这应该给它内部链接，避免了这个问题。 因此，我们只编译一个TU，然后在其上使用nm ：

g++ -std=c++14 -c test1.cpp
nm -C test1.o

这将产生以下结果：

                 U __cxa_atexit
                 U __dso_handle
0000000000000087 t _GLOBAL__sub_I__Z5test1v
0000000000000049 t __static_initialization_and_destruction_0(int, int)
0000000000000000 T test1()
000000000000003e t (anonymous namespace)::Foo<Bar<(anonymous namespace)::Foo> >::foo()
0000000000000000 W Bar<(anonymous namespace)::Foo>::foo()
                 U std::ostream::operator<<(int)
                 U std::ios_base::Init::Init()
                 U std::ios_base::Init::~Init()
                 U std::cerr
0000000000000000 r std::piecewise_construct
0000000000000000 b std::__ioinit
                 U std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)

除了大写和小写之外，现在不必担心字母。 小写字母符号是私有的，这是我们期望内部链接符号的方式。 大写字母符号是公共的，并且具有外部链接，并且对于链接器是公开的。

有趣的是，虽然Foo可能具有内部链接，但Bar却没有！ 第一个转换单元已经使用外部链接定义了符号Bar<Foo> 。 第二翻译单元执行相同的操作。 因此，当链接器链接它们时，它会看到两个翻译单元试图通过外部链接定义相同的符号。 请注意，它是内联定义的类成员，因此它是隐式内联的。 因此，链接器将一如既往地处理此问题：它只是将所有遇到的定义静默地丢弃在第一个之后（因为符号已经定义;链接器从左到右就是这样工作），因此在每个TU中都正确定义了Foo 。 ，但Bar<Foo>不是。

最重要的是，这是违反ODR的行为。 您将需要重新考虑一些东西。

编辑：看来实际上这是gcc中的错误。 该标准的措辞暗示在这种情况下应该对Foo进行唯一处理，因此，在每个Foo上模板化的Bar应该分开。 链接到错误： https : //gcc.gnu.org/bugzilla/show_bug.cgi?id=70413 。