我正在一个不鼓励堆分配的嵌入式平台上工作。在构建期间，我也有循环依赖项。考虑到这些限制，我的团队设计了一个静态分配器类，该类用于在.bss节中分配内存，然后以延迟的方式构造对象。
我们面临的问题是在延迟构造过程中，编译器生成的代码尝试引用尚未构造的静态分配内存中的数据-未被构造时，我们平台上的数据为零-这会导致空指针取消引用崩溃系统。
可以通过重新排序类的构造顺序来解决崩溃问题。不幸的是，我无法对此问题进行最低限度的复制。此外，当涉及到虚拟继承时，问题变得越来越严重，难以管理。
我们遇到了针对armclang和Visual Studio编译器的问题，因此似乎我们可能在执行C ++规范之外的事情。
静态分配器代码：
template <class UnderlyingType, typename... Args>
class StaticAllocator
{
private:
typedef std::uint64_t BaseDataType;
// Define a tuple of the variadic template parameters with the references removed
using TupleWithRefsRemoved = std::tuple<typename std::remove_reference<Args>::type...>;
// A function that strips return the ref-less template arguments
template <typename... T>
TupleWithRefsRemoved removeRefsFromTupleMembers(std::tuple<T...> const& t)
{
return TupleWithRefsRemoved{ t };
}
public:
StaticAllocator()
{
const auto ptr = reinterpret_cast<UnderlyingType *>(&m_underlyingData);
assert(ptr != nullptr);
}
virtual StaticAllocator* clone() const
{
return new StaticAllocator<UnderlyingType, Args...>(*this);
}
UnderlyingType *getPtr()
{
return reinterpret_cast<UnderlyingType *>(&m_underlyingData);
}
const UnderlyingType *getPtr() const
{
return reinterpret_cast<const UnderlyingType *>(&m_underlyingData);
}
UnderlyingType *operator->()
{
return getPtr();
}
const UnderlyingType *operator->() const
{
return getPtr();
}
UnderlyingType &operator*()
{
return *getPtr();
}
const UnderlyingType &operator*() const
{
return *getPtr();
}
operator UnderlyingType *()
{
return getPtr();
}
operator const UnderlyingType *() const
{
return getPtr();
}
void construct(Args... args)
{
_construct(TupleWithRefsRemoved(args...), std::index_sequence_for<Args...>());
}
void destroy()
{
const auto ptr = getPtr();
if (ptr != nullptr)
{
ptr->~T();
}
}
private:
BaseDataType m_underlyingData[(sizeof(UnderlyingType) + sizeof(BaseDataType) - 1) / sizeof(BaseDataType)];
// A function that unpacks the tuple of arguments, and constructs them
template <std::size_t... T>
void _construct(const std::tuple<Args...>& args, std::index_sequence<T...>)
{
new (m_underlyingData) UnderlyingType(std::get<T>(args)...);
}
};
简单用法示例：
class InterfaceA
{
// Interface functions here
}
class InterfaceB
{
// Interface functions here
}
class ObjectA : public virtual InterfaceA
{
public:
ObjectA(InterfaceB* intrB) : m_intrB(intrB) {}
private:
InterfaceB* m_intrB;
};
class ObjectB : public virtual InterfaceB
{
public:
ObjectB(InterfaceA* intrA) : m_intrA(intrA) {}
private:
InterfaceA* m_intrA;
}
StaticAllocator<ObjectA, InterfaceB*> objectAStorage;
StaticAllocator<ObjectB, InterfaceA*> objectBStorage;
// Crashes happen in this function, there are many more objects in our real
// system and the order of the objects effects if the crash occurs.
void initialize_objects()
{
auto objA = objectAStorage.getPtr();
auto objB = objectBStorage.getPtr();
objectAStorage.construct(objB);
objectBStorage.construct(objA);
}
答案 0 :(得分：0)
此答案以GCC为例描述了运行时发生的问题。其他编译器将生成具有类似问题的不同代码，因为您的代码具有固有的缺少初始化的问题。
在不出于效率目的而避免动态分配内存的情况下，如果没有通用方法，没有模板，并且分解了每一步，您的代码实际上可以归结为：
class InterfaceA {};
class InterfaceB {};
class ObjectA : public virtual InterfaceA {
public:
ObjectA(InterfaceB *intrB) : m_intrB(intrB) {}
private:
InterfaceB *m_intrB;
};
class ObjectB : public virtual InterfaceB {
public:
ObjectB(InterfaceA *intrA) : m_intrA(intrA) {}
private:
InterfaceA *m_intrA;
};
#include <new>
void simple_init() {
void *ObjectA_mem = operator new(sizeof(ObjectA));
void *ObjectB_mem = operator new(sizeof(ObjectB));
ObjectA *premature_ObjectA = static_cast<ObjectA *>(ObjectA_mem); // still not constructed
ObjectB *premature_ObjectB = static_cast<ObjectB *>(ObjectB_mem);
InterfaceA *ia = premature_ObjectA; // derived-to-base conversion
InterfaceB *ib = premature_ObjectB;
new (ObjectA_mem) ObjectA(ib);
new (ObjectB_mem) ObjectB(ia);
}
为了最大程度地提高编译代码的可读性，让我们改为使用全局变量：
void *ObjectA_mem;
void *ObjectB_mem;
ObjectA *premature_ObjectA;
ObjectB *premature_ObjectB;
InterfaceA *ia;
InterfaceB *ib;
void simple_init() {
ObjectA_mem = operator new(sizeof(ObjectA));
ObjectB_mem = operator new(sizeof(ObjectB));
premature_ObjectA = static_cast<ObjectA *>(ObjectA_mem); // still not constructed
premature_ObjectB = static_cast<ObjectB *>(ObjectB_mem);
ia = premature_ObjectA; // derived-to-base conversion
ib = premature_ObjectB;
new (ObjectA_mem) ObjectA(ib);
new (ObjectB_mem) ObjectB(ia);
}
那个gives us a very nice assembly code。我们可以看到以下语句：
ia = premature_ObjectA; // derived-to-base conversion
编译为：
movq premature_ObjectA(%rip), %rax
testq %rax, %rax
je .L6
movq premature_ObjectA(%rip), %rdx
movq premature_ObjectA(%rip), %rax
movq (%rax), %rax
subq $24, %rax
movq (%rax), %rax
addq %rdx, %rax
jmp .L7
.L6:
movl $0, %eax
.L7:
movq %rax, ia(%rip)
首先，我们看到（未优化的）代码测试的是空指针，等于
if (premature_ObjectA == 0)
ia = 0;
else
// real stuff
真正的东西是：
movq premature_ObjectA(%rip), %rdx
movq premature_ObjectA(%rip), %rax
movq (%rax), %rax
subq $24, %rax
movq (%rax), %rax
addq %rdx, %rax
movq %rax, ia(%rip)
因此，解引用premature_ObjectA所指向的值，将其解释为指针，并减少24，结果指针将用于读取一个值，并将该值添加到原始指针premature_ObjectA中。由于premature_ObjectA的内容尚未初始化，因此显然无法正常工作。
发生的事情是，编译器正在获取vptr（vtable指针）以从级别0（像建筑物的vtable可以具有负楼层）读取-3“ quad”（3 * 8 = 24）处的条目只是表示0楼不是最低楼层）：
vtable for ObjectA:
.quad 0
.quad 0
.quad typeinfo for ObjectA
vtable for ObjectB:
.quad 0
.quad 0
.quad typeinfo for ObjectB
（每个对象的）vtable 从其结尾开始，在“ ObjectA的typeinfo”之后，如我们在ObjectA::ObjectA(InterfaceB*)的已编译代码中看到的那样：
movl $vtable for ObjectA+24, %edx
...
movq %rdx, (%rax)
因此，在构建过程中，将vptr设置为第一个虚拟函数之前的vtable的“ floor 0”，如果没有虚拟函数，则将其结尾。
在-3楼有vtable的开头：
vtable for ObjectA:
.quad 0
值0表示“ InterfaceA在完整ObjectA对象内的偏移量为0”。
vtable布局的细节取决于编译器，其原理是：
InterfaceA基类的过程中使用这些隐藏的成员保持不变。
我的解释并没有提供解决办法：我们甚至不知道您遇到哪种高级问题，以及为什么使用这些构造函数参数和相互依赖的类。
知道这些类代表什么，我们也许可以提供更多帮助。