[WIP][ELFDumper] Refactor some of the helper functions to a header file.

[ayermolo]

Summary

Refactoring some of the helper functions and structs in to a header file so they can be used by other, downstream, tools. Second part will be moving it under llvm/include/*.

[jhenderson]

Could you provide some explanation as to why you need this code in your downstream tools, please? On the surface of it, I don't like this change (for a start, there's too much implementation in headers). An explanation of your use-cases may help provide an alternative approach.

[MaskRay]

And note that tools/llvm-readobj/ELFDumper.h is a public API header. llvm/include/llvm/**/*.h are public API headers.

[ayermolo]

Ah sorry was going to post on llvm-dev as RFC, but got pulled in to something else internally.
My motivation as it was previously to improve user experience of none compiler people dealing with compiler errors and reduce the work of dev teams that support them.
Right now when relocation overflow occurs it's a manual process to figure out what the layout is.

1. Isolate linking command
2. add a flag to dump map file
3. run SED command. Suggested by @MaskRay in another review.
4. look through not so user friendly output.

I understand @MaskRay doesn't want additional code in LLD in upstream because it ads to maintenance. I am hoping that upstream community will at least be OK with refactor of helper functions so that downstream changes are more self contained.
The end goal is when relocation error occurs part of error message is a nice looking layout print out in same format as llvm-readelf --sections that user can take a look at and see what is going wrong, or ask dev team. Without repeating aforementioned steps every single time.

