[Object] Rename getRelrRelocationType to getRelativeRelocationType

[MaskRay]

Summary

The two utility functions were added in D47919 to support SHT_RELR.
However, these are just relative relocations types and are't
necessarily be named Relr.

[MaskRay]

Rename RelrRelocationType

[dberris]

LGTM

include/llvm/Object/ELF.h

 #include <cstdint>
 #include <limits>
 #include <utility>
 
 namespace llvm {
 namespace object {
 
 StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type);
-uint32_t getELFRelrRelocationType(uint32_t Machine);
+uint32_t getELFRelativeRelocationType(uint32_t Machine);
 StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type);
 
 // Subclasses of ELFFile may need this for template instantiation
 inline std::pair<unsigned char, unsigned char>
 getElfArchType(StringRef Object) {
   if (Object.size() < ELF::EI_NIDENT)
     return std::make_pair((uint8_t)ELF::ELFCLASSNONE,
                           (uint8_t)ELF::ELFDATANONE);
public:
 
   Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section) const;
   Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section,
                                              Elf_Shdr_Range Sections) const;
 
   StringRef getRelocationTypeName(uint32_t Type) const;
   void getRelocationTypeName(uint32_t Type,
                              SmallVectorImpl<char> &Result) const;
-  uint32_t getRelrRelocationType() const;
+  uint32_t getRelativeRelocationType() const;
 
   const char *getDynamicTagAsString(unsigned Arch, uint64_t Type) const;
   const char *getDynamicTagAsString(uint64_t Type) const;
 
   /// Get the symbol for a given relocation.
   Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
                                                 const Elf_Shdr *SymTab) const;
 
if (!isMipsELF64()) {
 
     Name = getRelocationTypeName(Type3);
     Result.append(1, '/');
     Result.append(Name.begin(), Name.end());
   }
 }
 
 template <class ELFT>
-uint32_t ELFFile<ELFT>::getRelrRelocationType() const {
-  return getELFRelrRelocationType(getHeader()->e_machine);
+uint32_t ELFFile<ELFT>::getRelativeRelocationType() const {
+  return getELFRelativeRelocationType(getHeader()->e_machine);
 }
 
 template <class ELFT>
 Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel *Rel,
                                    const Elf_Shdr *SymTab) const {
   uint32_t Index = Rel->getSymbol(isMips64EL());
   if (Index == 0)

lib/Object/ELF.cpp

#include "llvm/BinaryFormat/ELFRelocs/MSP430.def"
   default:
     break;
   }
   return "Unknown";
 }
 
 #undef ELF_RELOC
 
-uint32_t llvm::object::getELFRelrRelocationType(uint32_t Machine) {
+uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) {
   switch (Machine) {
   case ELF::EM_X86_64:
     return ELF::R_X86_64_RELATIVE;
   case ELF::EM_386:
   case ELF::EM_IAMCU:
     return ELF::R_386_RELATIVE;
   case ELF::EM_MIPS:
     break;
ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
   // This encoding has a couple of interesting properties:
   // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
   //    even means address, odd means bitmap.
   // 2. Just a simple list of addresses is a valid encoding.
 
   Elf_Rela Rela;
   Rela.r_info = 0;
   Rela.r_addend = 0;
-  Rela.setType(getRelrRelocationType(), false);
+  Rela.setType(getRelativeRelocationType(), false);
   std::vector<Elf_Rela> Relocs;
 
   // Word type: uint32_t for Elf32, and uint64_t for Elf64.
   typedef typename ELFT::uint Word;
 
   // Word size in number of bytes.
   const size_t WordSize = sizeof(Word);
 

lib/XRay/InstrumentationMap.cpp

return make_error<StringError>(
         std::make_error_code(std::errc::executable_format_error));
 
   if (I->getContents(Contents))
     return errorCodeToError(
         std::make_error_code(std::errc::executable_format_error));
 
   RelocMap Relocs;
   if (ObjFile.getBinary()->isELF()) {
-    uint32_t RelrRelocationType = [](object::ObjectFile *ObjFile) {
+    uint32_t RelativeRelocation = [](object::ObjectFile *ObjFile) {
       if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(ObjFile))
-        return ELFObj->getELFFile()->getRelrRelocationType();
+        return ELFObj->getELFFile()->getRelativeRelocationType();
       else if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(ObjFile))
-        return ELFObj->getELFFile()->getRelrRelocationType();
+        return ELFObj->getELFFile()->getRelativeRelocationType();
       else if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(ObjFile))
-        return ELFObj->getELFFile()->getRelrRelocationType();
+        return ELFObj->getELFFile()->getRelativeRelocationType();
       else if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(ObjFile))
-        return ELFObj->getELFFile()->getRelrRelocationType();
+        return ELFObj->getELFFile()->getRelativeRelocationType();
       else
         return static_cast<uint32_t>(0);
     }(ObjFile.getBinary());
 
     for (const object::SectionRef &Section : Sections) {
       for (const object::RelocationRef &Reloc : Section.relocations()) {
-        if (Reloc.getType() != RelrRelocationType)
+        if (Reloc.getType() != RelativeRelocation)
           continue;
         if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend())
           Relocs.insert({Reloc.getOffset(), *AddendOrErr});
       }
     }
   }
 
   // Copy the instrumentation map data into the Sleds data structure.