| //=--------- COFFLinkGraphBuilder.cpp - COFF LinkGraph builder ----------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Generic COFF LinkGraph buliding code. |
| // |
| //===----------------------------------------------------------------------===// |
| #include "COFFLinkGraphBuilder.h" |
| |
| #define DEBUG_TYPE "jitlink" |
| |
| static const char *CommonSectionName = "__common"; |
| |
| namespace llvm { |
| namespace jitlink { |
| |
| static Triple createTripleWithCOFFFormat(Triple T) { |
| T.setObjectFormat(Triple::COFF); |
| return T; |
| } |
| |
| COFFLinkGraphBuilder::COFFLinkGraphBuilder( |
| const object::COFFObjectFile &Obj, Triple TT, |
| LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) |
| : Obj(Obj), |
| G(std::make_unique<LinkGraph>(Obj.getFileName().str(), |
| createTripleWithCOFFFormat(TT), |
| getPointerSize(Obj), getEndianness(Obj), |
| std::move(GetEdgeKindName))) { |
| LLVM_DEBUG({ |
| dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName() |
| << "\"\n"; |
| }); |
| } |
| |
| COFFLinkGraphBuilder::~COFFLinkGraphBuilder() = default; |
| |
| unsigned |
| COFFLinkGraphBuilder::getPointerSize(const object::COFFObjectFile &Obj) { |
| return Obj.getBytesInAddress(); |
| } |
| |
| support::endianness |
| COFFLinkGraphBuilder::getEndianness(const object::COFFObjectFile &Obj) { |
| return Obj.isLittleEndian() ? support::little : support::big; |
| } |
| |
| uint64_t COFFLinkGraphBuilder::getSectionSize(const object::COFFObjectFile &Obj, |
| const object::coff_section *Sec) { |
| // Consider the difference between executable form and object form. |
| // More information is inside COFFObjectFile::getSectionSize |
| if (Obj.getDOSHeader()) |
| return std::min(Sec->VirtualSize, Sec->SizeOfRawData); |
| return Sec->SizeOfRawData; |
| } |
| |
| uint64_t |
| COFFLinkGraphBuilder::getSectionAddress(const object::COFFObjectFile &Obj, |
| const object::coff_section *Section) { |
| return Section->VirtualAddress + Obj.getImageBase(); |
| } |
| |
| bool COFFLinkGraphBuilder::isComdatSection( |
| const object::coff_section *Section) { |
| return Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT; |
| } |
| |
| Section &COFFLinkGraphBuilder::getCommonSection() { |
| if (!CommonSection) |
| CommonSection = &G->createSection(CommonSectionName, |
| orc::MemProt::Read | orc::MemProt::Write); |
| return *CommonSection; |
| } |
| |
| Expected<std::unique_ptr<LinkGraph>> COFFLinkGraphBuilder::buildGraph() { |
| if (!Obj.isRelocatableObject()) |
| return make_error<JITLinkError>("Object is not a relocatable COFF file"); |
| |
| if (auto Err = graphifySections()) |
| return std::move(Err); |
| |
| if (auto Err = graphifySymbols()) |
| return std::move(Err); |
| |
| if (auto Err = addRelocations()) |
| return std::move(Err); |
| |
| return std::move(G); |
| } |
| |
| StringRef |
| COFFLinkGraphBuilder::getCOFFSectionName(COFFSectionIndex SectionIndex, |
| const object::coff_section *Sec, |
| object::COFFSymbolRef Sym) { |
| switch (SectionIndex) { |
| case COFF::IMAGE_SYM_UNDEFINED: { |
| if (Sym.getValue()) |
| return "(common)"; |
| else |
| return "(external)"; |
| } |
| case COFF::IMAGE_SYM_ABSOLUTE: |
| return "(absolute)"; |
| case COFF::IMAGE_SYM_DEBUG: { |
| // Used with .file symbol |
| return "(debug)"; |
| } |
| default: { |
| // Non reserved regular section numbers |
| if (Expected<StringRef> SecNameOrErr = Obj.getSectionName(Sec)) |
| return *SecNameOrErr; |
| } |
| } |
| return ""; |
| } |
| |
| Error COFFLinkGraphBuilder::graphifySections() { |
| LLVM_DEBUG(dbgs() << " Creating graph sections...\n"); |
| |
| GraphBlocks.resize(Obj.getNumberOfSections() + 1); |
| // For each section... |
| for (COFFSectionIndex SecIndex = 1; |
| SecIndex <= static_cast<COFFSectionIndex>(Obj.getNumberOfSections()); |
| SecIndex++) { |
| Expected<const object::coff_section *> Sec = Obj.getSection(SecIndex); |
| if (!Sec) |
| return Sec.takeError(); |
| |
| StringRef SectionName; |
| if (Expected<StringRef> SecNameOrErr = Obj.getSectionName(*Sec)) |
| SectionName = *SecNameOrErr; |
| |
| // FIXME: Skip debug info sections |
| |
| LLVM_DEBUG({ |
| dbgs() << " " |
| << "Creating section for \"" << SectionName << "\"\n"; |
| }); |
| |
| // Get the section's memory protection flags. |
| orc::MemProt Prot = orc::MemProt::Read; |
| if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_EXECUTE) |
| Prot |= orc::MemProt::Exec; |
| if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_READ) |
| Prot |= orc::MemProt::Read; |
| if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_WRITE) |
| Prot |= orc::MemProt::Write; |
| |
| // Look for existing sections first. |
| auto *GraphSec = G->findSectionByName(SectionName); |
| if (!GraphSec) |
| GraphSec = &G->createSection(SectionName, Prot); |
| if (GraphSec->getMemProt() != Prot) |
| return make_error<JITLinkError>("MemProt should match"); |
| |
| Block *B = nullptr; |
| if ((*Sec)->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) |
| B = &G->createZeroFillBlock( |
| *GraphSec, getSectionSize(Obj, *Sec), |
| orc::ExecutorAddr(getSectionAddress(Obj, *Sec)), |
| (*Sec)->getAlignment(), 0); |
| else { |
| ArrayRef<uint8_t> Data; |
| if (auto Err = Obj.getSectionContents(*Sec, Data)) |
| return Err; |
| |
| auto CharData = ArrayRef<char>( |
| reinterpret_cast<const char *>(Data.data()), Data.size()); |
| |
| if (SectionName == getDirectiveSectionName()) |
| if (auto Err = handleDirectiveSection( |
| StringRef(CharData.data(), CharData.size()))) |
| return Err; |
| |
| B = &G->createContentBlock( |
| *GraphSec, CharData, orc::ExecutorAddr(getSectionAddress(Obj, *Sec)), |
| (*Sec)->getAlignment(), 0); |
| } |
| |
| setGraphBlock(SecIndex, B); |
| } |
| |
| return Error::success(); |
| } |
| |
| Error COFFLinkGraphBuilder::graphifySymbols() { |
| LLVM_DEBUG(dbgs() << " Creating graph symbols...\n"); |
| |
| SymbolSets.resize(Obj.getNumberOfSections() + 1); |
| PendingComdatExports.resize(Obj.getNumberOfSections() + 1); |
| GraphSymbols.resize(Obj.getNumberOfSymbols()); |
| |
| for (COFFSymbolIndex SymIndex = 0; |
| SymIndex < static_cast<COFFSymbolIndex>(Obj.getNumberOfSymbols()); |
| SymIndex++) { |
| Expected<object::COFFSymbolRef> Sym = Obj.getSymbol(SymIndex); |
| if (!Sym) |
| return Sym.takeError(); |
| |
| StringRef SymbolName; |
| if (Expected<StringRef> SymNameOrErr = Obj.getSymbolName(*Sym)) |
| SymbolName = *SymNameOrErr; |
| |
| COFFSectionIndex SectionIndex = Sym->getSectionNumber(); |
| const object::coff_section *Sec = nullptr; |
| |
| if (!COFF::isReservedSectionNumber(SectionIndex)) { |
| auto SecOrErr = Obj.getSection(SectionIndex); |
| if (!SecOrErr) |
| return make_error<JITLinkError>( |
| "Invalid COFF section number:" + formatv("{0:d}: ", SectionIndex) + |
| " (" + toString(SecOrErr.takeError()) + ")"); |
| Sec = *SecOrErr; |
| } |
| |
| // Create jitlink symbol |
| jitlink::Symbol *GSym = nullptr; |
| if (Sym->isFileRecord()) |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex << ": Skipping FileRecord symbol \"" |
| << SymbolName << "\" in " |
| << getCOFFSectionName(SectionIndex, Sec, *Sym) |
| << " (index: " << SectionIndex << ") \n"; |
| }); |
| else if (Sym->isUndefined()) { |
| GSym = createExternalSymbol(SymIndex, SymbolName, *Sym, Sec); |
| } else if (Sym->isWeakExternal()) { |
| auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>(); |
| COFFSymbolIndex TagIndex = WeakExternal->TagIndex; |
| uint32_t Characteristics = WeakExternal->Characteristics; |
| WeakExternalRequests.push_back( |
| {SymIndex, TagIndex, Characteristics, SymbolName}); |
| } else { |
| Expected<jitlink::Symbol *> NewGSym = |
| createDefinedSymbol(SymIndex, SymbolName, *Sym, Sec); |
| if (!NewGSym) |
| return NewGSym.takeError(); |
| GSym = *NewGSym; |
| if (GSym) { |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex |
| << ": Creating defined graph symbol for COFF symbol \"" |
| << SymbolName << "\" in " |
| << getCOFFSectionName(SectionIndex, Sec, *Sym) |
| << " (index: " << SectionIndex << ") \n"; |
| dbgs() << " " << *GSym << "\n"; |
| }); |
| } |
| } |
| |
| // Register the symbol |
| if (GSym) |
| setGraphSymbol(SectionIndex, SymIndex, *GSym); |
| SymIndex += Sym->getNumberOfAuxSymbols(); |
| } |
| |
| if (auto Err = flushWeakAliasRequests()) |
| return Err; |
| |
| if (auto Err = handleAlternateNames()) |
| return Err; |
| |
| if (auto Err = calculateImplicitSizeOfSymbols()) |
| return Err; |
| |
| return Error::success(); |
| } |
| |
| Error COFFLinkGraphBuilder::handleDirectiveSection(StringRef Str) { |
| auto Parsed = DirectiveParser.parse(Str); |
| if (!Parsed) |
| return Parsed.takeError(); |
| for (auto *Arg : *Parsed) { |
| StringRef S = Arg->getValue(); |
| switch (Arg->getOption().getID()) { |
| case COFF_OPT_alternatename: { |
| StringRef From, To; |
| std::tie(From, To) = S.split('='); |
| if (From.empty() || To.empty()) |
| return make_error<JITLinkError>( |
| "Invalid COFF /alternatename directive"); |
| AlternateNames[From] = To; |
| break; |
| } |
| case COFF_OPT_incl: { |
| auto DataCopy = G->allocateString(S); |
| StringRef StrCopy(DataCopy.data(), DataCopy.size()); |
| ExternalSymbols[StrCopy] = &G->addExternalSymbol(StrCopy, 0, false); |
| ExternalSymbols[StrCopy]->setLive(true); |
| break; |
| } |
| case COFF_OPT_export: |
| break; |
| default: { |
| LLVM_DEBUG({ |
| dbgs() << "Unknown coff directive: " << Arg->getSpelling() << "\n"; |
| }); |
| break; |
| } |
| } |
| } |
| return Error::success(); |
| } |
| |
| Error COFFLinkGraphBuilder::flushWeakAliasRequests() { |
| // Export the weak external symbols and alias it |
| for (auto &WeakExternal : WeakExternalRequests) { |
| if (auto *Target = getGraphSymbol(WeakExternal.Target)) { |
| Expected<object::COFFSymbolRef> AliasSymbol = |
| Obj.getSymbol(WeakExternal.Alias); |
| if (!AliasSymbol) |
| return AliasSymbol.takeError(); |
| |
| // FIXME: IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY and |
| // IMAGE_WEAK_EXTERN_SEARCH_LIBRARY are handled in the same way. |
| Scope S = |
| WeakExternal.Characteristics == COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS |
| ? Scope::Default |
| : Scope::Local; |
| |
| auto NewSymbol = |
| createAliasSymbol(WeakExternal.SymbolName, Linkage::Weak, S, *Target); |
| if (!NewSymbol) |
| return NewSymbol.takeError(); |
| setGraphSymbol(AliasSymbol->getSectionNumber(), WeakExternal.Alias, |
| **NewSymbol); |
| LLVM_DEBUG({ |
| dbgs() << " " << WeakExternal.Alias |
| << ": Creating weak external symbol for COFF symbol \"" |
| << WeakExternal.SymbolName << "\" in section " |
| << AliasSymbol->getSectionNumber() << "\n"; |
| dbgs() << " " << **NewSymbol << "\n"; |
| }); |
| } else |
| return make_error<JITLinkError>("Weak symbol alias requested but actual " |
| "symbol not found for symbol " + |
| formatv("{0:d}", WeakExternal.Alias)); |
| } |
| return Error::success(); |
| } |
| |
| Error COFFLinkGraphBuilder::handleAlternateNames() { |
| for (auto &KeyValue : AlternateNames) |
| if (DefinedSymbols.count(KeyValue.second) && |
| ExternalSymbols.count(KeyValue.first)) { |
| auto *Target = DefinedSymbols[KeyValue.second]; |
| auto *Alias = ExternalSymbols[KeyValue.first]; |
| G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(), |
| Target->getSize(), Linkage::Weak, Scope::Local, false); |
| } |
| return Error::success(); |
| } |
| |
| Symbol *COFFLinkGraphBuilder::createExternalSymbol( |
| COFFSymbolIndex SymIndex, StringRef SymbolName, |
| object::COFFSymbolRef Symbol, const object::coff_section *Section) { |
| if (!ExternalSymbols.count(SymbolName)) |
| ExternalSymbols[SymbolName] = |
| &G->addExternalSymbol(SymbolName, Symbol.getValue(), false); |
| |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex |
| << ": Creating external graph symbol for COFF symbol \"" |
| << SymbolName << "\" in " |
| << getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol) |
| << " (index: " << Symbol.getSectionNumber() << ") \n"; |
| }); |
| return ExternalSymbols[SymbolName]; |
| } |
| |
| Expected<Symbol *> COFFLinkGraphBuilder::createAliasSymbol(StringRef SymbolName, |
| Linkage L, Scope S, |
| Symbol &Target) { |
| if (!Target.isDefined()) { |
| // FIXME: Support this when there's a way to handle this. |
| return make_error<JITLinkError>("Weak external symbol with external " |
| "symbol as alternative not supported."); |
| } |
| return &G->addDefinedSymbol(Target.getBlock(), Target.getOffset(), SymbolName, |
| Target.getSize(), L, S, Target.isCallable(), |
| false); |
| } |
| |
| // In COFF, most of the defined symbols don't contain the size information. |
| // Hence, we calculate the "implicit" size of symbol by taking the delta of |
| // offsets of consecutive symbols within a block. We maintain a balanced tree |
| // set of symbols sorted by offset per each block in order to achieve |
| // logarithmic time complexity of sorted symbol insertion. Symbol is inserted to |
| // the set once it's processed in graphifySymbols. In this function, we iterate |
| // each collected symbol in sorted order and calculate the implicit size. |
| Error COFFLinkGraphBuilder::calculateImplicitSizeOfSymbols() { |
| for (COFFSectionIndex SecIndex = 1; |
| SecIndex <= static_cast<COFFSectionIndex>(Obj.getNumberOfSections()); |
| SecIndex++) { |
| auto &SymbolSet = SymbolSets[SecIndex]; |
| if (SymbolSet.empty()) |
| continue; |
| jitlink::Block *B = getGraphBlock(SecIndex); |
| orc::ExecutorAddrDiff LastOffset = B->getSize(); |
| orc::ExecutorAddrDiff LastDifferentOffset = B->getSize(); |
| orc::ExecutorAddrDiff LastSize = 0; |
| for (auto It = SymbolSet.rbegin(); It != SymbolSet.rend(); It++) { |
| orc::ExecutorAddrDiff Offset = It->first; |
| jitlink::Symbol *Symbol = It->second; |
| orc::ExecutorAddrDiff CandSize; |
| // Last offset can be same when aliasing happened |
| if (Symbol->getOffset() == LastOffset) |
| CandSize = LastSize; |
| else |
| CandSize = LastOffset - Offset; |
| |
| LLVM_DEBUG({ |
| if (Offset + Symbol->getSize() > LastDifferentOffset) |
| dbgs() << " Overlapping symbol range generated for the following " |
| "symbol:" |
| << "\n" |
| << " " << *Symbol << "\n"; |
| }); |
| (void)LastDifferentOffset; |
| if (LastOffset != Offset) |
| LastDifferentOffset = Offset; |
| LastSize = CandSize; |
| LastOffset = Offset; |
| if (Symbol->getSize()) { |
| // Non empty symbol can happen in COMDAT symbol. |
| // We don't consider the possibility of overlapping symbol range that |
| // could be introduced by disparity between inferred symbol size and |
| // defined symbol size because symbol size information is currently only |
| // used by jitlink-check where we have control to not make overlapping |
| // ranges. |
| continue; |
| } |
| |
| LLVM_DEBUG({ |
| if (!CandSize) |
| dbgs() << " Empty implicit symbol size generated for the following " |
| "symbol:" |
| << "\n" |
| << " " << *Symbol << "\n"; |
| }); |
| |
| Symbol->setSize(CandSize); |
| } |
| } |
| return Error::success(); |
| } |
| |
| Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol( |
| COFFSymbolIndex SymIndex, StringRef SymbolName, |
| object::COFFSymbolRef Symbol, const object::coff_section *Section) { |
| if (Symbol.isCommon()) { |
| // FIXME: correct alignment |
| return &G->addDefinedSymbol( |
| G->createZeroFillBlock(getCommonSection(), Symbol.getValue(), |
| orc::ExecutorAddr(), Symbol.getValue(), 0), |
| 0, SymbolName, Symbol.getValue(), Linkage::Strong, Scope::Default, |
| false, false); |
| } |
| if (Symbol.isAbsolute()) |
| return &G->addAbsoluteSymbol(SymbolName, |
| orc::ExecutorAddr(Symbol.getValue()), 0, |
| Linkage::Strong, Scope::Local, false); |
| |
| if (llvm::COFF::isReservedSectionNumber(Symbol.getSectionNumber())) |
| return make_error<JITLinkError>( |
| "Reserved section number used in regular symbol " + |
| formatv("{0:d}", SymIndex)); |
| |
| Block *B = getGraphBlock(Symbol.getSectionNumber()); |
| if (!B) { |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex |
| << ": Skipping graph symbol since section was not created for " |
| "COFF symbol \"" |
| << SymbolName << "\" in section " << Symbol.getSectionNumber() |
| << "\n"; |
| }); |
| return nullptr; |
| } |
| |
| if (Symbol.isExternal()) { |
| // This is not a comdat sequence, export the symbol as it is |
| if (!isComdatSection(Section)) { |
| auto GSym = &G->addDefinedSymbol( |
| *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Default, |
| Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false); |
| DefinedSymbols[SymbolName] = GSym; |
| return GSym; |
| } else { |
| if (!PendingComdatExports[Symbol.getSectionNumber()]) |
| return make_error<JITLinkError>("No pending COMDAT export for symbol " + |
| formatv("{0:d}", SymIndex)); |
| |
| return exportCOMDATSymbol(SymIndex, SymbolName, Symbol); |
| } |
| } |
| |
| if (Symbol.getStorageClass() == COFF::IMAGE_SYM_CLASS_STATIC || |
| Symbol.getStorageClass() == COFF::IMAGE_SYM_CLASS_LABEL) { |
| const object::coff_aux_section_definition *Definition = |
| Symbol.getSectionDefinition(); |
| if (!Definition || !isComdatSection(Section)) { |
| // Handle typical static symbol |
| return &G->addDefinedSymbol( |
| *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Local, |
| Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false); |
| } |
| if (Definition->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) { |
| auto Target = Definition->getNumber(Symbol.isBigObj()); |
| auto GSym = &G->addDefinedSymbol( |
| *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Local, |
| Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false); |
| getGraphBlock(Target)->addEdge(Edge::KeepAlive, 0, *GSym, 0); |
| return GSym; |
| } |
| if (PendingComdatExports[Symbol.getSectionNumber()]) |
| return make_error<JITLinkError>( |
| "COMDAT export request already exists before symbol " + |
| formatv("{0:d}", SymIndex)); |
| return createCOMDATExportRequest(SymIndex, Symbol, Definition); |
| } |
| return make_error<JITLinkError>("Unsupported storage class " + |
| formatv("{0:d}", Symbol.getStorageClass()) + |
| " in symbol " + formatv("{0:d}", SymIndex)); |
| } |
| |
| // COMDAT handling: |
| // When IMAGE_SCN_LNK_COMDAT flag is set in the flags of a section, |
| // the section is called a COMDAT section. It contains two symbols |
| // in a sequence that specifes the behavior. First symbol is the section |
| // symbol which contains the size and name of the section. It also contains |
| // selection type that specifies how duplicate of the symbol is handled. |
| // Second symbol is COMDAT symbol which usually defines the external name and |
| // data type. |
| // |
| // Since two symbols always come in a specific order, we initiate pending COMDAT |
| // export request when we encounter the first symbol and actually exports it |
| // when we process the second symbol. |
| // |
| // Process the first symbol of COMDAT sequence. |
| Expected<Symbol *> COFFLinkGraphBuilder::createCOMDATExportRequest( |
| COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol, |
| const object::coff_aux_section_definition *Definition) { |
| Linkage L = Linkage::Strong; |
| switch (Definition->Selection) { |
| case COFF::IMAGE_COMDAT_SELECT_NODUPLICATES: { |
| L = Linkage::Strong; |
| break; |
| } |
| case COFF::IMAGE_COMDAT_SELECT_ANY: { |
| L = Linkage::Weak; |
| break; |
| } |
| case COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH: |
| case COFF::IMAGE_COMDAT_SELECT_SAME_SIZE: { |
| // FIXME: Implement size/content validation when LinkGraph is able to |
| // handle this. |
| L = Linkage::Weak; |
| break; |
| } |
| case COFF::IMAGE_COMDAT_SELECT_LARGEST: { |
| // FIXME: Support IMAGE_COMDAT_SELECT_LARGEST properly when LinkGraph is |
| // able to handle this. |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex |
| << ": Partially supported IMAGE_COMDAT_SELECT_LARGEST was used" |
| " in section " |
| << Symbol.getSectionNumber() << " (size: " << Definition->Length |
| << ")\n"; |
| }); |
| L = Linkage::Weak; |
| break; |
| } |
| case COFF::IMAGE_COMDAT_SELECT_NEWEST: { |
| // Even link.exe doesn't support this selection properly. |
| return make_error<JITLinkError>( |
| "IMAGE_COMDAT_SELECT_NEWEST is not supported."); |
| } |
| default: { |
| return make_error<JITLinkError>("Invalid comdat selection type: " + |
| formatv("{0:d}", Definition->Selection)); |
| } |
| } |
| PendingComdatExports[Symbol.getSectionNumber()] = {SymIndex, L, |
| Definition->Length}; |
| return nullptr; |
| } |
| |
| // Process the second symbol of COMDAT sequence. |
| Expected<Symbol *> |
| COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex, |
| StringRef SymbolName, |
| object::COFFSymbolRef Symbol) { |
| Block *B = getGraphBlock(Symbol.getSectionNumber()); |
| auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()]; |
| // NOTE: ComdatDef->Legnth is the size of "section" not size of symbol. |
| // We use zero symbol size to not reach out of bound of block when symbol |
| // offset is non-zero. |
| auto GSym = &G->addDefinedSymbol( |
| *B, Symbol.getValue(), SymbolName, 0, PendingComdatExport->Linkage, |
| Scope::Default, Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, |
| false); |
| LLVM_DEBUG({ |
| dbgs() << " " << SymIndex |
| << ": Exporting COMDAT graph symbol for COFF symbol \"" << SymbolName |
| << "\" in section " << Symbol.getSectionNumber() << "\n"; |
| dbgs() << " " << *GSym << "\n"; |
| }); |
| setGraphSymbol(Symbol.getSectionNumber(), PendingComdatExport->SymbolIndex, |
| *GSym); |
| DefinedSymbols[SymbolName] = GSym; |
| PendingComdatExport = std::nullopt; |
| return GSym; |
| } |
| |
| } // namespace jitlink |
| } // namespace llvm |
