[obj2yaml] - Merge dumpRelSection and dumpRelaSection. NFC.

[grimar]

Summary

These methods are very similar, so I would merge them into one.
(also, does not seem that any additional generalization would
make the code simpler too)

[jhenderson]

Basically looks fine, but I'd like the reordering done before I approve.

tools/obj2yaml/elf2yaml.cpp

365 ↗

(On Diff #184314)

This would probably line up better in diffs and history etc if you inverted this (i.e. do SHT_REL first, followed by SHT_RELA), since that matches the original function order.

[grimar]

• Reordered.

[jhenderson]

LGTM.

llvm/trunk/tools/obj2yaml/elf2yaml.cpp

std::error_code dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                              StringRef StrTable, ELFYAML::Symbol &S);
   std::error_code dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S);
   std::error_code dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                               ELFYAML::RelocationSection &S);
   template <class RelT>
   std::error_code dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                                  ELFYAML::Relocation &R);
 
-  ErrorOr<ELFYAML::RelocationSection *> dumpRelSection(const Elf_Shdr *Shdr);
-  ErrorOr<ELFYAML::RelocationSection *> dumpRelaSection(const Elf_Shdr *Shdr);
+  ErrorOr<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
 
 public:
   ELFDumper(const object::ELFFile<ELFT> &O);
case ELF::SHT_DYNSYM:
       break;
     case ELF::SHT_SYMTAB_SHNDX: {
       auto TableOrErr = Obj.getSHNDXTable(Sec);
       if (!TableOrErr)
         return errorToErrorCode(TableOrErr.takeError());
       ShndxTable = *TableOrErr;
       break;
     }
+    case ELF::SHT_REL:
     case ELF::SHT_RELA: {
-      ErrorOr<ELFYAML::RelocationSection *> S = dumpRelaSection(&Sec);
-      if (std::error_code EC = S.getError())
-        return EC;
-      Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
-      break;
-    }
-    case ELF::SHT_REL: {
-      ErrorOr<ELFYAML::RelocationSection *> S = dumpRelSection(&Sec);
+      ErrorOr<ELFYAML::RelocationSection *> S = dumpRelocSection(&Sec);
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
       break;
     }
     case ELF::SHT_GROUP: {
       ErrorOr<ELFYAML::Group *> G = dumpGroup(&Sec);
       if (std::error_code EC = G.getError())
if (!NameOrErr)
     return errorToErrorCode(NameOrErr.takeError());
   S.Info = NameOrErr.get();
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::RelocationSection *>
-ELFDumper<ELFT>::dumpRelSection(const Elf_Shdr *Shdr) {
-  assert(Shdr->sh_type == ELF::SHT_REL && "Section type is not SHT_REL");
+ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RelocationSection>();
-
   if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S))
     return EC;
 
   auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
   if (!SymTabOrErr)
     return errorToErrorCode(SymTabOrErr.takeError());
   const Elf_Shdr *SymTab = *SymTabOrErr;
 
+  if (Shdr->sh_type == ELF::SHT_REL) {
     auto Rels = Obj.rels(Shdr);
     if (!Rels)
       return errorToErrorCode(Rels.takeError());
     for (const Elf_Rel &Rel : *Rels) {
       ELFYAML::Relocation R;
       if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
         return EC;
       S->Relocations.push_back(R);
     }
-
-  return S.release();
-}
-
-template <class ELFT>
-ErrorOr<ELFYAML::RelocationSection *>
-ELFDumper<ELFT>::dumpRelaSection(const Elf_Shdr *Shdr) {
-  assert(Shdr->sh_type == ELF::SHT_RELA && "Section type is not SHT_RELA");
-  auto S = make_unique<ELFYAML::RelocationSection>();
-
-  if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S))
-    return EC;
-
-  auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
-  if (!SymTabOrErr)
-    return errorToErrorCode(SymTabOrErr.takeError());
-  const Elf_Shdr *SymTab = *SymTabOrErr;
-
+  } else {
     auto Rels = Obj.relas(Shdr);
     if (!Rels)
       return errorToErrorCode(Rels.takeError());
     for (const Elf_Rela &Rel : *Rels) {
       ELFYAML::Relocation R;
       if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
         return EC;
       R.Addend = Rel.r_addend;
       S->Relocations.push_back(R);
     }
+  }
 
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::RawContentSection *>
 ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RawContentSection>();