[ELF] Use symbol helper

[davide]

Summary

This builds on top of D10264. Use ELF helper rather than LLD ones.

[• shankar.easwaran]

LGTM.

lib/ReaderWriter/ELF/ELFFile.h

protected:
 
   /// Return the section contents.
   ErrorOr<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *shdr) const {
     if (!shdr || !sectionOccupiesMemorySpace(shdr))
       return ArrayRef<uint8_t>();
     return _objFile->getSectionContents(shdr);
   }
 
-  /// Returns true if the symbol is a undefined symbol.
-  bool isUndefinedSymbol(const Elf_Sym *sym) const {
-    return (sym->st_shndx == llvm::ELF::SHN_UNDEF);
-  }
-
   /// Determines if the target wants to create an atom for a section that has no
   /// symbol references.
   bool handleSectionWithNoSymbols(const Elf_Shdr *shdr,
                                   std::vector<Elf_Sym_Iter> &syms) const {
     return shdr && (shdr->sh_type == llvm::ELF::SHT_PROGBITS) && syms.empty();
   }
 
   /// Handle creation of atoms for .gnu.linkonce sections.
   std::error_code handleGnuLinkOnceSection(
       const Elf_Shdr *section,
       llvm::StringMap<std::vector<ELFDefinedAtom<ELFT> *>> &atomsForSection);
 
   // Handle COMDAT scetions.
   std::error_code handleSectionGroup(
       const Elf_Shdr *section,
       llvm::StringMap<std::vector<ELFDefinedAtom<ELFT> *>> &atomsForSection);
 
   /// Process the Undefined symbol and create an atom for it.
   ELFUndefinedAtom<ELFT> *createUndefinedAtom(StringRef symName,
                                               const Elf_Sym *sym) {
     return new (_readerStorage) ELFUndefinedAtom<ELFT>(*this, symName, sym);
   }
 
-  /// Returns true if the symbol is a absolute symbol.
-  bool isAbsoluteSymbol(const Elf_Sym *sym) const {
-    return (sym->st_shndx == llvm::ELF::SHN_ABS);
-  }
-
   /// Process the Absolute symbol and create an atom for it.
   ELFAbsoluteAtom<ELFT> *createAbsoluteAtom(StringRef symName,
                                             const Elf_Sym *sym, int64_t value) {
     return new (_readerStorage)
         ELFAbsoluteAtom<ELFT>(*this, symName, sym, value);
   }
 
-  /// Returns true if the symbol is common symbol. A common symbol represents a
-  /// tentive definition in C. It has name, size and alignment constraint, but
-  /// actual storage has not yet been allocated. (The linker will allocate
-  /// storage for them in the later pass after coalescing tentative symbols by
-  /// name.)
+  // This will go away. Blame Hexagon.
   virtual bool isCommonSymbol(const Elf_Sym *symbol) const {
-    return symbol->getType() == llvm::ELF::STT_COMMON ||
-           symbol->st_shndx == llvm::ELF::SHN_COMMON;
+    return _objFile->isCommonSymbol(symbol);
   }
 
   /// Returns true if the section is a gnulinkonce section.
   bool isGnuLinkOnceSection(StringRef sectionName) const {
     return sectionName.startswith(".gnu.linkonce.");
   }
 
   /// Returns true if the section is a COMDAT group section.
protected:
   }
 
   /// Process the common symbol and create an atom for it.
   virtual ELFCommonAtom<ELFT> *createCommonAtom(StringRef symName,
                                                 const Elf_Sym *sym) {
     return new (_readerStorage) ELFCommonAtom<ELFT>(*this, symName, sym);
   }
 
