CbC/CbC_llvm: lld/ELF/InputFiles.cpp comparison

comparison lld/ELF/InputFiles.cpp @ 173:0572611fdcc8 llvm10 llvm12

reorgnization done

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Mon, 25 May 2020 11:55:54 +0900
parents	1d019706d866
children	2e18cbf3894f

comparison

equal deleted inserted replaced

-:9fbae9c8bf63
+:0572611fdcc8
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::sys::fs;
 using namespace llvm::support::endian;
+using namespace lld;
-namespace lld {
+using namespace lld::elf;
+bool InputFile::isInGroup;
+uint32_t InputFile::nextGroupId;
+std::vector<ArchiveFile *> elf::archiveFiles;
+std::vector<BinaryFile *> elf::binaryFiles;
+std::vector<BitcodeFile *> elf::bitcodeFiles;
+std::vector<LazyObjFile *> elf::lazyObjFiles;
+std::vector<InputFile *> elf::objectFiles;
+std::vector<SharedFile *> elf::sharedFiles;
+std::unique_ptr<TarWriter> elf::tar;
 // Returns "<internal>", "foo.a(bar.o)" or "baz.o".
-std::string toString(const elf::InputFile *f) {
+std::string lld::toString(const InputFile *f) {
 if (!f)
 return "<internal>";
 if (f->toStringCache.empty()) {
 if (f->archiveName.empty())
 else
 f->toStringCache = (f->archiveName + "(" + f->getName() + ")").str();
 }
 return f->toStringCache;
 }
-namespace elf {
-bool InputFile::isInGroup;
-uint32_t InputFile::nextGroupId;
-std::vector<BinaryFile *> binaryFiles;
-std::vector<BitcodeFile *> bitcodeFiles;
-std::vector<LazyObjFile *> lazyObjFiles;
-std::vector<InputFile *> objectFiles;
-std::vector<SharedFile *> sharedFiles;
-std::unique_ptr<TarWriter> tar;
 static ELFKind getELFKind(MemoryBufferRef mb, StringRef archiveName) {
 unsigned char size;
 unsigned char endian;
 std::tie(size, endian) = getElfArchType(mb.getBuffer());
 // Otherwise, a new file will get a new group ID.
 if (!isInGroup)
 ++nextGroupId;
 }
-Optional<MemoryBufferRef> readFile(StringRef path) {
+Optional<MemoryBufferRef> elf::readFile(StringRef path) {
 // The --chroot option changes our virtual root directory.
 // This is useful when you are dealing with files created by --reproduce.
 if (!config->chroot.empty() && path.startswith("/"))
 path = saver.save(config->chroot + path);
 return true;
 if (isMipsN32Abi(file) == config->mipsN32Abi)
 return true;
 }
-if (!config->emulation.empty()) {
+StringRef target =
-error(toString(file) + " is incompatible with " + config->emulation);
+!config->bfdname.empty() ? config->bfdname : config->emulation;
+if (!target.empty()) {
+error(toString(file) + " is incompatible with " + target);
 return false;
 }
 InputFile *existing;
 if (!objectFiles.empty())
 existing = objectFiles[0];
 else if (!sharedFiles.empty())
 existing = sharedFiles[0];
+else if (!bitcodeFiles.empty())
+existing = bitcodeFiles[0];
 else
-existing = bitcodeFiles[0];
+llvm_unreachable("Must have -m, OUTPUT_FORMAT or existing input file to "
+"determine target emulation");
 error(toString(file) + " is incompatible with " + toString(existing));
 return false;
 }
 return;
 }
 // .a file
 if (auto *f = dyn_cast<ArchiveFile>(file)) {
+archiveFiles.push_back(f);
 f->parse();
 return;
 }
 // Lazy object file
 objectFiles.push_back(file);
 cast<ObjFile<ELFT>>(file)->parse();
 }
 // Add symbols in File to the symbol table.
-void parseFile(InputFile *file) {
+void elf::parseFile(InputFile *file) {
 switch (config->ekind) {
 case ELF32LEKind:
 doParseFile<ELF32LE>(file);
 return;
 case ELF32BEKind:
 case ELF64BEKind:
 return getSrcMsgAux(cast<ObjFile<ELF64BE>>(*this), sym, sec, offset);
 }
 }
-template <class ELFT> void ObjFile<ELFT>::initializeDwarf() {
+template <class ELFT> DWARFCache *ObjFile<ELFT>::getDwarf() {
-dwarf = make<DWARFCache>(std::make_unique<DWARFContext>(
+llvm::call_once(initDwarf, [this]() {
-std::make_unique<LLDDwarfObj<ELFT>>(this)));
+dwarf = std::make_unique<DWARFCache>(std::make_unique<DWARFContext>(
+std::make_unique<LLDDwarfObj<ELFT>>(this), "",
+[&](Error err) { warn(getName() + ": " + toString(std::move(err))); },
+[&](Error warning) {
+warn(getName() + ": " + toString(std::move(warning)));
+}));
+});
+return dwarf.get();
 }
 // Returns the pair of file name and line number describing location of data
 // object (variable, array, etc) definition.
 template <class ELFT>
 Optional<std::pair<std::string, unsigned>>
 ObjFile<ELFT>::getVariableLoc(StringRef name) {
-llvm::call_once(initDwarfLine, [this]() { initializeDwarf(); });
+return getDwarf()->getVariableLoc(name);
-return dwarf->getVariableLoc(name);
 }
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
 Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *s,
 uint64_t offset) {
-llvm::call_once(initDwarfLine, [this]() { initializeDwarf(); });
 // Detect SectionIndex for specified section.
 uint64_t sectionIndex = object::SectionedAddress::UndefSection;
 ArrayRef<InputSectionBase *> sections = s->file->getSections();
 for (uint64_t curIndex = 0; curIndex < sections.size(); ++curIndex) {
 if (s == sections[curIndex]) {
 sectionIndex = curIndex;
 break;
 }
 }
-// Use fake address calculated by adding section file offset and offset in
+return getDwarf()->getDILineInfo(offset, sectionIndex);
-// section. See comments for ObjectInfo class.
-return dwarf->getDILineInfo(s->getOffsetInFile() + offset, sectionIndex);
 }
 ELFFileBase::ELFFileBase(Kind k, MemoryBufferRef mb) : InputFile(k, mb) {
 ekind = getELFKind(mb, "");
 return signature;
 }
 template <class ELFT>
 bool ObjFile<ELFT>::shouldMerge(const Elf_Shdr &sec, StringRef name) {
+if (!(sec.sh_flags & SHF_MERGE))
+return false;
 // On a regular link we don't merge sections if -O0 (default is -O1). This
 // sometimes makes the linker significantly faster, although the output will
 // be bigger.
 //
 // Doing the same for -r would create a problem as it would combine sections
 if (sec.sh_size % entSize)
 fatal(toString(this) + ":(" + name + "): SHF_MERGE section size (" +
 Twine(sec.sh_size) + ") must be a multiple of sh_entsize (" +
 Twine(entSize) + ")");
-uint64_t flags = sec.sh_flags;
+if (sec.sh_flags & SHF_WRITE)
-if (!(flags & SHF_MERGE))
-return false;
-if (flags & SHF_WRITE)
 fatal(toString(this) + ":(" + name +
 "): writable SHF_MERGE section is not supported");
 return true;
 }
 // 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(const ARMAttributeParser &attributes,
 const InputFile *f) {
-if (!attributes.hasAttribute(ARMBuildAttrs::ABI_VFP_args))
+Optional<unsigned> attr =
+attributes.getAttributeValue(ARMBuildAttrs::ABI_VFP_args);
+if (!attr.hasValue())
 // If an ABI tag isn't present then it is implicitly given the value of 0
 // which maps to ARMBuildAttrs::BaseAAPCS. However many assembler files,
 // including some in glibc that don't use FP args (and should have value 3)
 // don't have the attribute so we do not consider an implicit value of 0
 // as a clash.
 return;
-unsigned vfpArgs = attributes.getAttributeValue(ARMBuildAttrs::ABI_VFP_args);
+unsigned vfpArgs = attr.getValue();
 ARMVFPArgKind arg;
 switch (vfpArgs) {
 case ARMBuildAttrs::BaseAAPCS:
 arg = ARMVFPArgKind::Base;
 break;
 // 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(const ARMAttributeParser &attributes) {
-if (!attributes.hasAttribute(ARMBuildAttrs::CPU_arch))
+Optional<unsigned> attr =
-return;
+attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
-auto arch = attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
+if (!attr.hasValue())
+return;
+auto arch = attr.getValue();
 switch (arch) {
 case ARMBuildAttrs::Pre_v4:
 case ARMBuildAttrs::v4:
 case ARMBuildAttrs::v4T:
 // Architectures prior to v5 do not support BLX instruction
 case SHT_ARM_ATTRIBUTES: {
 if (config->emachine != EM_ARM)
 break;
 ARMAttributeParser attributes;
 ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(&sec));
-attributes.Parse(contents, /*isLittle*/ config->ekind == ELF32LEKind);
+if (Error e = attributes.parse(contents, config->ekind == ELF32LEKind
+? support::little
+: support::big)) {
+auto *isec = make<InputSection>(*this, sec, name);
+warn(toString(isec) + ": " + llvm::toString(std::move(e)));
+break;
+}
 updateSupportedARMFeatures(attributes);
 updateARMVFPArgs(attributes, this);
 // FIXME: Retain the first attribute section we see. The eglibc ARM
 // dynamic loaders require the presence of an attribute section for dlopen
 toELFString(sym));
 if (tar && c.getParent()->isThin())
 tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb.getBuffer());
-InputFile *file = createObjectFile(
+InputFile *file = createObjectFile(mb, getName(), c.getChildOffset());
-mb, getName(), c.getParent()->isThin() ? 0 : c.getChildOffset());
 file->groupId = groupId;
 parseFile(file);
+}
+size_t ArchiveFile::getMemberCount() const {
+size_t count = 0;
+Error err = Error::success();
+for (const Archive::Child &c : file->children(err)) {
+(void)c;
+++count;
+}
+// This function is used by --print-archive-stats=, where an error does not
+// really matter.
+consumeError(std::move(err));
+return count;
 }
 unsigned SharedFile::vernauxNum;
 // Parse the version definitions in the object file if present, and return a
 unsigned verdefIndex = curVerdef->vd_ndx;
 verdefs.resize(verdefIndex + 1);
 verdefs[verdefIndex] = curVerdef;
 }
 return verdefs;
+}
+// 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) {
+if (!sec)
+return {};
+std::vector<uint32_t> verneeds;
+ArrayRef<uint8_t> data = CHECK(obj.getSectionContents(sec), this);
+const uint8_t *verneedBuf = data.begin();
+for (unsigned i = 0; i != sec->sh_info; ++i) {
+if (verneedBuf + sizeof(typename ELFT::Verneed) > data.end() ||
+uintptr_t(verneedBuf) % sizeof(uint32_t) != 0)
+fatal(toString(this) + " has an invalid Verneed");
+auto *vn = reinterpret_cast<const typename ELFT::Verneed *>(verneedBuf);
+const uint8_t *vernauxBuf = verneedBuf + vn->vn_aux;
+for (unsigned j = 0; j != vn->vn_cnt; ++j) {
+if (vernauxBuf + sizeof(typename ELFT::Vernaux) > data.end() ||
+uintptr_t(vernauxBuf) % sizeof(uint32_t) != 0)
+fatal(toString(this) + " has an invalid Vernaux");
+auto *aux = reinterpret_cast<const typename ELFT::Vernaux *>(vernauxBuf);
+if (aux->vna_name >= this->stringTable.size())
+fatal(toString(this) + " has a Vernaux with an invalid vna_name");
+uint16_t version = aux->vna_other & VERSYM_VERSION;
+if (version >= verneeds.size())
+verneeds.resize(version + 1);
+verneeds[version] = aux->vna_name;
+vernauxBuf += aux->vna_next;
+}
+verneedBuf += vn->vn_next;
+}
+return verneeds;
 }
 // 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
 const ELFFile<ELFT> obj = this->getObj<ELFT>();
 ArrayRef<Elf_Shdr> sections = CHECK(obj.sections(), this);
 const Elf_Shdr *versymSec = nullptr;
 const Elf_Shdr *verdefSec = nullptr;
