[Object/RelocVisitor] - Add support for R_X86_64_DTPOFF32 relocation.

[grimar]

Summary

This is PR33173. More simple way to reproduce is below:

If we have tls.c file with line

__thread int a;

gcc -c tls.c -g

gives us R_X86_64_DTPOFF32 relocation in output:

Relocation section '.rela.debug_info' at offset 0x2e0 contains 6 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000000006  00070000000a R_X86_64_32       0000000000000000 .debug_abbrev + 0
00000000000c  000a0000000a R_X86_64_32       0000000000000000 .debug_str + 26
000000000011  000a0000000a R_X86_64_32       0000000000000000 .debug_str + 54
000000000015  000a0000000a R_X86_64_32       0000000000000000 .debug_str + 0
000000000019  00090000000a R_X86_64_32       0000000000000000 .debug_line + 0
000000000028  000d00000015 R_X86_64_DTPOFF32 0000000000000000 a + 0

And run of llvm-dwarfdump tls.o would report "error: failed to compute relocation: R_X86_64_DTPOFF32"
error then, because such a relocation is not supported atm.

R_X86_64_DTPOFF32 calculates negative offset in the TLS block. Problem that size of TLS segment is not known
here. The same applies for PR33173 where we use RelocVisitor as part of DWARFContextInMemory for building .gdb_index.
TLS relocations pointing to .debug_info seems useless for index building purposes and we do not care about final value too.
So far it seems reasonable to have some value by default for TLS size, like 0 in this patch and some API that can be used in theory
if somebody needs to evaluate those TLS relocations.

That is what this patch do.

[grimar]

PR33173 fixed differently.

include/llvm/DebugInfo/DIContext.h

public:
   /// local (unrelocated) object file and applied on the fly. Note that this method
   /// is used purely for optimzation purposes in the common case of JITting in the
   /// local address space, so returning false should always be correct.
   virtual bool getLoadedSectionContents(const object::SectionRef &Sec,
                                         StringRef &Data) const {
     return false;
   }
 
+  /// Method returns size of TLS segment which is required for resolving TLS
+  /// relocations sometimes.
+  virtual uint64_t getTlsSize() const { return 0; }
+
   /// Obtain a copy of this LoadedObjectInfo.
   ///
   /// The caller is responsible for deallocation once the copy is no longer required.
   virtual std::unique_ptr<LoadedObjectInfo> clone() const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DICONTEXT_H

include/llvm/Object/RelocVisitor.h

 #include <system_error>
 
 namespace llvm {
 namespace object {
 
 /// @brief Base class for object file relocation visitors.
 class RelocVisitor {
 public:
-  explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {}
+  explicit RelocVisitor(const ObjectFile &Obj, uint64_t TlsSize)
+      : ObjToVisit(Obj), TlsSize(TlsSize) {}
 
   // TODO: Should handle multiple applied relocations via either passing in the
   // previously computed value or just count paired relocations as a single
   // visit.
   uint64_t visit(uint32_t Rel, RelocationRef R, uint64_t Value = 0) {
     if (isa<ELFObjectFileBase>(ObjToVisit))
       return visitELF(Rel, R, Value);
     if (isa<COFFObjectFile>(ObjToVisit))
       return visitCOFF(Rel, R, Value);
     if (isa<MachOObjectFile>(ObjToVisit))
       return visitMachO(Rel, R, Value);
 
     HasError = true;
     return 0;
   }
 
   bool error() { return HasError; }
 
 private:
   const ObjectFile &ObjToVisit;
+  uint64_t TlsSize;
   bool HasError = false;
 
   uint64_t visitELF(uint32_t Rel, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getBytesInAddress() == 8) { // 64-bit object file
       switch (ObjToVisit.getArch()) {
       case Triple::x86_64:
         return visitX86_64(Rel, R, Value);
       case Triple::aarch64:
case ELF::R_X86_64_NONE:
       return 0;
     case ELF::R_X86_64_64:
       return Value + getELFAddend(R);
     case ELF::R_X86_64_PC32:
       return Value + getELFAddend(R) - R.getOffset();
     case ELF::R_X86_64_32:
     case ELF::R_X86_64_32S:
       return (Value + getELFAddend(R)) & 0xFFFFFFFF;
+    case ELF::R_X86_64_DTPOFF32:
+      return Value + getELFAddend(R) - TlsSize;
     }
     HasError = true;
     return 0;
   }
 
   uint64_t visitAarch64(uint32_t Rel, RelocationRef R, uint64_t Value) {
     switch (Rel) {
     case ELF::R_AARCH64_ABS32: {

lib/DebugInfo/DWARF/DWARFContext.cpp

for (const RelocationRef &Reloc : Section.relocations()) {
         continue;
 
       Expected<SymInfo> SymInfoOrErr = getSymbolInfo(Obj, Reloc, L, AddrCache);
       if (!SymInfoOrErr) {
         errs() << toString(SymInfoOrErr.takeError()) << '\n';
         continue;
       }
 
-      object::RelocVisitor V(Obj);
+      object::RelocVisitor V(Obj, L ? L->getTlsSize() : 0);
       uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address);
       if (V.error()) {
         SmallString<32> Name;
         Reloc.getTypeName(Name);
         errs() << "error: failed to compute relocation: " << Name << "\n";
         continue;
       }
       llvm::RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};