From c8477b82341bdaad43ba9d334c798e918438b2f3 Mon Sep 17 00:00:00 2001 From: Peter Collingbourne Date: Mon, 27 Nov 2017 21:37:51 +0000 Subject: [PATCH] Revert r319090, "COFF: Do not create SectionChunks for discarded comdat sections." Caused test failures in check-cfi on Windows. http://lab.llvm.org:8011/builders/sanitizer-windows/builds/20284 llvm-svn: 319100 --- lld/COFF/Chunks.cpp | 11 +- lld/COFF/Chunks.h | 21 ++- lld/COFF/InputFiles.cpp | 272 +++++++++++--------------------- lld/COFF/InputFiles.h | 14 +- lld/COFF/MarkLive.cpp | 7 + lld/COFF/SymbolTable.cpp | 66 +++++--- lld/COFF/SymbolTable.h | 5 +- lld/COFF/Symbols.h | 1 + lld/test/COFF/reloc-discarded.s | 1 + llvm/include/llvm/Object/COFF.h | 14 -- 10 files changed, 169 insertions(+), 243 deletions(-) diff --git a/lld/COFF/Chunks.cpp b/lld/COFF/Chunks.cpp index df98a041cd5c..e83a8c6e458f 100644 --- a/lld/COFF/Chunks.cpp +++ b/lld/COFF/Chunks.cpp @@ -38,6 +38,9 @@ SectionChunk::SectionChunk(ObjFile *F, const coff_section *H) Alignment = Header->getAlignment(); + // Chunks may be discarded during comdat merging. + Discarded = false; + // If linker GC is disabled, every chunk starts out alive. If linker GC is // enabled, treat non-comdat sections as roots. Generally optimized object // files will be built with -ffunction-sections or /Gy, so most things worth @@ -359,8 +362,12 @@ bool SectionChunk::isCOMDAT() const { void SectionChunk::printDiscardedMessage() const { // Removed by dead-stripping. If it's removed by ICF, ICF already // printed out the name, so don't repeat that here. - if (Sym && this == Repl) - message("Discarded " + Sym->getName()); + if (Sym && this == Repl) { + if (Discarded) + message("Discarded comdat symbol " + Sym->getName()); + else if (!Live) + message("Discarded " + Sym->getName()); + } } StringRef SectionChunk::getDebugName() { diff --git a/lld/COFF/Chunks.h b/lld/COFF/Chunks.h index 381527ee6ef2..4effc71ab7ac 100644 --- a/lld/COFF/Chunks.h +++ b/lld/COFF/Chunks.h @@ -159,9 +159,10 @@ public: void addAssociative(SectionChunk *Child); StringRef getDebugName() override; + void setSymbol(DefinedRegular *S) { if (!Sym) Sym = S; } - // Returns true if the chunk was not dropped by GC. - bool isLive() { return Live; } + // Returns true if the chunk was not dropped by GC or COMDAT deduplication. + bool isLive() { return Live && !Discarded; } // Used by the garbage collector. void markLive() { @@ -170,6 +171,13 @@ public: Live = true; } + // Returns true if this chunk was dropped by COMDAT deduplication. + bool isDiscarded() const { return Discarded; } + + // Used by the SymbolTable when discarding unused comdat sections. This is + // redundant when GC is enabled, as all comdat sections will start out dead. + void markDiscarded() { Discarded = true; } + // True if this is a codeview debug info chunk. These will not be laid out in // the image. Instead they will end up in the PDB, if one is requested. bool isCodeView() const { @@ -205,21 +213,24 @@ public: // The file that this chunk was created from. ObjFile *File; - // The COMDAT leader symbol if this is a COMDAT chunk. - DefinedRegular *Sym = nullptr; - private: StringRef SectionName; std::vector AssocChildren; llvm::iterator_range Relocs; size_t NumRelocs; + // True if this chunk was discarded because it was a duplicate comdat section. + bool Discarded; + // Used by the garbage collector. bool Live; // Used for ICF (Identical COMDAT Folding) void replace(SectionChunk *Other); uint32_t Class[2] = {0, 0}; + + // Sym points to a section symbol if this is a COMDAT chunk. + DefinedRegular *Sym = nullptr; }; // A chunk for common symbols. Common chunks don't have actual data. diff --git a/lld/COFF/InputFiles.cpp b/lld/COFF/InputFiles.cpp index 0ecfbdaf7373..20ba70618135 100644 --- a/lld/COFF/InputFiles.cpp +++ b/lld/COFF/InputFiles.cpp @@ -119,158 +119,86 @@ void ObjFile::parse() { initializeSEH(); } -// We set SectionChunk pointers in the SparseChunks vector to this value -// temporarily to mark comdat sections as having an unknown resolution. As we -// walk the object file's symbol table, once we visit either a leader symbol or -// an associative section definition together with the parent comdat's leader, -// we set the pointer to either nullptr (to mark the section as discarded) or a -// valid SectionChunk for that section. -static SectionChunk *const PendingComdat = reinterpret_cast(1); - void ObjFile::initializeChunks() { uint32_t NumSections = COFFObj->getNumberOfSections(); Chunks.reserve(NumSections); SparseChunks.resize(NumSections + 1); for (uint32_t I = 1; I < NumSections + 1; ++I) { const coff_section *Sec; + StringRef Name; if (auto EC = COFFObj->getSection(I, Sec)) fatal("getSection failed: #" + Twine(I) + ": " + EC.message()); + if (auto EC = COFFObj->getSectionName(Sec, Name)) + fatal("getSectionName failed: #" + Twine(I) + ": " + EC.message()); + if (Name == ".sxdata") { + SXData = Sec; + continue; + } + if (Name == ".drectve") { + ArrayRef Data; + COFFObj->getSectionContents(Sec, Data); + Directives = std::string((const char *)Data.data(), Data.size()); + continue; + } - if (Sec->Characteristics & IMAGE_SCN_LNK_COMDAT) - SparseChunks[I] = PendingComdat; + // Object files may have DWARF debug info or MS CodeView debug info + // (or both). + // + // DWARF sections don't need any special handling from the perspective + // of the linker; they are just a data section containing relocations. + // We can just link them to complete debug info. + // + // CodeView needs a linker support. We need to interpret and debug + // info, and then write it to a separate .pdb file. + + // Ignore debug info unless /debug is given. + if (!Config->Debug && Name.startswith(".debug")) + continue; + + if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE) + continue; + auto *C = make(this, Sec); + + // CodeView sections are stored to a different vector because they are not + // linked in the regular manner. + if (C->isCodeView()) + DebugChunks.push_back(C); else - SparseChunks[I] = readSection(I, nullptr); + Chunks.push_back(C); + + SparseChunks[I] = C; } } -SectionChunk *ObjFile::readSection(uint32_t SectionNumber, - const coff_aux_section_definition *Def) { - const coff_section *Sec; - StringRef Name; - if (auto EC = COFFObj->getSection(SectionNumber, Sec)) - fatal("getSection failed: #" + Twine(SectionNumber) + ": " + EC.message()); - if (auto EC = COFFObj->getSectionName(Sec, Name)) - fatal("getSectionName failed: #" + Twine(SectionNumber) + ": " + - EC.message()); - if (Name == ".sxdata") { - SXData = Sec; - return nullptr; - } - if (Name == ".drectve") { - ArrayRef Data; - COFFObj->getSectionContents(Sec, Data); - Directives = std::string((const char *)Data.data(), Data.size()); - return nullptr; - } - - // Object files may have DWARF debug info or MS CodeView debug info - // (or both). - // - // DWARF sections don't need any special handling from the perspective - // of the linker; they are just a data section containing relocations. - // We can just link them to complete debug info. - // - // CodeView needs a linker support. We need to interpret and debug - // info, and then write it to a separate .pdb file. - - // Ignore debug info unless /debug is given. - if (!Config->Debug && Name.startswith(".debug")) - return nullptr; - - if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE) - return nullptr; - auto *C = make(this, Sec); - if (Def) - C->Checksum = Def->CheckSum; - - // CodeView sections are stored to a different vector because they are not - // linked in the regular manner. - if (C->isCodeView()) - DebugChunks.push_back(C); - else - Chunks.push_back(C); - - return C; -} - -void ObjFile::readAssociativeDefinition( - COFFSymbolRef Sym, const coff_aux_section_definition *Def) { - SectionChunk *Parent = SparseChunks[Def->getNumber(Sym.isBigObj())]; - - // If the parent is pending, it probably means that its section definition - // appears after us in the symbol table. Leave the associated section as - // pending; we will handle it during the second pass in initializeSymbols(). - if (Parent == PendingComdat) - return; - - // Check whether the parent is prevailing. If it is, so are we, and we read - // the section; otherwise mark it as discarded. - int32_t SectionNumber = Sym.getSectionNumber(); - if (Parent) { - SparseChunks[SectionNumber] = readSection(SectionNumber, Def); - Parent->addAssociative(SparseChunks[SectionNumber]); - } else { - SparseChunks[SectionNumber] = nullptr; - } -} - -Symbol *ObjFile::createRegular(COFFSymbolRef Sym) { - SectionChunk *SC = SparseChunks[Sym.getSectionNumber()]; - if (Sym.isExternal()) { - StringRef Name; - COFFObj->getSymbolName(Sym, Name); - if (SC) - return Symtab->addRegular(this, Name, Sym.getGeneric(), SC); - return Symtab->addUndefined(Name, this, false); - } - if (SC) - return make(this, /*Name*/ "", false, - /*IsExternal*/ false, Sym.getGeneric(), SC); - return nullptr; -} - void ObjFile::initializeSymbols() { uint32_t NumSymbols = COFFObj->getNumberOfSymbols(); Symbols.resize(NumSymbols); SmallVector, 8> WeakAliases; - std::vector PendingIndexes; - PendingIndexes.reserve(NumSymbols); - - std::vector ComdatDefs( - COFFObj->getNumberOfSections() + 1); + int32_t LastSectionNumber = 0; for (uint32_t I = 0; I < NumSymbols; ++I) { COFFSymbolRef COFFSym = check(COFFObj->getSymbol(I)); - if (COFFSym.isUndefined()) { - Symbols[I] = createUndefined(COFFSym); - } else if (COFFSym.isWeakExternal()) { - Symbols[I] = createUndefined(COFFSym); - uint32_t TagIndex = COFFSym.getAux()->TagIndex; - WeakAliases.emplace_back(Symbols[I], TagIndex); - } else if (Optional OptSym = createDefined(COFFSym, ComdatDefs)) { - Symbols[I] = *OptSym; - } else { - // createDefined() returns None if a symbol belongs to a section that - // was pending at the point when the symbol was read. This can happen in - // two cases: - // 1) section definition symbol for a comdat leader; - // 2) symbol belongs to a comdat section associated with a section whose - // section definition symbol appears later in the symbol table. - // In both of these cases, we can expect the section to be resolved by - // the time we finish visiting the remaining symbols in the symbol - // table. So we postpone the handling of this symbol until that time. - PendingIndexes.push_back(I); - } - I += COFFSym.getNumberOfAuxSymbols(); - } - for (uint32_t I : PendingIndexes) { - COFFSymbolRef Sym = check(COFFObj->getSymbol(I)); - if (auto *Def = Sym.getSectionDefinition()) - if (Def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) - readAssociativeDefinition(Sym, Def); - Symbols[I] = createRegular(Sym); + const void *AuxP = nullptr; + if (COFFSym.getNumberOfAuxSymbols()) + AuxP = check(COFFObj->getSymbol(I + 1)).getRawPtr(); + bool IsFirst = (LastSectionNumber != COFFSym.getSectionNumber()); + + Symbol *Sym = nullptr; + if (COFFSym.isUndefined()) { + Sym = createUndefined(COFFSym); + } else if (COFFSym.isWeakExternal()) { + Sym = createUndefined(COFFSym); + uint32_t TagIndex = + static_cast(AuxP)->TagIndex; + WeakAliases.emplace_back(Sym, TagIndex); + } else { + Sym = createDefined(COFFSym, AuxP, IsFirst); + } + Symbols[I] = Sym; + I += COFFSym.getNumberOfAuxSymbols(); + LastSectionNumber = COFFSym.getSectionNumber(); } for (auto &KV : WeakAliases) { @@ -286,9 +214,8 @@ Symbol *ObjFile::createUndefined(COFFSymbolRef Sym) { return Symtab->addUndefined(Name, this, Sym.isWeakExternal()); } -Optional ObjFile::createDefined( - COFFSymbolRef Sym, - std::vector &ComdatDefs) { +Symbol *ObjFile::createDefined(COFFSymbolRef Sym, const void *AuxP, + bool IsFirst) { StringRef Name; if (Sym.isCommon()) { auto *C = make(Sym); @@ -327,46 +254,37 @@ Optional ObjFile::createDefined( if ((uint32_t)SectionNumber >= SparseChunks.size()) fatal("broken object file: " + toString(this)); - // Handle comdat leader symbols. - if (const coff_aux_section_definition *Def = ComdatDefs[SectionNumber]) { - ComdatDefs[SectionNumber] = nullptr; - Symbol *Leader; - bool Prevailing; - if (Sym.isExternal()) { - COFFObj->getSymbolName(Sym, Name); - std::tie(Leader, Prevailing) = - Symtab->addComdat(this, Name, Sym.getGeneric()); - } else { - Leader = make(this, /*Name*/ "", false, - /*IsExternal*/ false, Sym.getGeneric()); - Prevailing = true; - } - if (Prevailing) { - SectionChunk *C = readSection(SectionNumber, Def); - SparseChunks[SectionNumber] = C; - C->Sym = cast(Leader); - cast(Leader)->Data = &C->Repl; - } else { - SparseChunks[SectionNumber] = nullptr; - } - return Leader; + // Nothing else to do without a section chunk. + auto *SC = SparseChunks[SectionNumber]; + if (!SC) + return nullptr; + + // Handle section definitions + if (IsFirst && AuxP) { + auto *Aux = reinterpret_cast(AuxP); + if (Aux->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) + if (auto *ParentSC = SparseChunks[Aux->getNumber(Sym.isBigObj())]) { + ParentSC->addAssociative(SC); + // If we already discarded the parent, discard the child. + if (ParentSC->isDiscarded()) + SC->markDiscarded(); + } + SC->Checksum = Aux->CheckSum; } - // Read associative section definitions and prepare to handle the comdat - // leader symbol by setting the section's ComdatDefs pointer if we encounter a - // non-associative comdat. - if (SparseChunks[SectionNumber] == PendingComdat) { - if (auto *Def = Sym.getSectionDefinition()) { - if (Def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) - readAssociativeDefinition(Sym, Def); - else - ComdatDefs[SectionNumber] = Def; - } - } + DefinedRegular *B; + if (Sym.isExternal()) { + COFFObj->getSymbolName(Sym, Name); + Symbol *S = + Symtab->addRegular(this, Name, SC->isCOMDAT(), Sym.getGeneric(), SC); + B = cast(S); + } else + B = make(this, /*Name*/ "", SC->isCOMDAT(), + /*IsExternal*/ false, Sym.getGeneric(), SC); + if (SC->isCOMDAT() && Sym.getValue() == 0 && !AuxP) + SC->setSymbol(B); - if (SparseChunks[SectionNumber] == PendingComdat) - return None; - return createRegular(Sym); + return B; } void ObjFile::initializeSEH() { @@ -443,12 +361,8 @@ void ImportFile::parse() { void BitcodeFile::parse() { Obj = check(lto::InputFile::create(MemoryBufferRef( MB.getBuffer(), Saver.save(ParentName + MB.getBufferIdentifier())))); - std::vector> Comdat(Obj->getComdatTable().size()); - for (size_t I = 0; I != Obj->getComdatTable().size(); ++I) - Comdat[I] = Symtab->addComdat(this, Saver.save(Obj->getComdatTable()[I])); for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) { StringRef SymName = Saver.save(ObjSym.getName()); - int ComdatIndex = ObjSym.getComdatIndex(); Symbol *Sym; if (ObjSym.isUndefined()) { Sym = Symtab->addUndefined(SymName, this, false); @@ -460,15 +374,9 @@ void BitcodeFile::parse() { std::string Fallback = ObjSym.getCOFFWeakExternalFallback(); Symbol *Alias = Symtab->addUndefined(Saver.save(Fallback)); checkAndSetWeakAlias(Symtab, this, Sym, Alias); - } else if (ComdatIndex != -1) { - if (SymName == Obj->getComdatTable()[ComdatIndex]) - Sym = Comdat[ComdatIndex].first; - else if (Comdat[ComdatIndex].second) - Sym = Symtab->addRegular(this, SymName); - else - Sym = Symtab->addUndefined(SymName, this, false); } else { - Sym = Symtab->addRegular(this, SymName); + bool IsCOMDAT = ObjSym.getComdatIndex() != -1; + Sym = Symtab->addRegular(this, SymName, IsCOMDAT); } SymbolBodies.push_back(Sym); } diff --git a/lld/COFF/InputFiles.h b/lld/COFF/InputFiles.h index e4dee4c54ebb..3ffb3bf2ab2e 100644 --- a/lld/COFF/InputFiles.h +++ b/lld/COFF/InputFiles.h @@ -142,19 +142,7 @@ private: void initializeSymbols(); void initializeSEH(); - SectionChunk * - readSection(uint32_t SectionNumber, - const llvm::object::coff_aux_section_definition *Def); - - void readAssociativeDefinition( - COFFSymbolRef COFFSym, - const llvm::object::coff_aux_section_definition *Def); - - llvm::Optional - createDefined(COFFSymbolRef Sym, - std::vector - &ComdatDefs); - Symbol *createRegular(COFFSymbolRef Sym); + Symbol *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst); Symbol *createUndefined(COFFSymbolRef Sym); std::unique_ptr COFFObj; diff --git a/lld/COFF/MarkLive.cpp b/lld/COFF/MarkLive.cpp index b1e27bafb1e9..a523a41f764e 100644 --- a/lld/COFF/MarkLive.cpp +++ b/lld/COFF/MarkLive.cpp @@ -52,6 +52,13 @@ void markLive(const std::vector &Chunks) { while (!Worklist.empty()) { SectionChunk *SC = Worklist.pop_back_val(); + + // If this section was discarded, there are relocations referring to + // discarded sections. Ignore these sections to avoid crashing. They will be + // diagnosed during relocation processing. + if (SC->isDiscarded()) + continue; + assert(SC->isLive() && "We mark as live when pushing onto the worklist!"); // Mark all symbols listed in the relocation table for this section. diff --git a/lld/COFF/SymbolTable.cpp b/lld/COFF/SymbolTable.cpp index 5960bf042e59..db3d309c8703 100644 --- a/lld/COFF/SymbolTable.cpp +++ b/lld/COFF/SymbolTable.cpp @@ -24,6 +24,36 @@ using namespace llvm; namespace lld { namespace coff { +enum SymbolPreference { + SP_EXISTING = -1, + SP_CONFLICT = 0, + SP_NEW = 1, +}; + +/// Checks if an existing symbol S should be kept or replaced by a new symbol. +/// Returns SP_EXISTING when S should be kept, SP_NEW when the new symbol +/// should be kept, and SP_CONFLICT if no valid resolution exists. +static SymbolPreference compareDefined(Symbol *S, bool WasInserted, + bool NewIsCOMDAT) { + // If the symbol wasn't previously known, the new symbol wins by default. + if (WasInserted || !isa(S)) + return SP_NEW; + + // If the existing symbol is a DefinedRegular, both it and the new symbol + // must be comdats. In that case, we have no reason to prefer one symbol + // over the other, and we keep the existing one. If one of the symbols + // is not a comdat, we report a conflict. + if (auto *R = dyn_cast(S)) { + if (NewIsCOMDAT && R->isCOMDAT()) + return SP_EXISTING; + else + return SP_CONFLICT; + } + + // Existing symbol is not a DefinedRegular; new symbol wins. + return SP_NEW; +} + SymbolTable *Symtab; void SymbolTable::addFile(InputFile *File) { @@ -210,7 +240,7 @@ Symbol *SymbolTable::addSynthetic(StringRef N, Chunk *C) { return S; } -Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, +Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, bool IsCOMDAT, const coff_symbol_generic *Sym, SectionChunk *C) { Symbol *S; @@ -218,30 +248,20 @@ Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, std::tie(S, WasInserted) = insert(N); if (!isa(F)) S->IsUsedInRegularObj = true; - if (WasInserted || !isa(S)) - replaceSymbol(S, F, N, /*IsCOMDAT*/ false, - /*IsExternal*/ true, Sym, C); - else + SymbolPreference SP = compareDefined(S, WasInserted, IsCOMDAT); + if (SP == SP_CONFLICT) { reportDuplicate(S, F); - return S; -} - -std::pair -SymbolTable::addComdat(InputFile *F, StringRef N, - const coff_symbol_generic *Sym) { - Symbol *S; - bool WasInserted; - std::tie(S, WasInserted) = insert(N); - if (!isa(F)) - S->IsUsedInRegularObj = true; - if (WasInserted || !isa(S)) { - replaceSymbol(S, F, N, /*IsCOMDAT*/ true, - /*IsExternal*/ true, Sym, nullptr); - return {S, true}; + } else if (SP == SP_NEW) { + replaceSymbol(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym, + C); + } else if (SP == SP_EXISTING && IsCOMDAT && C) { + C->markDiscarded(); + // Discard associative chunks that we've parsed so far. No need to recurse + // because an associative section cannot have children. + for (SectionChunk *Child : C->children()) + Child->markDiscarded(); } - if (!cast(S)->isCOMDAT()) - reportDuplicate(S, F); - return {S, false}; + return S; } Symbol *SymbolTable::addCommon(InputFile *F, StringRef N, uint64_t Size, diff --git a/lld/COFF/SymbolTable.h b/lld/COFF/SymbolTable.h index e981085aee8e..56f145c48464 100644 --- a/lld/COFF/SymbolTable.h +++ b/lld/COFF/SymbolTable.h @@ -83,12 +83,9 @@ public: Symbol *addUndefined(StringRef Name, InputFile *F, bool IsWeakAlias); void addLazy(ArchiveFile *F, const Archive::Symbol Sym); Symbol *addAbsolute(StringRef N, COFFSymbolRef S); - Symbol *addRegular(InputFile *F, StringRef N, + Symbol *addRegular(InputFile *F, StringRef N, bool IsCOMDAT, const llvm::object::coff_symbol_generic *S = nullptr, SectionChunk *C = nullptr); - std::pair - addComdat(InputFile *F, StringRef N, - const llvm::object::coff_symbol_generic *S = nullptr); Symbol *addCommon(InputFile *F, StringRef N, uint64_t Size, const llvm::object::coff_symbol_generic *S = nullptr, CommonChunk *C = nullptr); diff --git a/lld/COFF/Symbols.h b/lld/COFF/Symbols.h index 2d7811b7120b..48f9455875ac 100644 --- a/lld/COFF/Symbols.h +++ b/lld/COFF/Symbols.h @@ -169,6 +169,7 @@ public: SectionChunk *getChunk() const { return *Data; } uint32_t getValue() const { return Sym->Value; } +private: SectionChunk **Data; }; diff --git a/lld/test/COFF/reloc-discarded.s b/lld/test/COFF/reloc-discarded.s index 0be4e110b4db..94eaba998330 100644 --- a/lld/test/COFF/reloc-discarded.s +++ b/lld/test/COFF/reloc-discarded.s @@ -18,6 +18,7 @@ main_global: .section .CRT$XCU,"dr",associative,main_global .p2align 3 + .globl assoc_global assoc_global: .quad main_global diff --git a/llvm/include/llvm/Object/COFF.h b/llvm/include/llvm/Object/COFF.h index 2fb896eed97b..3ad60b05b6f5 100644 --- a/llvm/include/llvm/Object/COFF.h +++ b/llvm/include/llvm/Object/COFF.h @@ -275,8 +275,6 @@ struct coff_symbol_generic { support::ulittle32_t Value; }; -struct coff_aux_section_definition; - class COFFSymbolRef { public: COFFSymbolRef() = default; @@ -348,18 +346,6 @@ public: return (getType() & 0xF0) >> COFF::SCT_COMPLEX_TYPE_SHIFT; } - template const T *getAux() const { - return CS16 ? reinterpret_cast(CS16 + 1) - : reinterpret_cast(CS32 + 1); - } - - const coff_aux_section_definition *getSectionDefinition() const { - if (!getNumberOfAuxSymbols() || - getStorageClass() != COFF::IMAGE_SYM_CLASS_STATIC) - return nullptr; - return getAux(); - } - bool isAbsolute() const { return getSectionNumber() == -1; }