[ELF] Create reference to symbol map.

[shankarke]

Summary

In LLD's model, symbol is a property of the node (atom) and not a property of edge (reference). Prior to this patch, we stored the symbol in the reference. From post-commit comments, it seemed better to create a map from the reference to the symbol instead and use this mapping wherever desired.

This patch does that.

[shankarke]

lib/ReaderWriter/ELF/ELFFile.h

399

this is a minor nit and will fix.

[ruiu]

I'm still reading the prior patches but this patch itself looks good.

lib/ReaderWriter/ELF/ELFFile.h

399

Remove

[shankarke]

https://llvm.org/svn/llvm-project/lld/trunk@230273

lib/ReaderWriter/ELF/Atoms.h

 /// ELFREference. In the second pass, ELFReferences are revisited to update
 /// target atoms by target symbol indexes.
 template <class ELFT> class ELFReference : public Reference {
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
 
 public:
-  ELFReference(const Elf_Sym *sym, const Elf_Rela *rela, uint64_t off,
-               Reference::KindArch arch, Reference::KindValue relocType,
-               uint32_t idx)
-      : Reference(Reference::KindNamespace::ELF, arch, relocType), _sym(sym),
+  ELFReference(const Elf_Rela *rela, uint64_t off, Reference::KindArch arch,
+               Reference::KindValue relocType, uint32_t idx)
+      : Reference(Reference::KindNamespace::ELF, arch, relocType),
         _target(nullptr), _targetSymbolIndex(idx), _offsetInAtom(off),
         _addend(rela->r_addend) {}
 
-  ELFReference(const Elf_Sym *sym, uint64_t off, Reference::KindArch arch,
+  ELFReference(uint64_t off, Reference::KindArch arch,
                Reference::KindValue relocType, uint32_t idx)
-      : Reference(Reference::KindNamespace::ELF, arch, relocType), _sym(sym),
+      : Reference(Reference::KindNamespace::ELF, arch, relocType),
         _target(nullptr), _targetSymbolIndex(idx), _offsetInAtom(off),
         _addend(0) {}
 
   ELFReference(uint32_t edgeKind)
       : Reference(Reference::KindNamespace::all, Reference::KindArch::all,
                   edgeKind),
-        _sym(nullptr), _target(nullptr), _targetSymbolIndex(0),
-        _offsetInAtom(0), _addend(0) {}
+        _target(nullptr), _targetSymbolIndex(0), _offsetInAtom(0), _addend(0) {}
 
   uint64_t offsetInAtom() const override { return _offsetInAtom; }
 
   const Atom *target() const override { return _target; }
 
   /// \brief The symbol table index that contains the target reference.
   uint64_t targetSymbolIndex() const {
     return _targetSymbolIndex;
   }
 
   Addend addend() const override { return _addend; }
 
   virtual void setOffset(uint64_t off) { _offsetInAtom = off; }
 
   void setAddend(Addend A) override { _addend = A; }
 
   void setTarget(const Atom *newAtom) override { _target = newAtom; }
 
-  /// Is used for lookup the symbol or section that refers is in the same group
-  /// or not in a group.
-  const Elf_Sym *symbol() const { return _sym; }
-
 private:
-  const Elf_Sym *_sym;
   const Atom *_target;
   uint64_t _targetSymbolIndex;
   uint64_t _offsetInAtom;
   Addend _addend;
 };
 
 /// \brief These atoms store symbols that are fixed to a particular address.
 /// This atom has no content its address will be used by the writer to fixup

lib/ReaderWriter/ELF/ELFFile.h

protected:
   /// referencing global symbols defined as addresses in the group
   /// sections. They may not reference local symbols for addresses in
   /// the group's sections, including section symbols.
   /// ABI Doc : https://mentorembedded.github.io/cxx-abi/abi/prop-72-comdat.html
   /// Does the atom need to be redirected using a separate undefined atom ?
   bool redirectReferenceUsingUndefAtom(const Elf_Sym *sourceSymbol,
                                        const Elf_Sym *targetSymbol) const;
 
+  void addReferenceToSymbol(const ELFReference<ELFT> *r, const Elf_Sym *sym) {
+    _referenceToSymbol[r] = sym;
+  }
+
+  const Elf_Sym *findSymbolForReference(const ELFReference<ELFT> *r) const {
+    auto elfReferenceToSymbol = _referenceToSymbol.find(r);
+    if (elfReferenceToSymbol != _referenceToSymbol.end())
+      return elfReferenceToSymbol->second;
+    ;
+    return nullptr;
+  }
+
   llvm::BumpPtrAllocator _readerStorage;
   std::unique_ptr<llvm::object::ELFFile<ELFT> > _objFile;
   atom_collection_vector<DefinedAtom> _definedAtoms;
   atom_collection_vector<UndefinedAtom> _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
 
   /// \brief _relocationAddendReferences and _relocationReferences contain the
   /// list of relocations references.  In ELF, if a section named, ".text" has
   /// relocations will also have a section named ".rel.text" or ".rela.text"
   /// which will hold the entries.
   std::unordered_map<StringRef, range<Elf_Rela_Iter>>
   _relocationAddendReferences;
   MergedSectionMapT _mergedSectionMap;
   std::unordered_map<StringRef, range<Elf_Rel_Iter>> _relocationReferences;
   std::vector<ELFReference<ELFT> *> _references;
   llvm::DenseMap<const Elf_Sym *, Atom *> _symbolToAtomMapping;
+  llvm::DenseMap<const ELFReference<ELFT> *, const Elf_Sym *>
+  _referenceToSymbol;
   // Group child atoms have a pair corresponding to the signature and the
   // section header of the section that was used for generating the signature.
   llvm::DenseMap<const Elf_Sym *, std::pair<StringRef, const Elf_Shdr *>>
       _groupChild;
   llvm::StringMap<Atom *> _undefAtomsForGroupChild;
 
   /// \brief Atoms that are created for a section that has the merge property
   /// set
void ELFFile<ELFT>::createRelocationReferences(const Elf_Sym *symbol,
                                                ArrayRef<uint8_t> content,
                                                range<Elf_Rela_Iter> rels) {
   bool isMips64EL = _objFile->isMips64EL();
   const auto symValue = getSymbolValue(symbol);
   for (const auto &rel : rels) {
     if (rel.r_offset < symValue ||
         symValue + content.size() <= rel.r_offset)
       continue;
-    _references.push_back(new (_readerStorage) ELFReference<ELFT>(
-        symbol, &rel, rel.r_offset - symValue, kindArch(),
-        rel.getType(isMips64EL), rel.getSymbol(isMips64EL)));
+    auto elfRelocation = new (_readerStorage)
+        ELFReference<ELFT>(&rel, rel.r_offset - symValue, kindArch(),
+                           rel.getType(isMips64EL), rel.getSymbol(isMips64EL));
+    addReferenceToSymbol(elfRelocation, symbol);
+    _references.push_back(elfRelocation);
   }
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::createRelocationReferences(const Elf_Sym *symbol,
                                                ArrayRef<uint8_t> symContent,
                                                ArrayRef<uint8_t> secContent,
                                                range<Elf_Rel_Iter> rels) {
   bool isMips64EL = _objFile->isMips64EL();
   const auto symValue = getSymbolValue(symbol);
   for (const auto &rel : rels) {
     if (rel.r_offset < symValue ||
         symValue + symContent.size() <= rel.r_offset)
       continue;
-    _references.push_back(new (_readerStorage) ELFReference<ELFT>(
-        symbol, rel.r_offset - symValue, kindArch(), rel.getType(isMips64EL),
-        rel.getSymbol(isMips64EL)));
+    auto elfRelocation = new (_readerStorage)
+        ELFReference<ELFT>(rel.r_offset - symValue, kindArch(),
+                           rel.getType(isMips64EL), rel.getSymbol(isMips64EL));
     int32_t addend = *(symContent.data() + rel.r_offset - symValue);
-    _references.back()->setAddend(addend);
+    elfRelocation->setAddend(addend);
+    addReferenceToSymbol(elfRelocation, symbol);
+    _references.push_back(elfRelocation);
   }
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::updateReferenceForMergeStringAccess(ELFReference<ELFT> *ref,
                                                         const Elf_Sym *symbol,
                                                         const Elf_Shdr *shdr) {
   // If the target atom is mergeable strefng atom, the atom might have been
template <class ELFT> void ELFFile<ELFT>::updateReferences() {
   for (auto &ri : _references) {
     if (ri->kindNamespace() == lld::Reference::KindNamespace::ELF) {
       const Elf_Sym *symbol = _objFile->getSymbol(ri->targetSymbolIndex());
       const Elf_Shdr *shdr = _objFile->getSection(symbol);
 
       // If the atom is not in mergeable string section, the target atom is
       // simply that atom.
       if (!isMergeableStringSection(shdr)) {
-        ri->setTarget(findAtom(ri->symbol(), symbol));
+        ri->setTarget(findAtom(findSymbolForReference(ri), symbol));
         continue;
       }
       updateReferenceForMergeStringAccess(ri, symbol, shdr);
     }
   }
 }
 
 template <class ELFT>

lib/ReaderWriter/ELF/Mips/MipsELFFile.h

void createRelocationReferences(const Elf_Sym *symbol,
                                   ArrayRef<uint8_t> symContent,
                                   ArrayRef<uint8_t> secContent,
                                   range<Elf_Rel_Iter> rels) override {
     for (Elf_Rel_Iter rit = rels.begin(), eit = rels.end(); rit != eit; ++rit) {
       if (rit->r_offset < symbol->st_value ||
           symbol->st_value + symContent.size() <= rit->r_offset)
         continue;
 
-      this->_references.push_back(new (this->_readerStorage) ELFReference<ELFT>(
-          symbol, rit->r_offset - symbol->st_value, this->kindArch(),
-          rit->getType(isMips64EL()), rit->getSymbol(isMips64EL())));
+      auto elfReference = new (this->_readerStorage) ELFReference<ELFT>(
+          rit->r_offset - symbol->st_value, this->kindArch(),
+          rit->getType(isMips64EL()), rit->getSymbol(isMips64EL()));
+      ELFFile<ELFT>::addReferenceToSymbol(elfReference, symbol);
+      this->_references.push_back(elfReference);
 
       auto addend = getAddend(*rit, secContent);
       auto pairRelType = getPairRelocation(*rit);
       if (pairRelType != llvm::ELF::R_MIPS_NONE) {
         addend <<= 16;
         auto mit = findMatchingRelocation(pairRelType, rit, eit);
         if (mit != eit)
           addend += int16_t(getAddend(*mit, secContent));