Check that Symbol types are trivially destructible

[sbc100]

Summary

This adds an extra level of static safety to our use of placement
new to allocate Symbol types. It prevents the accidental addition
of a non-trivially-destructible member that could (for example)
allocate and leak memory.

From the spec: Storage occupied by trivially destructible objects
may be reused without calling the destructor.

[ruiu]

LGTM

Thanks! We should've done that from the beginning.

lld/trunk/COFF/Symbols.h

union SymbolUnion {
   alignas(Undefined) char F[sizeof(Undefined)];
   alignas(DefinedImportData) char G[sizeof(DefinedImportData)];
   alignas(DefinedImportThunk) char H[sizeof(DefinedImportThunk)];
   alignas(DefinedLocalImport) char I[sizeof(DefinedLocalImport)];
 };
 
 template <typename T, typename... ArgT>
 void replaceSymbol(Symbol *S, ArgT &&... Arg) {
+  static_assert(std::is_trivially_destructible<T>(),
+                "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
   new (S) T(std::forward<ArgT>(Arg)...);
 }
 } // namespace coff
 
 std::string toString(coff::Symbol &B);
 } // namespace lld
 
 #endif

lld/trunk/ELF/Symbols.h

union SymbolUnion {
   alignas(LazyArchive) char E[sizeof(LazyArchive)];
   alignas(LazyObject) char F[sizeof(LazyObject)];
 };
 
 void printTraceSymbol(Symbol *Sym);
 
 template <typename T, typename... ArgT>
 void replaceSymbol(Symbol *S, ArgT &&... Arg) {
+  static_assert(std::is_trivially_destructible<T>(),
+                "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
 
   Symbol Sym = *S;