+const Elf_Shdr *verneedSec = nullptr;
 // Search for .dynsym, .dynamic, .symtab, .gnu.version and .gnu.version_d.
 for (const Elf_Shdr &sec : sections) {
 switch (sec.sh_type) {
 default:
 versymSec = &sec;
 break;
 case SHT_GNU_verdef:
 verdefSec = &sec;
 break;
+case SHT_GNU_verneed:
+verneedSec = &sec;
+break;
 }
 }
 if (versymSec && numELFSyms == 0) {
 error("SHT_GNU_versym should be associated with symbol table");
 return;
 sharedFiles.push_back(this);
 verdefs = parseVerdefs<ELFT>(obj.base(), verdefSec);
+std::vector<uint32_t> verneeds = parseVerneed<ELFT>(obj, verneedSec);
 // Parse ".gnu.version" section which is a parallel array for the symbol
 // table. If a given file doesn't have a ".gnu.version" section, we use
 // VER_NDX_GLOBAL.
 size_t size = numELFSyms - firstGlobal;
-std::vector<uint32_t> versyms(size, VER_NDX_GLOBAL);
+std::vector<uint16_t> versyms(size, VER_NDX_GLOBAL);
 if (versymSec) {
 ArrayRef<Elf_Versym> versym =
 CHECK(obj.template getSectionContentsAsArray<Elf_Versym>(versymSec),
 this)
 .slice(firstGlobal);
 warn("found local symbol '" + name +
 "' in global part of symbol table in file " + toString(this));
 continue;
 }
+uint16_t idx = versyms[i] & ~VERSYM_HIDDEN;
 if (sym.isUndefined()) {
+// For unversioned undefined symbols, VER_NDX_GLOBAL makes more sense but
+// as of binutils 2.34, GNU ld produces VER_NDX_LOCAL.
+if (idx != VER_NDX_LOCAL && idx != VER_NDX_GLOBAL) {
+if (idx >= verneeds.size()) {
+error("corrupt input file: version need index " + Twine(idx) +
+" for symbol " + name + " is out of bounds\n>>> defined in " +
+toString(this));
+continue;
+}
+StringRef verName = this->stringTable.data() + verneeds[idx];
+versionedNameBuffer.clear();
+name =
+saver.save((name + "@" + verName).toStringRef(versionedNameBuffer));
+}
 Symbol *s = symtab->addSymbol(
 Undefined{this, name, sym.getBinding(), sym.st_other, sym.getType()});
 s->exportDynamic = true;
 continue;
 }
 // MIPS BFD linker puts _gp_disp symbol into DSO files and incorrectly
 // assigns VER_NDX_LOCAL to this section global symbol. Here is a
 // workaround for this bug.
-uint32_t idx = versyms[i] & ~VERSYM_HIDDEN;
 if (config->emachine == EM_MIPS && idx == VER_NDX_LOCAL &&
 name == "_gp_disp")
 continue;
 uint32_t alignment = getAlignment<ELFT>(sections, sym);
 // name. If two archives define two members with the same name, this
 // causes a collision which result in only one of the objects being taken
 // into consideration at LTO time (which very likely causes undefined
 // symbols later in the link stage). So we append file offset to make
 // filename unique.
-StringRef name = archiveName.empty()
+StringRef name =
-? saver.save(path)
+archiveName.empty()
-: saver.save(archiveName + "(" + path + " at " +
+? saver.save(path)
-utostr(offsetInArchive) + ")");
+: saver.save(archiveName + "(" + path::filename(path) + " at " +
+utostr(offsetInArchive) + ")");
 MemoryBufferRef mbref(mb.getBuffer(), name);
 obj = CHECK(lto::InputFile::create(mbref), this);
 Triple t(obj->getTargetTriple());
 STV_DEFAULT, STT_OBJECT, data.size(), 0, section});
 symtab->addSymbol(Defined{nullptr, saver.save(s + "_size"), STB_GLOBAL,
 STV_DEFAULT, STT_OBJECT, data.size(), 0, nullptr});
 }
-InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName,
+InputFile *elf::createObjectFile(MemoryBufferRef mb, StringRef archiveName,
 uint64_t offsetInArchive) {
 if (isBitcode(mb))
 return make<BitcodeFile>(mb, archiveName, offsetInArchive);
 switch (getELFKind(mb, archiveName)) {
 case ELF32LEKind:
 }
 return;
 }
 }
-std::string replaceThinLTOSuffix(StringRef path) {
+std::string elf::replaceThinLTOSuffix(StringRef path) {
 StringRef suffix = config->thinLTOObjectSuffixReplace.first;
 StringRef repl = config->thinLTOObjectSuffixReplace.second;
 if (path.consume_back(suffix))
 return (path + repl).str();
 template void LazyObjFile::parse<ELF32LE>();
 template void LazyObjFile::parse<ELF32BE>();
 template void LazyObjFile::parse<ELF64LE>();
 template void LazyObjFile::parse<ELF64BE>();
-template class ObjFile<ELF32LE>;
+template class elf::ObjFile<ELF32LE>;
-template class ObjFile<ELF32BE>;
+template class elf::ObjFile<ELF32BE>;
-template class ObjFile<ELF64LE>;
+template class elf::ObjFile<ELF64LE>;
-template class ObjFile<ELF64BE>;
+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>();
-} // namespace elf
-} // namespace lld

Mercurial > hg > CbC > CbC_llvm

comparison lld/ELF/InputFiles.cpp @ 173:0572611fdcc8 llvm10 llvm12