This is an archive of the discontinued LLVM Phabricator instance.

Differential D43305

Convert an assert to a static_assert. NFC.
ClosedPublic

Authored by sbc100 on Feb 14 2018, 11:17 AM.

Details

Reviewers
ruiu
ncw
Commits
rGab31b7759dc3: Convert an assert to a static_assert. NFC.
rLLD325158: Convert an assert to a static_assert. NFC.
rL325158: Convert an assert to a static_assert. NFC.
Summary

This check is simply verifying the static_cast is valid between the two types.

Diff Detail

Repository
rLLD LLVM Linker

Event Timeline

sbc100 created this revision.Feb 14 2018, 11:17 AM
Herald added subscribers: llvm-commits, aheejin, arichardson, emaste. · View Herald TranscriptFeb 14 2018, 11:17 AM
Harbormaster completed remote builds in B14981: Diff 134270.Feb 14 2018, 11:17 AM
sbc100 edited the summary of this revision. (Show Details)Feb 14 2018, 11:18 AM
sbc100 added reviewers: ruiu, ncw.
ruiu accepted this revision.Feb 14 2018, 11:25 AM

LGTM

This revision is now accepted and ready to land.Feb 14 2018, 11:25 AM
Closed by commit rL325158: Convert an assert to a static_assert. NFC. (authored by sbc). · Explain WhyFeb 14 2018, 11:33 AM
Closed by commit rLLD325158: Convert an assert to a static_assert. NFC. (authored by sbc). · Explain Why
This revision was automatically updated to reflect the committed changes.
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
COFF/
4 lines
ELF/
4 lines
wasm/
4 lines

Diff 134280

COFF/Symbols.h

Show First 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
template <typename T, typename... ArgT> template <typename T, typename... ArgT>
void replaceSymbol(Symbol *S, ArgT &&... Arg) { void replaceSymbol(Symbol *S, ArgT &&... Arg) {
static_assert(std::is_trivially_destructible<T>(), static_assert(std::is_trivially_destructible<T>(),
"Symbol types must be trivially destructible"); "Symbol types must be trivially destructible");
static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small"); static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
static_assert(alignof(T) <= alignof(SymbolUnion), static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough"); "SymbolUnion not aligned enough");
assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr && static_assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr,
"Not a Symbol"); "Not a Symbol");
new (S) T(std::forward<ArgT>(Arg)...); new (S) T(std::forward<ArgT>(Arg)...);
} }
} // namespace coff } // namespace coff
std::string toString(coff::Symbol &B); std::string toString(coff::Symbol &B);
} // namespace lld } // namespace lld
#endif #endif

ELF/Symbols.h

Show First 20 Lines • Show All 349 Lines • ▼ Show 20 Lines
template <typename T, typename... ArgT> template <typename T, typename... ArgT>
void replaceSymbol(Symbol *S, ArgT &&... Arg) { void replaceSymbol(Symbol *S, ArgT &&... Arg) {
static_assert(std::is_trivially_destructible<T>(), static_assert(std::is_trivially_destructible<T>(),
"Symbol types must be trivially destructible"); "Symbol types must be trivially destructible");
static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small"); static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
static_assert(alignof(T) <= alignof(SymbolUnion), static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough"); "SymbolUnion not aligned enough");
assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr && static_assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr,
"Not a Symbol"); "Not a Symbol");
Symbol Sym = *S; Symbol Sym = *S;
new (S) T(std::forward<ArgT>(Arg)...); new (S) T(std::forward<ArgT>(Arg)...);
S->VersionId = Sym.VersionId; S->VersionId = Sym.VersionId;
S->Visibility = Sym.Visibility; S->Visibility = Sym.Visibility;
S->IsUsedInRegularObj = Sym.IsUsedInRegularObj; S->IsUsedInRegularObj = Sym.IsUsedInRegularObj;
Show All 16 Lines

wasm/Symbols.h

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
template <typename T, typename... ArgT> template <typename T, typename... ArgT>
T *replaceSymbol(Symbol *S, ArgT &&... Arg) { T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
static_assert(std::is_trivially_destructible<T>(), static_assert(std::is_trivially_destructible<T>(),
"Symbol types must be trivially destructible"); "Symbol types must be trivially destructible");
static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small"); static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
static_assert(alignof(T) <= alignof(SymbolUnion), static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough"); "SymbolUnion not aligned enough");
assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr && static_assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr,
"Not a Symbol"); "Not a Symbol");
return new (S) T(std::forward<ArgT>(Arg)...); return new (S) T(std::forward<ArgT>(Arg)...);
} }
} // namespace wasm } // namespace wasm
// Returns a symbol name for an error message. // Returns a symbol name for an error message.
std::string toString(const wasm::Symbol &Sym); std::string toString(const wasm::Symbol &Sym);
std::string toString(wasm::Symbol::Kind Kind); std::string toString(wasm::Symbol::Kind Kind);
} // namespace lld } // namespace lld
#endif #endif