[Object/ELF] Provide symbol helpers

[davide]

Summary

These were in lld. They can be reused for other tools, e.g. llvm-readobj.
If needed, we can introduce another class as COFF does (i.e. COFFSymboRef).
Note: Hexagon has a different notion of common symbol I'm not entirely sure I understand.
I wasn't able to find documentation either, so any help on this side is greatly appreciated.

[• rafael]

include/llvm/Object/ELF.h

1030

You don't need the type, just she st_shndx.

1033

This is scary and should probably not be in the common function.

These values can be reused by other architectures to mean something else, no? So they can only be checked in a hexagon only path.

1042

You only need to check the st_shndx.

My suggestion would be to have predicates that cover all values:

SHN_UNDEF -> isUndefinedSymbol
not SHN_UNDEF and (not in SHN_LORESERVE..SHN_HIRESERVE) except for SHN_XINDEX -> isDefinedSymbol
SHN_LOPROC..SHN_HIOS -> isTargetSpecific
SHN_ABS -> isAbsSymbol
SHN_COMMON ->isAbsSymbol

[• rafael]

include/llvm/Object/ELF.h

1030

Actually, sorry, you need the type.

On a .o the symbol is required to have SHN_COMMON, but that doesn't exist on a .so.

Since we want this to work for both what you have is probably the best.

[ruiu]

All these member functions don't seem to actually belong to ELFFile. They
just call member functions of their arguments. Does it make more sense if
we add them to Elf_Sym?

[davide]

Yes, you're both right. I should have done this before.

[davide]

Updated.

[ruiu]

LGTM but please wait for Rafael.

[davide]

2015-06-05 13:56 GMT-07:00 Rui Ueyama <[e-mail]>:

LGTM but please wait for Rafael.

Sure, no rush.

[• rafael]

LGTM with a fix for common symbols.

include/llvm/Object/ELFTypes.h

185 ↗

(On Diff #27225)

Now that I think of it, do we count common as defined? For ELF probably.

With that you can use

!isUndefiredSymbol && !(st_shndx >= SHN_LORESERVE && st_shndx < SHN_ABS);

include/llvm/Object/ELF.h

public:
   /// \p SymTab is used to lookup the string table to use to get the symbol's
   /// name.
   ErrorOr<StringRef> getSymbolName(const Elf_Shdr *SymTab,
                                    const Elf_Sym *Symb) const;
   ErrorOr<StringRef> getSectionName(const Elf_Shdr *Section) const;
   uint64_t getSymbolIndex(const Elf_Sym *sym) const;
   ErrorOr<ArrayRef<uint8_t> > getSectionContents(const Elf_Shdr *Sec) const;
   StringRef getLoadName() const;
+
+  bool isUndefinedSymbol(const Elf_Sym *Sym) const;
+  bool isAbsoluteSymbol(const Elf_Sym *Sym) const;
+  bool isCommonSymbol(const Elf_Sym *Sym) const;
+  bool isDefinedSymbol(const Elf_Sym *Sym) const;
 };
 
 typedef ELFFile<ELFType<support::little, false>> ELF32LEFile;
 typedef ELFFile<ELFType<support::little, true>> ELF64LEFile;
 typedef ELFFile<ELFType<support::big, false>> ELF32BEFile;
 typedef ELFFile<ELFType<support::big, true>> ELF64BEFile;
 
 // Iterate through the version definitions, and place each Elf_Verdef
if (entry.isVerdef()) {
     IsDefault = false;
   }
 
   if (name_offset >= DynStrRegion.Size)
     return object_error::parse_failed;
   return StringRef(getDynamicString(name_offset));
 }
 
+template <class ELFT>
+bool ELFFile<ELFT>::isUndefinedSymbol(const Elf_Sym *Sym) const {
+  return Sym->st_shndx == llvm::ELF::SHN_UNDEF;
+}
+
+template <class ELFT>
+bool ELFFile<ELFT>::isAbsoluteSymbol(const Elf_Sym *Sym) const {
+  return Sym->st_shndx == llvm::ELF::SHN_ABS;
+}
+
+template <class ELFT>
+bool ELFFile<ELFT>::isCommonSymbol(const Elf_Sym *Sym) const {
+  return Sym->getType() == llvm::ELF::STT_COMMON ||
+         Sym->st_shndx == llvm::ELF::SHN_COMMON ||
+         /* Hexagon-specific */
+         Sym->st_shndx == llvm::ELF::SHN_HEXAGON_SCOMMON ||
+         Sym->st_shndx == llvm::ELF::SHN_HEXAGON_SCOMMON_1 ||
+         Sym->st_shndx == llvm::ELF::SHN_HEXAGON_SCOMMON_2 ||
+         Sym->st_shndx == llvm::ELF::SHN_HEXAGON_SCOMMON_4 ||
+         Sym->st_shndx == llvm::ELF::SHN_HEXAGON_SCOMMON_8;
+}
+
+template <class ELFT>
+bool ELFFile<ELFT>::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;
+}
+
 /// This function returns the hash value for a symbol in the .dynsym section
 /// Name of the API remains consistent as specified in the libelf
 /// REF : http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash
 static inline unsigned elf_hash(StringRef &symbolName) {
   unsigned h = 0, g;
   for (unsigned i = 0, j = symbolName.size(); i < j; i++) {
     h = (h << 4) + symbolName[i];
     g = h & 0xf0000000L;