For header layout comment. When I refactored llvm-dwp in to a library David Blaikie asked me to split it to two commits. One refactor, and second moving files in under llvm/include/* llvm/lib/*. So I am following the same pattern here.
For too much implementation in the headers. I don't really have a strong opinion about it. I was hoping to get feedback from community. In the headers it can just be inlined without using LTO, but standard approach of linked library also works. Probably doesn't matter since this is not on a critical execution path.

[jhenderson]

Sorry for not coming back to this sooner. I've been both away and busy. I recommend you try writing an RFC for the mailing list, as it will get more attention.

From what I can see, all the code you're moving around is to do with actual printing, not parsing, of objects. In my mind, parsing code can and probably should live in the Object library, and printing code should be specific to each individual tool, so that the impact of output format changes are restricted in scope. It also ensures each tool has its own specific formatting, appropriate for its individual needs - it is extremely rare that one tool's output is appropriate for other tools. If it were, why do those tools need to exist after all? In your case, would a simple script which performs the same operations as you hope to achieve with your tool suffice? This could obviously shell out to llvm-readobj for the printing. That all being said, there might be an appetite in the wider community for refactoring the llvm-readobj dumping code into a library so other tools can share the dumping functionality in the future - you'd need to ask.

More generally, a refactor like this in its current form is likely to be reversed at some future point by somebody who doesn't know the context of this change ("Why are all these functions in the header file, when they can just be defined in the .cpp?"), and so will just break your tool then. If we are going to propose sharing the llvm-readobj code wider, I'd create a dedicated Readobj or ObjectPrinting library, or similar, that can be used elsewhere. In such a case, you'd want to move ALL the llvm-readobj printing code (i.e. basically all of the *Dumper source) into the library, leaving the tool to read the command-line, load the object(s) and call the appropriate functions. Once the code is in a library, it is much easier to work with, and much less likely to get broken at some future point.

llvm/tools/llvm-readobj/ELFDumper.h

+//===-- ELFDumper.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_READOBJ_ELFDUMPER_H
+#define LLVM_TOOLS_LLVM_READOBJ_ELFDUMPER_H
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+namespace llvm {
+namespace ELF {
+#define LLVM_READOBJ_ENUM_CASE(ns, enum)                                       \
+  case ns::enum:                                                               \
+    return #enum;
+
+#define ENUM_ENT(enum, altName)                                                \
+  { #enum, altName, ELF::enum }
+
+#define ENUM_ENT_1(enum)                                                       \
+  { #enum, #enum, ELF::enum }
+
+const EnumEntry<unsigned> ElfSectionFlags[] = {
+    ENUM_ENT(SHF_WRITE, "W"),      ENUM_ENT(SHF_ALLOC, "A"),
+    ENUM_ENT(SHF_EXECINSTR, "X"),  ENUM_ENT(SHF_MERGE, "M"),
+    ENUM_ENT(SHF_STRINGS, "S"),    ENUM_ENT(SHF_INFO_LINK, "I"),
+    ENUM_ENT(SHF_LINK_ORDER, "L"), ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
+    ENUM_ENT(SHF_GROUP, "G"),      ENUM_ENT(SHF_TLS, "T"),
+    ENUM_ENT(SHF_COMPRESSED, "C"), ENUM_ENT(SHF_GNU_RETAIN, "R"),
+    ENUM_ENT(SHF_EXCLUDE, "E"),
+};
+
+const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
+    ENUM_ENT(XCORE_SHF_CP_SECTION, ""), ENUM_ENT(XCORE_SHF_DP_SECTION, "")};
+
+const EnumEntry<unsigned> ElfARMSectionFlags[] = {
+    ENUM_ENT(SHF_ARM_PURECODE, "y")};
+
+const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
+    ENUM_ENT(SHF_HEX_GPREL, "")};
+
+const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
+    ENUM_ENT(SHF_MIPS_NODUPES, ""), ENUM_ENT(SHF_MIPS_NAMES, ""),
+    ENUM_ENT(SHF_MIPS_LOCAL, ""),   ENUM_ENT(SHF_MIPS_NOSTRIP, ""),
+    ENUM_ENT(SHF_MIPS_GPREL, ""),   ENUM_ENT(SHF_MIPS_MERGE, ""),
+    ENUM_ENT(SHF_MIPS_ADDR, ""),    ENUM_ENT(SHF_MIPS_STRING, "")};
+
+const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
+    ENUM_ENT(SHF_X86_64_LARGE, "l")};
+
+struct Field {
+  std::string Str;
+  unsigned Column;
+
+  Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {}
+  Field(unsigned Col) : Column(Col) {}
+};
+
+inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
+                        StringRef Str2) {
+  OS.PadToColumn(2u);
+  OS << Str1;
+  OS.PadToColumn(37u);
+  OS << Str2 << "\n";
+  OS.flush();
+}
+
+inline void printField(formatted_raw_ostream &OS, struct Field F) {
+  if (F.Column != 0)
+    OS.PadToColumn(F.Column);
+  OS << F.Str;
+  OS.flush();
+}
+
+inline std::vector<EnumEntry<unsigned>>
+getSectionFlagsForTarget(unsigned EMachine) {
+  std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags),
+                                       std::end(ElfSectionFlags));
+  switch (EMachine) {
+  case EM_ARM:
+    Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags),
+               std::end(ElfARMSectionFlags));
+    break;
+  case EM_HEXAGON:
+    Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags),
+               std::end(ElfHexagonSectionFlags));
+    break;
+  case EM_MIPS:
+    Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags),
+               std::end(ElfMipsSectionFlags));
+    break;
+  case EM_X86_64:
+    Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags),
+               std::end(ElfX86_64SectionFlags));
+    break;
+  case EM_XCORE:
+    Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags),
+               std::end(ElfXCoreSectionFlags));
+    break;
+  default:
+    break;
+  }
+  return Ret;
+}
+
+inline std::string getGNUFlags(unsigned EMachine, uint64_t Flags) {
+  // Here we are trying to build the flags string in the same way as GNU does.
+  // It is not that straightforward. Imagine we have sh_flags == 0x90000000.
+  // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000.
+  // GNU readelf will not print "E" or "Ep" in this case, but will print just
+  // "p". It only will print "E" when no other processor flag is set.
+  std::string Str;
+  bool HasUnknownFlag = false;
+  bool HasOSFlag = false;
+  bool HasProcFlag = false;
+  std::vector<EnumEntry<unsigned>> FlagsList =
+      getSectionFlagsForTarget(EMachine);
+  while (Flags) {
+    // Take the least significant bit as a flag.
+    uint64_t Flag = Flags & -Flags;
+    Flags -= Flag;
+
+    // Find the flag in the known flags list.
+    auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) {
+      // Flags with empty names are not printed in GNU style output.
+      return E.Value == Flag && !E.AltName.empty();
+    });
+    if (I != FlagsList.end()) {
+      Str += I->AltName;
+      continue;
+    }
+
+    // If we did not find a matching regular flag, then we deal with an OS
+    // specific flag, processor specific flag or an unknown flag.
+    if (Flag & ELF::SHF_MASKOS) {
+      HasOSFlag = true;
+      Flags &= ~ELF::SHF_MASKOS;
+    } else if (Flag & ELF::SHF_MASKPROC) {
+      HasProcFlag = true;
+      // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE
+      // bit if set so that it doesn't also get printed.
+      Flags &= ~ELF::SHF_MASKPROC;
+    } else {
+      HasUnknownFlag = true;
+    }
+  }
+
+  // "o", "p" and "x" are printed last.
+  if (HasOSFlag)
+    Str += "o";
+  if (HasProcFlag)
+    Str += "p";
+  if (HasUnknownFlag)
+    Str += "x";
+  return Str;
+}
+
+// Print the offset of a particular section from anyone of the ranges:
+// [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER].
+// If 'Type' does not fall within any of those ranges, then a string is
+// returned as '<unknown>' followed by the type value.
+inline std::string getSectionTypeOffsetString(unsigned Type) {
+  if (Type >= SHT_LOOS && Type <= SHT_HIOS)
+    return "LOOS+0x" + to_hexString(Type - SHT_LOOS);
+  else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC)
+    return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC);
+  else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER)
+    return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER);
+  return "0x" + to_hexString(Type) + ": <unknown>";
+}
+
+std::string getSectionTypeString(unsigned Machine, unsigned Type) {
+  StringRef Name = object::getELFSectionTypeName(Machine, Type);
+
+  // Handle SHT_GNU_* type names.
+  if (Name.startswith("SHT_GNU_")) {
+    if (Name == "SHT_GNU_HASH")
+      return "GNU_HASH";
+    // E.g. SHT_GNU_verneed -> VERNEED.
+    return Name.drop_front(8).upper();
+  }
+
+  if (Name == "SHT_SYMTAB_SHNDX")
+    return "SYMTAB SECTION INDICES";
+
+  if (Name.startswith("SHT_"))
+    return Name.drop_front(4).str();
+  return getSectionTypeOffsetString(Type);
+}
+
+void printSectionDescription(formatted_raw_ostream &OS, unsigned EMachine) {
+  OS << "Key to Flags:\n";
+  OS << "  W (write), A (alloc), X (execute), M (merge), S (strings), I "
+        "(info),\n";
+  OS << "  L (link order), O (extra OS processing required), G (group), T "
+        "(TLS),\n";
+  OS << "  C (compressed), x (unknown), o (OS specific), E (exclude),\n";
+  OS << "  R (retain)";
+
+  if (EMachine == EM_X86_64)
+    OS << ", l (large)";
+  else if (EMachine == EM_ARM)
+    OS << ", y (purecode)";
+
+  OS << ", p (processor specific)\n";
+}
+} // namespace ELF
+} // namespace llvm
+
+#endif

llvm/tools/llvm-readobj/ELFDumper.cpp

 //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the ELF-specific dumper for llvm-readobj.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "ELFDumper.h"
 #include "ARMEHABIPrinter.h"
 #include "DwarfCFIEHPrinter.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Demangle/Demangle.h"
-#include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocationResolver.h"
 #include "llvm/Object/StackMapParser.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/ARMAttributeParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MipsABIFlags.h"
 #include "llvm/Support/RISCVAttributeParser.h"
 #include "llvm/Support/RISCVAttributes.h"
-#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace ELF;
 
-#define LLVM_READOBJ_ENUM_CASE(ns, enum)                                       \
-  case ns::enum:                                                               \
-    return #enum;
-
-#define ENUM_ENT(enum, altName)                                                \
-  { #enum, altName, ELF::enum }
-
-#define ENUM_ENT_1(enum)                                                       \
-  { #enum, #enum, ELF::enum }
-
 namespace {
 
 template <class ELFT> struct RelSymbol {
   RelSymbol(const typename ELFT::Sym *S, StringRef N)
       : Sym(S), Name(N.str()) {}
   const typename ELFT::Sym *Sym;
   std::string Name;
 };
public:
   void printStackSizes() override;
 
 private:
   void printHashHistogram(const Elf_Hash &HashTable);
   void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable);
   void printHashTableSymbols(const Elf_Hash &HashTable);
   void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable);
 
-  struct Field {
-    std::string Str;
-    unsigned Column;
-
-    Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {}
-    Field(unsigned Col) : Column(Col) {}
-  };
-
   template <typename T, typename TEnum>
   std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) const {
     for (const EnumEntry<TEnum> &EnumItem : EnumValues)
       if (EnumItem.Value == Value)
         return std::string(EnumItem.AltName);
     return to_hexString(Value, false);
   }
 
for (const EnumEntry<TEnum> &Flag : EnumValues) {
         if (!Str.empty())
           Str += ", ";
         Str += Flag.AltName;
       }
     }
     return Str;
   }
 
-  formatted_raw_ostream &printField(struct Field F) const {
-    if (F.Column != 0)
-      OS.PadToColumn(F.Column);
-    OS << F.Str;
-    OS.flush();
-    return OS;
-  }
   void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex,
                          DataRegion<Elf_Word> ShndxTable, StringRef StrTable,
                          uint32_t Bucket);
   void printRelrReloc(const Elf_Relr &R) override;
   void printRelRelaReloc(const Relocation<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym) override;
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    DataRegion<Elf_Word> ShndxTable,

 
 static const char *getGroupType(uint32_t Flag) {
   if (Flag & ELF::GRP_COMDAT)
     return "COMDAT";
   else
     return "(unknown)";
 }
 
-static const EnumEntry<unsigned> ElfSectionFlags[] = {
-  ENUM_ENT(SHF_WRITE,            "W"),
-  ENUM_ENT(SHF_ALLOC,            "A"),
-  ENUM_ENT(SHF_EXECINSTR,        "X"),
-  ENUM_ENT(SHF_MERGE,            "M"),
-  ENUM_ENT(SHF_STRINGS,          "S"),
-  ENUM_ENT(SHF_INFO_LINK,        "I"),
-  ENUM_ENT(SHF_LINK_ORDER,       "L"),
-  ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
-  ENUM_ENT(SHF_GROUP,            "G"),
-  ENUM_ENT(SHF_TLS,              "T"),
-  ENUM_ENT(SHF_COMPRESSED,       "C"),
-  ENUM_ENT(SHF_GNU_RETAIN,       "R"),
-  ENUM_ENT(SHF_EXCLUDE,          "E"),
-};
-
-static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
-  ENUM_ENT(XCORE_SHF_CP_SECTION, ""),
-  ENUM_ENT(XCORE_SHF_DP_SECTION, "")
-};
-
-static const EnumEntry<unsigned> ElfARMSectionFlags[] = {
-  ENUM_ENT(SHF_ARM_PURECODE, "y")
-};
-
-static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
-  ENUM_ENT(SHF_HEX_GPREL, "")
-};
-
-static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
-  ENUM_ENT(SHF_MIPS_NODUPES, ""),
-  ENUM_ENT(SHF_MIPS_NAMES,   ""),
-  ENUM_ENT(SHF_MIPS_LOCAL,   ""),
-  ENUM_ENT(SHF_MIPS_NOSTRIP, ""),
-  ENUM_ENT(SHF_MIPS_GPREL,   ""),
-  ENUM_ENT(SHF_MIPS_MERGE,   ""),
-  ENUM_ENT(SHF_MIPS_ADDR,    ""),
-  ENUM_ENT(SHF_MIPS_STRING,  "")
-};
-
-static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
-  ENUM_ENT(SHF_X86_64_LARGE, "l")
-};
-
-static std::vector<EnumEntry<unsigned>>
-getSectionFlagsForTarget(unsigned EMachine) {
-  std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags),
-                                       std::end(ElfSectionFlags));
-  switch (EMachine) {
-  case EM_ARM:
-    Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags),
-               std::end(ElfARMSectionFlags));
-    break;
-  case EM_HEXAGON:
-    Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags),
-               std::end(ElfHexagonSectionFlags));
-    break;
-  case EM_MIPS:
-    Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags),
-               std::end(ElfMipsSectionFlags));
-    break;
-  case EM_X86_64:
-    Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags),
-               std::end(ElfX86_64SectionFlags));
-    break;
-  case EM_XCORE:
-    Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags),
-               std::end(ElfXCoreSectionFlags));
-    break;
-  default:
-    break;
-  }
-  return Ret;
-}
-
-static std::string getGNUFlags(unsigned EMachine, uint64_t Flags) {
-  // Here we are trying to build the flags string in the same way as GNU does.
-  // It is not that straightforward. Imagine we have sh_flags == 0x90000000.
-  // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000.
-  // GNU readelf will not print "E" or "Ep" in this case, but will print just
-  // "p". It only will print "E" when no other processor flag is set.
-  std::string Str;
-  bool HasUnknownFlag = false;
-  bool HasOSFlag = false;
-  bool HasProcFlag = false;
-  std::vector<EnumEntry<unsigned>> FlagsList =
-      getSectionFlagsForTarget(EMachine);
-  while (Flags) {
-    // Take the least significant bit as a flag.
-    uint64_t Flag = Flags & -Flags;
-    Flags -= Flag;
-
-    // Find the flag in the known flags list.
-    auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) {
-      // Flags with empty names are not printed in GNU style output.
-      return E.Value == Flag && !E.AltName.empty();
-    });
-    if (I != FlagsList.end()) {
-      Str += I->AltName;
-      continue;
-    }
-
-    // If we did not find a matching regular flag, then we deal with an OS
-    // specific flag, processor specific flag or an unknown flag.
-    if (Flag & ELF::SHF_MASKOS) {
-      HasOSFlag = true;
-      Flags &= ~ELF::SHF_MASKOS;
-    } else if (Flag & ELF::SHF_MASKPROC) {
-      HasProcFlag = true;
-      // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE
-      // bit if set so that it doesn't also get printed.
-      Flags &= ~ELF::SHF_MASKPROC;
-    } else {
-      HasUnknownFlag = true;
-    }
-  }
-
-  // "o", "p" and "x" are printed last.
-  if (HasOSFlag)
-    Str += "o";
-  if (HasProcFlag)
-    Str += "p";
-  if (HasUnknownFlag)
-    Str += "x";
-  return Str;
-}
-
 static StringRef segmentTypeToString(unsigned Arch, unsigned Type) {
   // Check potentially overlapped processor-specific program header type.
   switch (Arch) {
   case ELF::EM_ARM:
     switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX); }
     break;
   case ELF::EM_MIPS:
   case ELF::EM_MIPS_RS3_LE:
void ELFDumper<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
   if (!Target)
     reportUniqueWarning("unable to print relocation " + Twine(RelIndex) +
                         " in " + describe(Sec) + ": " +
                         toString(Target.takeError()));
   else
     printRelRelaReloc(R, *Target);
 }
 
-static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
-                               StringRef Str2) {
-  OS.PadToColumn(2u);
-  OS << Str1;
-  OS.PadToColumn(37u);
-  OS << Str2 << "\n";
-  OS.flush();
-}
-
 template <class ELFT>
 static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj,
                                               StringRef FileName) {
   const typename ELFT::Ehdr &ElfHeader = Obj.getHeader();
   if (ElfHeader.e_shnum != 0)
     return to_string(ElfHeader.e_shnum);
 
   Expected<ArrayRef<typename ELFT::Shdr>> ArrOrErr = Obj.sections();
void GNUELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
   Fields[2].Str = RelocName.c_str();
 
   if (RelSym.Sym)
     Fields[3].Str =
         to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width));
 
   Fields[4].Str = std::string(RelSym.Name);
   for (const Field &F : Fields)
-    printField(F);
+    printField(OS, F);
 
   std::string Addend;
   if (Optional<int64_t> A = R.Addend) {
     int64_t RelAddend = *A;
     if (!RelSym.Name.empty()) {
       if (RelAddend < 0) {
         Addend = " - ";
         RelAddend = std::abs(RelAddend);
OS << "\nRelocation section '" << Name << "' at offset 0x"
        << " entries:\n";
     printRelocHeaderFields<ELFT>(OS, Sec.sh_type);
     this->printRelocationsHelper(Sec);
   }
   if (!HasRelocSections)
     OS << "\nThere are no relocations in this file.\n";
 }
 
-// Print the offset of a particular section from anyone of the ranges:
-// [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER].
-// If 'Type' does not fall within any of those ranges, then a string is
-// returned as '<unknown>' followed by the type value.
-static std::string getSectionTypeOffsetString(unsigned Type) {
-  if (Type >= SHT_LOOS && Type <= SHT_HIOS)
-    return "LOOS+0x" + to_hexString(Type - SHT_LOOS);
-  else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC)
-    return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC);
-  else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER)
-    return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER);
-  return "0x" + to_hexString(Type) + ": <unknown>";
-}
-
-static std::string getSectionTypeString(unsigned Machine, unsigned Type) {
-  StringRef Name = getELFSectionTypeName(Machine, Type);
-
-  // Handle SHT_GNU_* type names.
-  if (Name.startswith("SHT_GNU_")) {
-    if (Name == "SHT_GNU_HASH")
-      return "GNU_HASH";
-    // E.g. SHT_GNU_verneed -> VERNEED.
-    return Name.drop_front(8).upper();
-  }
-
-  if (Name == "SHT_SYMTAB_SHNDX")
-    return "SYMTAB SECTION INDICES";
-
-  if (Name.startswith("SHT_"))
-    return Name.drop_front(4).str();
-  return getSectionTypeOffsetString(Type);
-}
-
-static void printSectionDescription(formatted_raw_ostream &OS,
-                                    unsigned EMachine) {
-  OS << "Key to Flags:\n";
-  OS << "  W (write), A (alloc), X (execute), M (merge), S (strings), I "
-        "(info),\n";
-  OS << "  L (link order), O (extra OS processing required), G (group), T "
-        "(TLS),\n";
-  OS << "  C (compressed), x (unknown), o (OS specific), E (exclude),\n";
-  OS << "  R (retain)";
-
-  if (EMachine == EM_X86_64)
-    OS << ", l (large)";
-  else if (EMachine == EM_ARM)
-    OS << ", y (purecode)";
-
-  OS << ", p (processor specific)\n";
-}
-
 template <class ELFT> void GNUELFDumper<ELFT>::printSectionHeaders() {
   unsigned Bias = ELFT::Is64Bits ? 0 : 8;
   ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
   OS << "There are " << to_string(Sections.size())
      << " section headers, starting at offset "
      << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n";
   OS << "Section Headers:\n";
   Field Fields[11] = {
       {"[Nr]", 2},        {"Name", 7},        {"Type", 25},
       {"Address", 41},    {"Off", 58 - Bias}, {"Size", 65 - Bias},
       {"ES", 72 - Bias},  {"Flg", 75 - Bias}, {"Lk", 79 - Bias},
       {"Inf", 82 - Bias}, {"Al", 86 - Bias}};
   for (const Field &F : Fields)
-    printField(F);
+    printField(OS, F);
   OS << "\n";
 
   StringRef SecStrTable;
   if (Expected<StringRef> SecStrTableOrErr =
           this->Obj.getSectionStringTable(Sections, this->WarningHandler))
     SecStrTable = *SecStrTableOrErr;
   else
     this->reportUniqueWarning(SecStrTableOrErr.takeError());
for (const Elf_Shdr &Sec : Sections) {
     Fields[7].Str = getGNUFlags(this->Obj.getHeader().e_machine, Sec.sh_flags);
     Fields[8].Str = to_string(Sec.sh_link);
     Fields[9].Str = to_string(Sec.sh_info);
     Fields[10].Str = to_string(Sec.sh_addralign);
 
     OS.PadToColumn(Fields[0].Column);
     OS << "[" << right_justify(Fields[0].Str, 2) << "]";
     for (int i = 1; i < 7; i++)
-      printField(Fields[i]);
+      printField(OS, Fields[i]);
     OS.PadToColumn(Fields[7].Column);
     OS << right_justify(Fields[7].Str, 3);
     OS.PadToColumn(Fields[8].Column);
     OS << right_justify(Fields[8].Str, 2);
     OS.PadToColumn(Fields[9].Column);
     OS << right_justify(Fields[9].Str, 3);
     OS.PadToColumn(Fields[10].Column);
     OS << right_justify(Fields[10].Str, 2);
void GNUELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
   }
 
   Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0;
   Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex, ShndxTable);
 
   Fields[7].Str = this->getFullSymbolName(Symbol, SymIndex, ShndxTable,
                                           StrTable, IsDynamic);
   for (const Field &Entry : Fields)
-    printField(Entry);
+    printField(OS, Entry);
   OS << "\n";
 }
 
 template <class ELFT>
 void GNUELFDumper<ELFT>::printHashedSymbol(const Elf_Sym *Symbol,
                                            unsigned SymIndex,
                                            DataRegion<Elf_Word> ShndxTable,
                                            StringRef StrTable,
Fields[5].Str =
       printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
   Fields[6].Str =
       printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities));
   Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable);
   Fields[8].Str =
       this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true);
 
   for (const Field &Entry : Fields)
-    printField(Entry);
+    printField(OS, Entry);
   OS << "\n";
 }
 
 template <class ELFT>
 void GNUELFDumper<ELFT>::printSymbols(bool PrintSymbols,
                                       bool PrintDynamicSymbols) {
   if (!PrintSymbols && !PrintDynamicSymbols)
     return;
template <class ELFT> void GNUELFDumper<ELFT>::printSectionDetails() {
   OS << "There are " << to_string(Sections.size())
      << " section headers, starting at offset "
      << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n";
 
   OS << "Section Headers:\n";
 
   auto PrintFields = [&](ArrayRef<Field> V) {
     for (const Field &F : V)
-      printField(F);
+      printField(OS, F);
     OS << "\n";
   };
 
   PrintFields({{"[Nr]", 2}, {"Name", 7}});
 
   constexpr bool Is64 = ELFT::Is64Bits;
   PrintFields({{"Type", 7},
                {Is64 ? "Address" : "Addr", 23},
for (const Elf_Phdr &Phdr : *PhdrsOrErr) {
     Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8));
     Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width));
     Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width));
     Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth));
     Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth));
     Fields[6].Str = printPhdrFlags(Phdr.p_flags);
     Fields[7].Str = to_string(format_hex(Phdr.p_align, 1));
     for (const Field &F : Fields)
-      printField(F);
+      printField(OS, F);
     if (Phdr.p_type == ELF::PT_INTERP) {
       OS << "\n";
       auto ReportBadInterp = [&](const Twine &Msg) {
         this->reportUniqueWarning(
             "unable to read program interpreter name at offset 0x" +
             Twine::utohexstr(Phdr.p_offset) + ": " + Msg);
       };
 
template <class ELFT> void GNUELFDumper<ELFT>::printAddrsig() {
   OS << "   Num: Name\n";
 
   Field Fields[2] = {0, 8};
   size_t SymIndex = 0;
   for (uint64_t Sym : *SymsOrErr) {
     Fields[0].Str = to_string(format_decimal(++SymIndex, 6)) + ":";
     Fields[1].Str = this->getStaticSymbolName(Sym);
     for (const Field &Entry : Fields)
-      printField(Entry);
+      printField(OS, Entry);
     OS << "\n";
   }
 }
 
 template <typename ELFT>
 static std::string getGNUProperty(uint32_t Type, uint32_t DataSize,
                                   ArrayRef<uint8_t> Data) {
   std::string str;

llvm/tools/llvm-readobj/ObjDumper.h

 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 
 #include <memory>
 #include <system_error>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FormattedStream.h"
 
 #include <unordered_set>
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
 class XCOFFObjectFile;