[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 ↗

(On Diff #27166)

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

1033 ↗

(On Diff #27166)

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 ↗

(On Diff #27166)

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 ↗

(On Diff #27166)

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

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/ELFTypes.h

struct Elf_Sym_Base<ELFType<TargetEndianness, true>> {
   Elf_Half st_shndx;      // Which section (header table index) it's defined in
   Elf_Addr st_value;      // Value or address associated with the symbol
   Elf_Xword st_size;      // Size of the symbol
 };
 
 template <class ELFT>
 struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
   using Elf_Sym_Base<ELFT>::st_info;
+  using Elf_Sym_Base<ELFT>::st_shndx;
   using Elf_Sym_Base<ELFT>::st_other;
 
   // These accessors and mutators correspond to the ELF32_ST_BIND,
   // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification:
   unsigned char getBinding() const { return st_info >> 4; }
   unsigned char getType() const { return st_info & 0x0f; }
   void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
   void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
   void setBindingAndType(unsigned char b, unsigned char t) {
     st_info = (b << 4) + (t & 0x0f);
   }
 
   /// Access to the STV_xxx flag stored in the first two bits of st_other.
   /// STV_DEFAULT: 0
   /// STV_INTERNAL: 1
   /// STV_HIDDEN: 2
   /// STV_PROTECTED: 3
   unsigned char getVisibility() const { return st_other & 0x3; }
   void setVisibility(unsigned char v) {
     assert(v < 4 && "Invalid value for visibility");
     st_other = (st_other & ~0x3) | v;
   }
+
+  bool isAbsolute() const { return st_shndx == ELF::SHN_ABS; }
+  bool isCommon() const {
+    return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
+  }
+  bool isDefined() const {
+    return !isUndefinedSymbol() &&
+           (!(st_shndx >= ELF::SHN_LORESERVE &&
+              st_shndx <= ELF::SHN_HIRESERVE) ||
+            st_shndx == ELF::SHN_XINDEX);
+  }
+  bool isProcessorSpecific() const {
+    return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
+  }
+  bool isOSSpecific() const {
+    return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
+  }
+  bool isReserved() const {
+    return st_shndx > ELF::SHN_HIOS && st_shndx < ELF::SHN_ABS;
+  }
+  bool isUndefined() const { return st_shndx == ELF::SHN_UNDEF; }
 };
 
 /// Elf_Versym: This is the structure of entries in the SHT_GNU_versym section
 /// (.gnu.version). This structure is identical for ELF32 and ELF64.
 template <class ELFT>
 struct Elf_Versym_Impl {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
   Elf_Half vs_index; // Version index with flags (e.g. VERSYM_HIDDEN)