-  /// Returns true if the symbol is a defined symbol.
-  virtual bool isDefinedSymbol(const Elf_Sym *sym) const {
-    return (sym->getType() == llvm::ELF::STT_NOTYPE ||
-            sym->getType() == llvm::ELF::STT_OBJECT ||
-            sym->getType() == llvm::ELF::STT_FUNC ||
-            sym->getType() == llvm::ELF::STT_GNU_IFUNC ||
-            sym->getType() == llvm::ELF::STT_SECTION ||
-            sym->getType() == llvm::ELF::STT_FILE ||
-            sym->getType() == llvm::ELF::STT_TLS);
-  }
-
   /// Creates an atom for a given defined symbol.
   virtual ELFDefinedAtom<ELFT> *
   createDefinedAtom(StringRef symName, StringRef sectionName,
                     const Elf_Sym *sym, const Elf_Shdr *sectionHdr,
                     ArrayRef<uint8_t> contentData, unsigned int referenceStart,
                     unsigned int referenceEnd,
                     std::vector<ELFReference<ELFT> *> &referenceList) {
     return new (_readerStorage) ELFDefinedAtom<ELFT>(

lib/ReaderWriter/ELF/ELFFile.cpp

std::error_code ELFFile<ELFT>::createSymbolsFromAtomizableSections() {
 
   for (; SymI != SymE; ++SymI) {
     const Elf_Shdr *section = _objFile->getSection(&*SymI);
 
     auto symbolName = _objFile->getSymbolName(SymI);
     if (std::error_code ec = symbolName.getError())
       return ec;
 
-    if (isAbsoluteSymbol(&*SymI)) {
+    if (_objFile->isAbsoluteSymbol(&*SymI)) {
       ELFAbsoluteAtom<ELFT> *absAtom = createAbsoluteAtom(
           *symbolName, &*SymI, (int64_t)getSymbolValue(&*SymI));
       addAtom(*absAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*SymI, absAtom));
-    } else if (isUndefinedSymbol(&*SymI)) {
+    } else if (_objFile->isUndefinedSymbol(&*SymI)) {
       if (_useWrap &&
           (_wrapSymbolMap.find(*symbolName) != _wrapSymbolMap.end())) {
         auto wrapAtom = _wrapSymbolMap.find(*symbolName);
         _symbolToAtomMapping.insert(
             std::make_pair(&*SymI, wrapAtom->getValue()));
         continue;
       }
       ELFUndefinedAtom<ELFT> *undefAtom =
           createUndefinedAtom(*symbolName, &*SymI);
       addAtom(*undefAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*SymI, undefAtom));
-    } else if (isCommonSymbol(&*SymI)) {
+    } else if (_objFile->isCommonSymbol(&*SymI)) {
       ELFCommonAtom<ELFT> *commonAtom = createCommonAtom(*symbolName, &*SymI);
       commonAtom->setOrdinal(++_ordinal);
       addAtom(*commonAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*SymI, commonAtom));
-    } else if (isDefinedSymbol(&*SymI)) {
+    } else if (_objFile->isDefinedSymbol(&*SymI)) {
       _sectionSymbols[section].push_back(SymI);
     } else {
       llvm::errs() << "Unable to create atom for: " << *symbolName << "\n";
       return llvm::object::object_error::parse_failed;
     }
   }
 
   return std::error_code();

lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h

 class HexagonELFFile : public ELFFile<ELF32LE> {
   typedef llvm::object::Elf_Sym_Impl<ELF32LE> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELF32LE> Elf_Shdr;
 
 public:
   HexagonELFFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
       : ELFFile(std::move(mb), ctx) {}
 
-  bool isCommonSymbol(const Elf_Sym *symbol) const override {
-    switch (symbol->st_shndx) {
-    // Common symbols
-    case llvm::ELF::SHN_HEXAGON_SCOMMON:
-    case llvm::ELF::SHN_HEXAGON_SCOMMON_1:
-    case llvm::ELF::SHN_HEXAGON_SCOMMON_2:
-    case llvm::ELF::SHN_HEXAGON_SCOMMON_4:
-    case llvm::ELF::SHN_HEXAGON_SCOMMON_8:
-      return true;
-    default:
-      break;
-    }
-    return ELFFile::isCommonSymbol(symbol);
-  }
-
   /// Process the Defined symbol and create an atom for it.
   ELFDefinedAtom<ELF32LE> *createDefinedAtom(
       StringRef symName, StringRef sectionName, const Elf_Sym *sym,
       const Elf_Shdr *sectionHdr, ArrayRef<uint8_t> contentData,
       unsigned int referenceStart, unsigned int referenceEnd,
       std::vector<ELFReference<ELF32LE> *> &referenceList) override {
     return new (_readerStorage) HexagonELFDefinedAtom(
         *this, symName, sectionName, sym, sectionHdr, contentData,