[DWARF] - Simplify RelocVisitor implementation.

[grimar]

Summary

We do not need to store relocation width field.
Patch removes relative code, that simplifies implementation.

[grimar]

• Removed unused code.

include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

 
 #include "llvm/ADT/DenseMap.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 struct RelocAddrEntry {
-  int64_t Value;
+  uint64_t Value;
 };
 
 /// In place of applying the relocations to the data we've read from disk we use
 /// a separate mapping table to the side and checking that at locations in the
 /// dwarf where we expect relocated values. This adds a bit of complexity to the
 /// dwarf parsing/extraction at the benefit of not allocating memory for the
 /// entire size of the debug info sections.
 typedef DenseMap<uint64_t, RelocAddrEntry> RelocAddrMap;
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFRELOCMAP_H

include/llvm/Object/RelocVisitor.h

 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MachO.h"
 #include <cstdint>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
-struct RelocToApply {
-  // The computed value after applying the relevant relocations.
-  int64_t Value = 0;
-
-  // The width of the value; how many bytes to touch when applying the
-  // relocation.
-  char Width = 0;
-
-  RelocToApply() = default;
-  RelocToApply(int64_t Value, char Width) : Value(Value), Width(Width) {}
-};
-
 /// @brief Base class for object file relocation visitors.
 class RelocVisitor {
 public:
   explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {}
 
   // TODO: Should handle multiple applied relocations via either passing in the
   // previously computed value or just count paired relocations as a single
   // visit.
-  RelocToApply visit(uint32_t RelocType, RelocationRef R, uint64_t Value = 0) {
+  uint64_t visit(uint32_t RelocType, RelocationRef R, uint64_t Value = 0) {
     if (isa<ELFObjectFileBase>(ObjToVisit))
       return visitELF(RelocType, R, Value);
     if (isa<COFFObjectFile>(ObjToVisit))
       return visitCOFF(RelocType, R, Value);
     if (isa<MachOObjectFile>(ObjToVisit))
       return visitMachO(RelocType, R, Value);
 
     HasError = true;
-    return RelocToApply();
+    return 0;
   }
 
   bool error() { return HasError; }
 
 private:
   const ObjectFile &ObjToVisit;
   bool HasError = false;
 
-  RelocToApply visitELF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
+  uint64_t visitELF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getBytesInAddress() == 8) { // 64-bit object file
       switch (ObjToVisit.getArch()) {
       case Triple::x86_64:
         switch (RelocType) {
         case ELF::R_X86_64_NONE:
           return visitELF_X86_64_NONE(R);
         case ELF::R_X86_64_64:
           return visitELF_X86_64_64(R, Value);
         case ELF::R_X86_64_PC32:
           return visitELF_X86_64_PC32(R, Value);
         case ELF::R_X86_64_32:
           return visitELF_X86_64_32(R, Value);
         case ELF::R_X86_64_32S:
           return visitELF_X86_64_32S(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::aarch64:
       case Triple::aarch64_be:
         switch (RelocType) {
         case ELF::R_AARCH64_ABS32:
           return visitELF_AARCH64_ABS32(R, Value);
         case ELF::R_AARCH64_ABS64:
           return visitELF_AARCH64_ABS64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::bpfel:
       case Triple::bpfeb:
         switch (RelocType) {
         case ELF::R_BPF_64_64:
           return visitELF_BPF_64_64(R, Value);
         case ELF::R_BPF_64_32:
           return visitELF_BPF_64_32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::mips64el:
       case Triple::mips64:
         switch (RelocType) {
         case ELF::R_MIPS_32:
           return visitELF_MIPS64_32(R, Value);
         case ELF::R_MIPS_64:
           return visitELF_MIPS64_64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::ppc64le:
       case Triple::ppc64:
         switch (RelocType) {
         case ELF::R_PPC64_ADDR32:
           return visitELF_PPC64_ADDR32(R, Value);
         case ELF::R_PPC64_ADDR64:
           return visitELF_PPC64_ADDR64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::systemz:
         switch (RelocType) {
         case ELF::R_390_32:
           return visitELF_390_32(R, Value);
         case ELF::R_390_64:
           return visitELF_390_64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::sparcv9:
         switch (RelocType) {
         case ELF::R_SPARC_32:
         case ELF::R_SPARC_UA32:
           return visitELF_SPARCV9_32(R, Value);
         case ELF::R_SPARC_64:
         case ELF::R_SPARC_UA64:
           return visitELF_SPARCV9_64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::amdgcn:
         switch (RelocType) {
         case ELF::R_AMDGPU_ABS32:
           return visitELF_AMDGPU_ABS32(R, Value);
         case ELF::R_AMDGPU_ABS64:
           return visitELF_AMDGPU_ABS64(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       default:
         HasError = true;
-        return RelocToApply();
+        return 0;
       }
     } else if (ObjToVisit.getBytesInAddress() == 4) { // 32-bit object file
       switch (ObjToVisit.getArch()) {
       case Triple::x86:
         switch (RelocType) {
         case ELF::R_386_NONE:
           return visitELF_386_NONE(R);
         case ELF::R_386_32:
           return visitELF_386_32(R, Value);
         case ELF::R_386_PC32:
           return visitELF_386_PC32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::ppc:
         switch (RelocType) {
         case ELF::R_PPC_ADDR32:
           return visitELF_PPC_ADDR32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::arm:
       case Triple::armeb:
         switch (RelocType) {
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         case ELF::R_ARM_ABS32:
           return visitELF_ARM_ABS32(R, Value);
         }
       case Triple::lanai:
         switch (RelocType) {
         case ELF::R_LANAI_32:
           return visitELF_Lanai_32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::mipsel:
       case Triple::mips:
         switch (RelocType) {
         case ELF::R_MIPS_32:
           return visitELF_MIPS_32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::sparc:
         switch (RelocType) {
         case ELF::R_SPARC_32:
         case ELF::R_SPARC_UA32:
           return visitELF_SPARC_32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       case Triple::hexagon:
         switch (RelocType) {
         case ELF::R_HEX_32:
           return visitELF_HEX_32(R, Value);
         default:
           HasError = true;
-          return RelocToApply();
+          return 0;
         }
       default:
         HasError = true;
-        return RelocToApply();
+        return 0;
       }
     } else {
       report_fatal_error("Invalid word size in object file");
     }
   }
 
-  RelocToApply visitCOFF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
+  uint64_t visitCOFF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
     switch (ObjToVisit.getArch()) {
     case Triple::x86:
       switch (RelocType) {
       case COFF::IMAGE_REL_I386_SECREL:
         return visitCOFF_I386_SECREL(R, Value);
       case COFF::IMAGE_REL_I386_DIR32:
         return visitCOFF_I386_DIR32(R, Value);
       }
       break;
     case Triple::x86_64:
       switch (RelocType) {
       case COFF::IMAGE_REL_AMD64_SECREL:
         return visitCOFF_AMD64_SECREL(R, Value);
       case COFF::IMAGE_REL_AMD64_ADDR64:
         return visitCOFF_AMD64_ADDR64(R, Value);
       }
       break;
     }
     HasError = true;
-    return RelocToApply();
+    return 0;
   }
 
-  RelocToApply visitMachO(uint32_t RelocType, RelocationRef R, uint64_t Value) {
+  uint64_t visitMachO(uint32_t RelocType, RelocationRef R, uint64_t Value) {
     switch (ObjToVisit.getArch()) {
     default: break;
     case Triple::x86_64:
       switch (RelocType) {
         default: break;
         case MachO::X86_64_RELOC_UNSIGNED:
           return visitMACHO_X86_64_UNSIGNED(R, Value);
       }
     }
     HasError = true;
-    return RelocToApply();
+    return 0;
   }
 
   int64_t getELFAddend(RelocationRef R) {
     ErrorOr<int64_t> AddendOrErr = ELFRelocationRef(R).getAddend();
     if (std::error_code EC = AddendOrErr.getError())
       report_fatal_error(EC.message());
     return *AddendOrErr;
   }
 
-  uint8_t getLengthMachO64(RelocationRef R) {
-    const MachOObjectFile *Obj = cast<MachOObjectFile>(R.getObject());
-    return Obj->getRelocationLength(R.getRawDataRefImpl());
-  }
-
   /// Operations
 
   /// 386-ELF
-  RelocToApply visitELF_386_NONE(RelocationRef R) {
-    return RelocToApply(0, 0);
+  uint64_t visitELF_386_NONE(RelocationRef R) {
+    return 0;
   }
 
   // Ideally the Addend here will be the addend in the data for
   // the relocation. It's not actually the case for Rel relocations.
-  RelocToApply visitELF_386_32(RelocationRef R, uint64_t Value) {
-    return RelocToApply(Value, 4);
+  uint64_t visitELF_386_32(RelocationRef R, uint64_t Value) {
+    return Value;
   }
 
-  RelocToApply visitELF_386_PC32(RelocationRef R, uint64_t Value) {
-    uint64_t Address = R.getOffset();
-    return RelocToApply(Value - Address, 4);
+  uint64_t visitELF_386_PC32(RelocationRef R, uint64_t Value) {
+    return Value - R.getOffset();
   }
 
   /// X86-64 ELF
-  RelocToApply visitELF_X86_64_NONE(RelocationRef R) {
-    return RelocToApply(0, 0);
+  uint64_t visitELF_X86_64_NONE(RelocationRef R) {
+    return 0;
   }
-  RelocToApply visitELF_X86_64_64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+
+  uint64_t visitELF_X86_64_64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
-  RelocToApply visitELF_X86_64_PC32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint64_t Address = R.getOffset();
-    return RelocToApply(Value + Addend - Address, 4);
+
+  uint64_t visitELF_X86_64_PC32(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R) - R.getOffset();
   }
-  RelocToApply visitELF_X86_64_32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+
+  uint64_t visitELF_X86_64_32(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
-  RelocToApply visitELF_X86_64_32S(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    int32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+
+  uint64_t visitELF_X86_64_32S(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
 
   /// BPF ELF
-  RelocToApply visitELF_BPF_64_32(RelocationRef R, uint64_t Value) {
-    uint32_t Res = Value & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_BPF_64_32(RelocationRef R, uint64_t Value) {
+    return Value & 0xFFFFFFFF;
   }
-  RelocToApply visitELF_BPF_64_64(RelocationRef R, uint64_t Value) {
-    return RelocToApply(Value, 8);
+
+  uint64_t visitELF_BPF_64_64(RelocationRef R, uint64_t Value) {
+    return Value;
   }
 
   /// PPC64 ELF
-  RelocToApply visitELF_PPC64_ADDR32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_PPC64_ADDR32(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
-  RelocToApply visitELF_PPC64_ADDR64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+
+  uint64_t visitELF_PPC64_ADDR64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
   /// PPC32 ELF
-  RelocToApply visitELF_PPC_ADDR32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_PPC_ADDR32(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
 
   /// Lanai ELF
-  RelocToApply visitELF_Lanai_32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_Lanai_32(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
 
   /// MIPS ELF
-  RelocToApply visitELF_MIPS_32(RelocationRef R, uint64_t Value) {
-    uint32_t Res = Value & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_MIPS_32(RelocationRef R, uint64_t Value) {
+    return Value & 0xFFFFFFFF;
   }
 
   /// MIPS64 ELF
-  RelocToApply visitELF_MIPS64_32(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
-    return RelocToApply(Res, 4);
+  uint64_t visitELF_MIPS64_32(RelocationRef R, uint64_t Value) {
+    return (Value + getELFAddend(R)) & 0xFFFFFFFF;
   }
 
-  RelocToApply visitELF_MIPS64_64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    uint64_t Res = (Value + Addend);
-    return RelocToApply(Res, 8);
+  uint64_t visitELF_MIPS64_64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
   // AArch64 ELF
-  RelocToApply visitELF_AARCH64_ABS32(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_AARCH64_ABS32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
     int64_t Res =  Value + Addend;
 
     // Overflow check allows for both signed and unsigned interpretation.
     if (Res < INT32_MIN || Res > UINT32_MAX)
       HasError = true;
 
-    return RelocToApply(static_cast<uint32_t>(Res), 4);
+    return static_cast<uint32_t>(Res);
   }
 
-  RelocToApply visitELF_AARCH64_ABS64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+  uint64_t visitELF_AARCH64_ABS64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
   // SystemZ ELF
-  RelocToApply visitELF_390_32(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_390_32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
     int64_t Res = Value + Addend;
 
     // Overflow check allows for both signed and unsigned interpretation.
     if (Res < INT32_MIN || Res > UINT32_MAX)
       HasError = true;
 
-    return RelocToApply(static_cast<uint32_t>(Res), 4);
+    return static_cast<uint32_t>(Res);
   }
 
-  RelocToApply visitELF_390_64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+  uint64_t visitELF_390_64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
-  RelocToApply visitELF_SPARC_32(RelocationRef R, uint32_t Value) {
-    int32_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 4);
+  uint64_t visitELF_SPARC_32(RelocationRef R, uint32_t Value) {
+    return Value + getELFAddend(R);
   }
 
-  RelocToApply visitELF_SPARCV9_32(RelocationRef R, uint64_t Value) {
-    int32_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 4);
+  uint64_t visitELF_SPARCV9_32(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
-  RelocToApply visitELF_SPARCV9_64(RelocationRef R, uint64_t Value) {
-    int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+  uint64_t visitELF_SPARCV9_64(RelocationRef R, uint64_t Value) {
+    return Value + getELFAddend(R);
   }
 
-  RelocToApply visitELF_ARM_ABS32(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_ARM_ABS32(RelocationRef R, uint64_t Value) {
     int64_t Res = Value;
 
     // Overflow check allows for both signed and unsigned interpretation.
     if (Res < INT32_MIN || Res > UINT32_MAX)
       HasError = true;
 
-    return RelocToApply(static_cast<uint32_t>(Res), 4);
+    return static_cast<uint32_t>(Res);
   }
 
-  RelocToApply visitELF_HEX_32(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_HEX_32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 4);
+    return Value + Addend;
   }
 
-  RelocToApply visitELF_AMDGPU_ABS32(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_AMDGPU_ABS32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 4);
+    return Value + Addend;
   }
 
-  RelocToApply visitELF_AMDGPU_ABS64(RelocationRef R, uint64_t Value) {
+  uint64_t visitELF_AMDGPU_ABS64(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
-    return RelocToApply(Value + Addend, 8);
+    return Value + Addend;
   }
 
   /// I386 COFF
-  RelocToApply visitCOFF_I386_SECREL(RelocationRef R, uint64_t Value) {
-    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
+  uint64_t visitCOFF_I386_SECREL(RelocationRef R, uint64_t Value) {
+    return static_cast<uint32_t>(Value);
   }
 
-  RelocToApply visitCOFF_I386_DIR32(RelocationRef R, uint64_t Value) {
-    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
+  uint64_t visitCOFF_I386_DIR32(RelocationRef R, uint64_t Value) {
+    return static_cast<uint32_t>(Value);
   }
 
   /// AMD64 COFF
-  RelocToApply visitCOFF_AMD64_SECREL(RelocationRef R, uint64_t Value) {
-    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
+  uint64_t visitCOFF_AMD64_SECREL(RelocationRef R, uint64_t Value) {
+    return static_cast<uint32_t>(Value);
   }
 
-  RelocToApply visitCOFF_AMD64_ADDR64(RelocationRef R, uint64_t Value) {
-    return RelocToApply(Value, /*Width=*/8);
+  uint64_t visitCOFF_AMD64_ADDR64(RelocationRef R, uint64_t Value) {
+    return Value;
   }
 
   // X86_64 MachO
-  RelocToApply visitMACHO_X86_64_UNSIGNED(RelocationRef R, uint64_t Value) {
-    uint8_t Length = getLengthMachO64(R);
-    Length = 1<<Length;
-    return RelocToApply(Value, Length);
+  uint64_t visitMACHO_X86_64_UNSIGNED(RelocationRef R, uint64_t Value) {
+    return Value;
   }
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_RELOCVISITOR_H

lib/DebugInfo/DWARF/DWARFContext.cpp

if (!Map) {
       else
         continue;
     }
 
     if (Section.relocation_begin() == Section.relocation_end())
       continue;
 
     std::map<SymbolRef, uint64_t> AddrCache;
+    if (Section.relocation_begin() != Section.relocation_end()) {
       for (const RelocationRef &Reloc : Section.relocations()) {
         // FIXME: it's not clear how to correctly handle scattered
         // relocations.
         if (isRelocScattered(Obj, Reloc))
           continue;
 
         Expected<uint64_t> SymAddrOrErr =
             getSymbolAddress(Obj, Reloc, L, AddrCache);
         if (!SymAddrOrErr) {
           errs() << toString(SymAddrOrErr.takeError()) << '\n';
           continue;
         }
 
         object::RelocVisitor V(Obj);
-      object::RelocToApply R(V.visit(Reloc.getType(), Reloc, *SymAddrOrErr));
+        uint64_t Val = V.visit(Reloc.getType(), Reloc, *SymAddrOrErr);
         if (V.error()) {
           SmallString<32> Name;
           Reloc.getTypeName(Name);
           errs() << "error: failed to compute relocation: " << Name << "\n";
           continue;
         }
-      Map->insert({Reloc.getOffset(), {R.Value}});
+        Map->insert({Reloc.getOffset(), {Val}});
+      }
     }
   }
 }
 
 DWARFContextInMemory::DWARFContextInMemory(
     const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, uint8_t AddrSize,
     bool isLittleEndian)
     : IsLittleEndian(isLittleEndian), AddressSize(AddrSize) {