//===- InputFiles.cpp -----------------------------------------------------===// // // 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 // //===----------------------------------------------------------------------===// #include "InputFiles.h" #include "Config.h" #include "DWARF.h" #include "Driver.h" #include "InputSection.h" #include "LinkerScript.h" #include "SymbolTable.h" #include "Symbols.h" #include "SyntheticSections.h" #include "Target.h" #include "lld/Common/CommonLinkerContext.h" #include "lld/Common/DWARF.h" #include "llvm/ADT/CachedHashString.h" #include "llvm/ADT/STLExtras.h" #include "llvm/LTO/LTO.h" #include "llvm/Object/IRObjectFile.h" #include "llvm/Support/ARMAttributeParser.h" #include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/Endian.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/RISCVAttributeParser.h" #include "llvm/Support/TimeProfiler.h" #include "llvm/Support/raw_ostream.h" #include <optional> usingnamespacellvm; usingnamespacellvm::ELF; usingnamespacellvm::object; usingnamespacellvm::sys; usingnamespacellvm::sys::fs; usingnamespacellvm::support::endian; usingnamespacelld; usingnamespacelld::elf; // This function is explicitly instantiated in ARM.cpp, don't do it here to // avoid warnings with MSVC. extern template void ObjFile<ELF32LE>::importCmseSymbols(); extern template void ObjFile<ELF32BE>::importCmseSymbols(); extern template void ObjFile<ELF64LE>::importCmseSymbols(); extern template void ObjFile<ELF64BE>::importCmseSymbols(); bool InputFile::isInGroup; uint32_t InputFile::nextGroupId; // Returns "<internal>", "foo.a(bar.o)" or "baz.o". std::string lld::toString(const InputFile *f) { … } static ELFKind getELFKind(MemoryBufferRef mb, StringRef archiveName) { … } // For ARM only, to set the EF_ARM_ABI_FLOAT_SOFT or EF_ARM_ABI_FLOAT_HARD // flag in the ELF Header we need to look at Tag_ABI_VFP_args to find out how // the input objects have been compiled. static void updateARMVFPArgs(Ctx &ctx, const ARMAttributeParser &attributes, const InputFile *f) { … } // The ARM support in lld makes some use of instructions that are not available // on all ARM architectures. Namely: // - Use of BLX instruction for interworking between ARM and Thumb state. // - Use of the extended Thumb branch encoding in relocation. // - Use of the MOVT/MOVW instructions in Thumb Thunks. // The ARM Attributes section contains information about the architecture chosen // at compile time. We follow the convention that if at least one input object // is compiled with an architecture that supports these features then lld is // permitted to use them. static void updateSupportedARMFeatures(Ctx &ctx, const ARMAttributeParser &attributes) { … } InputFile::InputFile(Kind k, MemoryBufferRef m) : … { … } std::optional<MemoryBufferRef> elf::readFile(StringRef path) { … } // All input object files must be for the same architecture // (e.g. it does not make sense to link x86 object files with // MIPS object files.) This function checks for that error. static bool isCompatible(Ctx &ctx, InputFile *file) { … } template <class ELFT> static void doParseFile(Ctx &ctx, InputFile *file) { … } // Add symbols in File to the symbol table. void elf::parseFile(Ctx &ctx, InputFile *file) { … } // This function is explicitly instantiated in ARM.cpp. Mark it extern here, // to avoid warnings when building with MSVC. extern template void ObjFile<ELF32LE>::importCmseSymbols(); extern template void ObjFile<ELF32BE>::importCmseSymbols(); extern template void ObjFile<ELF64LE>::importCmseSymbols(); extern template void ObjFile<ELF64BE>::importCmseSymbols(); template <class ELFT> static void doParseFiles(Ctx &ctx, const std::vector<InputFile *> &files) { … } void elf::parseFiles(Ctx &ctx, const std::vector<InputFile *> &files) { … } // Concatenates arguments to construct a string representing an error location. static std::string createFileLineMsg(StringRef path, unsigned line) { … } template <class ELFT> static std::string getSrcMsgAux(ObjFile<ELFT> &file, const Symbol &sym, const InputSectionBase &sec, uint64_t offset) { … } std::string InputFile::getSrcMsg(const Symbol &sym, const InputSectionBase &sec, uint64_t offset) { … } StringRef InputFile::getNameForScript() const { … } // An ELF object file may contain a `.deplibs` section. If it exists, the // section contains a list of library specifiers such as `m` for libm. This // function resolves a given name by finding the first matching library checking // the various ways that a library can be specified to LLD. This ELF extension // is a form of autolinking and is called `dependent libraries`. It is currently // unique to LLVM and lld. static void addDependentLibrary(Ctx &ctx, StringRef specifier, const InputFile *f) { … } // Record the membership of a section group so that in the garbage collection // pass, section group members are kept or discarded as a unit. template <class ELFT> static void handleSectionGroup(ArrayRef<InputSectionBase *> sections, ArrayRef<typename ELFT::Word> entries) { … } template <class ELFT> DWARFCache *ObjFile<ELFT>::getDwarf() { … } // Returns the pair of file name and line number describing location of data // object (variable, array, etc) definition. template <class ELFT> std::optional<std::pair<std::string, unsigned>> ObjFile<ELFT>::getVariableLoc(StringRef name) { … } // Returns source line information for a given offset // using DWARF debug info. template <class ELFT> std::optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(const InputSectionBase *s, uint64_t offset) { … } ELFFileBase::ELFFileBase(Kind k, ELFKind ekind, MemoryBufferRef mb) : … { … } template <typename Elf_Shdr> static const Elf_Shdr *findSection(ArrayRef<Elf_Shdr> sections, uint32_t type) { … } void ELFFileBase::init() { … } template <class ELFT> void ELFFileBase::init(InputFile::Kind k) { … } template <class ELFT> uint32_t ObjFile<ELFT>::getSectionIndex(const Elf_Sym &sym) const { … } template <class ELFT> void ObjFile<ELFT>::parse(bool ignoreComdats) { … } // Sections with SHT_GROUP and comdat bits define comdat section groups. // They are identified and deduplicated by group name. This function // returns a group name. template <class ELFT> StringRef ObjFile<ELFT>::getShtGroupSignature(ArrayRef<Elf_Shdr> sections, const Elf_Shdr &sec) { … } template <class ELFT> bool ObjFile<ELFT>::shouldMerge(const Elf_Shdr &sec, StringRef name) { … } // This is for --just-symbols. // // --just-symbols is a very minor feature that allows you to link your // output against other existing program, so that if you load both your // program and the other program into memory, your output can refer the // other program's symbols. // // When the option is given, we link "just symbols". The section table is // initialized with null pointers. template <class ELFT> void ObjFile<ELFT>::initializeJustSymbols() { … } static bool isKnownSpecificSectionType(uint32_t t, uint32_t flags) { … } template <class ELFT> void ObjFile<ELFT>::initializeSections(bool ignoreComdats, const llvm::object::ELFFile<ELFT> &obj) { … } // Read the following info from the .note.gnu.property section and write it to // the corresponding fields in `ObjFile`: // - Feature flags (32 bits) representing x86 or AArch64 features for // hardware-assisted call flow control; // - AArch64 PAuth ABI core info (16 bytes). template <class ELFT> void readGnuProperty(const InputSection &sec, ObjFile<ELFT> &f) { … } template <class ELFT> InputSectionBase *ObjFile<ELFT>::getRelocTarget(uint32_t idx, uint32_t info) { … } // The function may be called concurrently for different input files. For // allocation, prefer makeThreadLocal which does not require holding a lock. template <class ELFT> InputSectionBase *ObjFile<ELFT>::createInputSection(uint32_t idx, const Elf_Shdr &sec, StringRef name) { … } // Initialize symbols. symbols is a parallel array to the corresponding ELF // symbol table. template <class ELFT> void ObjFile<ELFT>::initializeSymbols(const object::ELFFile<ELFT> &obj) { … } template <class ELFT> void ObjFile<ELFT>::initSectionsAndLocalSyms(bool ignoreComdats) { … } // Called after all ObjFile::parse is called for all ObjFiles. This checks // duplicate symbols and may do symbol property merge in the future. template <class ELFT> void ObjFile<ELFT>::postParse() { … } // The handling of tentative definitions (COMMON symbols) in archives is murky. // A tentative definition will be promoted to a global definition if there are // no non-tentative definitions to dominate it. When we hold a tentative // definition to a symbol and are inspecting archive members for inclusion // there are 2 ways we can proceed: // // 1) Consider the tentative definition a 'real' definition (ie promotion from // tentative to real definition has already happened) and not inspect // archive members for Global/Weak definitions to replace the tentative // definition. An archive member would only be included if it satisfies some // other undefined symbol. This is the behavior Gold uses. // // 2) Consider the tentative definition as still undefined (ie the promotion to // a real definition happens only after all symbol resolution is done). // The linker searches archive members for STB_GLOBAL definitions to // replace the tentative definition with. This is the behavior used by // GNU ld. // // The second behavior is inherited from SysVR4, which based it on the FORTRAN // COMMON BLOCK model. This behavior is needed for proper initialization in old // (pre F90) FORTRAN code that is packaged into an archive. // // The following functions search archive members for definitions to replace // tentative definitions (implementing behavior 2). static bool isBitcodeNonCommonDef(MemoryBufferRef mb, StringRef symName, StringRef archiveName) { … } template <class ELFT> static bool isNonCommonDef(ELFKind ekind, MemoryBufferRef mb, StringRef symName, StringRef archiveName) { … } static bool isNonCommonDef(MemoryBufferRef mb, StringRef symName, StringRef archiveName) { … } unsigned SharedFile::vernauxNum; SharedFile::SharedFile(MemoryBufferRef m, StringRef defaultSoName) : … { … } // Parse the version definitions in the object file if present, and return a // vector whose nth element contains a pointer to the Elf_Verdef for version // identifier n. Version identifiers that are not definitions map to nullptr. template <typename ELFT> static SmallVector<const void *, 0> parseVerdefs(const uint8_t *base, const typename ELFT::Shdr *sec) { … } // Parse SHT_GNU_verneed to properly set the name of a versioned undefined // symbol. We detect fatal issues which would cause vulnerabilities, but do not // implement sophisticated error checking like in llvm-readobj because the value // of such diagnostics is low. template <typename ELFT> std::vector<uint32_t> SharedFile::parseVerneed(const ELFFile<ELFT> &obj, const typename ELFT::Shdr *sec) { … } // We do not usually care about alignments of data in shared object // files because the loader takes care of it. However, if we promote a // DSO symbol to point to .bss due to copy relocation, we need to keep // the original alignment requirements. We infer it in this function. template <typename ELFT> static uint64_t getAlignment(ArrayRef<typename ELFT::Shdr> sections, const typename ELFT::Sym &sym) { … } // Fully parse the shared object file. // // This function parses symbol versions. If a DSO has version information, // the file has a ".gnu.version_d" section which contains symbol version // definitions. Each symbol is associated to one version through a table in // ".gnu.version" section. That table is a parallel array for the symbol // table, and each table entry contains an index in ".gnu.version_d". // // The special index 0 is reserved for VERF_NDX_LOCAL and 1 is for // VER_NDX_GLOBAL. There's no table entry for these special versions in // ".gnu.version_d". // // The file format for symbol versioning is perhaps a bit more complicated // than necessary, but you can easily understand the code if you wrap your // head around the data structure described above. template <class ELFT> void SharedFile::parse() { … } static ELFKind getBitcodeELFKind(const Triple &t) { … } static uint16_t getBitcodeMachineKind(StringRef path, const Triple &t) { … } static uint8_t getOsAbi(const Triple &t) { … } BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName, uint64_t offsetInArchive, bool lazy) : … { … } static uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) { … } static void createBitcodeSymbol(Ctx &ctx, Symbol *&sym, const std::vector<bool> &keptComdats, const lto::InputFile::Symbol &objSym, BitcodeFile &f) { … } void BitcodeFile::parse() { … } void BitcodeFile::parseLazy() { … } void BitcodeFile::postParse() { … } void BinaryFile::parse() { … } InputFile *elf::createInternalFile(StringRef name) { … } ELFFileBase *elf::createObjFile(MemoryBufferRef mb, StringRef archiveName, bool lazy) { … } template <class ELFT> void ObjFile<ELFT>::parseLazy() { … } bool InputFile::shouldExtractForCommon(StringRef name) const { … } std::string elf::replaceThinLTOSuffix(Ctx &ctx, StringRef path) { … } template class elf::ObjFile<ELF32LE>; template class elf::ObjFile<ELF32BE>; template class elf::ObjFile<ELF64LE>; template class elf::ObjFile<ELF64BE>; template void SharedFile::parse<ELF32LE>(); template void SharedFile::parse<ELF32BE>(); template void SharedFile::parse<ELF64LE>(); template void SharedFile::parse<ELF64BE>();
Codebase Browser
llvm