[WIP][LLD] Add output section printout

[ayermolo]

Summary

When debugging relocation overflow it is useful to know sizes of output sections, etc.
I added a way to print out same way that llvm-readelf does it.
For now I put it under verbose flag.
This can be split in to two commits. One refactor ELFDumper, and another LLD.
For now keeping it as one to get some feedback if community wants this, etc.

[MaskRay]

I don't think we need this. We have D75966 (-M).

[jhenderson]

I agree with @MaskRay: does the map file solve the problem for you?

[ayermolo]

Well print-map does have size and address information scattered throughout what is potentially quite a large output. I think it will be useful to have a summary that can be quickly referenced with all the information in one place.
Maybe split the difference and add it as part of -print-map as a summary that gets printed before?

[jhenderson]

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

[ayermolo]

In D94141#2483728, @jhenderson wrote:

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

Sure. From memory, as I was doing it last year.
I was looking in to relocation R_X86_64_DTPOFF32 out of range issue in the unknown code base in an older version of llvm. I don't quite remember all the details at this point, but it It was useful to see what the layout was produced at a glance, what each section address, and size was. Similar to what llvm-readelf -sections outputs. Specifically as it related to .tdata/.tbss. The original theory was that maybe one of them was growing too large or linker script was messing with layout. The output, redirected to file, of print-map for that build is around 2GB. The size of each section can be just searched. Figuring out how everything laid out would require a script. I thought that having lld output summary would benefit others also, so they don't have to write a script to parse out that from output of print-map.

[MaskRay]

In D94141#2487960, @ayermolo wrote:

In D94141#2483728, @jhenderson wrote:

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

Sure. From memory, as I was doing it last year.
I was looking in to relocation R_X86_64_DTPOFF32 out of range issue in the unknown code base in an older version of llvm. I don't quite remember all the details at this point, but it It was useful to see what the layout was produced at a glance, what each section address, and size was. Similar to what llvm-readelf -sections outputs. Specifically as it related to .tdata/.tbss. The original theory was that maybe one of them was growing too large or linker script was messing with layout. The output, redirected to file, of print-map for that build is around 2GB. The size of each section can be just searched. Figuring out how everything laid out would require a script. I thought that having lld output summary would benefit others also, so they don't have to write a script to parse out that from output of print-map.

You can use ld.lld ... -M | sed -En '/\w+ +\w+ +\w+ \S/p'

I have seen #include "\.\./ occasionally within a top-level llvm-project directory, but I don't think cross top-level directory should be allowed.

[ayermolo]

In D94141#2488729, @MaskRay wrote:

In D94141#2487960, @ayermolo wrote:

In D94141#2483728, @jhenderson wrote:

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

Sure. From memory, as I was doing it last year.
I was looking in to relocation R_X86_64_DTPOFF32 out of range issue in the unknown code base in an older version of llvm. I don't quite remember all the details at this point, but it It was useful to see what the layout was produced at a glance, what each section address, and size was. Similar to what llvm-readelf -sections outputs. Specifically as it related to .tdata/.tbss. The original theory was that maybe one of them was growing too large or linker script was messing with layout. The output, redirected to file, of print-map for that build is around 2GB. The size of each section can be just searched. Figuring out how everything laid out would require a script. I thought that having lld output summary would benefit others also, so they don't have to write a script to parse out that from output of print-map.

You can use ld.lld ... -M | sed -En '/\w+ +\w+ +\w+ \S/p'

I have seen #include "\.\./ occasionally within a top-level llvm-project directory, but I don't think cross top-level directory should be allowed.

Thank you for sed command.
I tried it on output and it partially cleaned up output, there is still quite a bit of "typeinfo name for".
Probably command can be modified, but I think fundamentally this comes back to the same thing. Other users of lld need to know how to use sed, and if they are say on windows find alternative or write a parsing script.
This is an opt-in option that provides a better usage experience so that others don't need to re-invent the wheel.
Just a thought.

[MaskRay]

In D94141#2491909, @ayermolo wrote:

In D94141#2488729, @MaskRay wrote:

In D94141#2487960, @ayermolo wrote:

In D94141#2483728, @jhenderson wrote:

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

Sure. From memory, as I was doing it last year.
I was looking in to relocation R_X86_64_DTPOFF32 out of range issue in the unknown code base in an older version of llvm. I don't quite remember all the details at this point, but it It was useful to see what the layout was produced at a glance, what each section address, and size was. Similar to what llvm-readelf -sections outputs. Specifically as it related to .tdata/.tbss. The original theory was that maybe one of them was growing too large or linker script was messing with layout. The output, redirected to file, of print-map for that build is around 2GB. The size of each section can be just searched. Figuring out how everything laid out would require a script. I thought that having lld output summary would benefit others also, so they don't have to write a script to parse out that from output of print-map.

You can use ld.lld ... -M | sed -En '/\w+ +\w+ +\w+ \S/p'

I have seen #include "\.\./ occasionally within a top-level llvm-project directory, but I don't think cross top-level directory should be allowed.

Thank you for sed command.
I tried it on output and it partially cleaned up output, there is still quite a bit of "typeinfo name for".
Probably command can be modified, but I think fundamentally this comes back to the same thing. Other users of lld need to know how to use sed, and if they are say on windows find alternative or write a parsing script.
This is an opt-in option that provides a better usage experience so that others don't need to re-invent the wheel.
Just a thought.

We accept new features very cautiously. Adding an option has maintenance costs and recognition cost if some options have overlapping features. You can dig up the history for previous options. They need to show values to the community. For this one, I don't think it provides any additional benefit and can just confuse users as it duplicates --print-map/-M. If you want the output, add --noinhibit-exec and inspect the output with readelf -S.

[ayermolo]

In D94141#2491925, @MaskRay wrote:

In D94141#2491909, @ayermolo wrote:

In D94141#2488729, @MaskRay wrote:

In D94141#2487960, @ayermolo wrote:

In D94141#2483728, @jhenderson wrote:

Could you give a step-by-step example of how you might use the information you want to emit? That will help us ensure that any proposals satisfy the requirements (or possibly to suggest an alternative).

Sure. From memory, as I was doing it last year.
I was looking in to relocation R_X86_64_DTPOFF32 out of range issue in the unknown code base in an older version of llvm. I don't quite remember all the details at this point, but it It was useful to see what the layout was produced at a glance, what each section address, and size was. Similar to what llvm-readelf -sections outputs. Specifically as it related to .tdata/.tbss. The original theory was that maybe one of them was growing too large or linker script was messing with layout. The output, redirected to file, of print-map for that build is around 2GB. The size of each section can be just searched. Figuring out how everything laid out would require a script. I thought that having lld output summary would benefit others also, so they don't have to write a script to parse out that from output of print-map.

You can use ld.lld ... -M | sed -En '/\w+ +\w+ +\w+ \S/p'

I have seen #include "\.\./ occasionally within a top-level llvm-project directory, but I don't think cross top-level directory should be allowed.

Thank you for sed command.
I tried it on output and it partially cleaned up output, there is still quite a bit of "typeinfo name for".
Probably command can be modified, but I think fundamentally this comes back to the same thing. Other users of lld need to know how to use sed, and if they are say on windows find alternative or write a parsing script.
This is an opt-in option that provides a better usage experience so that others don't need to re-invent the wheel.
Just a thought.

We accept new features very cautiously. Adding an option has maintenance costs and recognition cost if some options have overlapping features. You can dig up the history for previous options. They need to show values to the community. For this one, I don't think it provides any additional benefit and can just confuse users as it duplicates --print-map/-M. If you want the output, add --noinhibit-exec and inspect the output with readelf -S.

Ok, thanks for feedback/explanation.

[ayermolo]

@MaskRay saw you marking this as "Needs revision", is that just a general way of not accepting diff?

[MaskRay]

Needs Revision is a way to make a patch not show up in reviewers' review queue, and to prevent making the patch "green" if another reviewer accepts it. It could mean the patch needs substantial change or the reviewer has substantial objection.
To save your time, I has a strong objection to the idea, given the fact that we have accepted an alternative D94560 and there are various approaches tackling with the problem.

[ayermolo]

Gotcha, thanks. Yeah I abandoned it on my end.

lld/ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
+#include "../../llvm/tools/llvm-readobj/ELFDumper.h"
 #include "AArch64ErrataFix.h"
 #include "ARMErrataFix.h"
 #include "CallGraphSort.h"
 #include "Config.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <climits>
 
 #define DEBUG_TYPE "lld"
if (in.symTab)
     add(in.symTab);
   if (in.symTabShndx)
     add(in.symTabShndx);
   add(in.shStrTab);
   if (in.strTab)
     add(in.strTab);
 }
 
+struct Field {
+  std::string Str;
+  unsigned Column;
+
+  Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {}
+  Field(unsigned Col) : Column(Col) {}
+};
+
+static void printField(struct Field F, formatted_raw_ostream &OS) {
+  if (F.Column != 0)
+    OS.PadToColumn(F.Column);
+  OS << F.Str;
+  OS.flush();
+  ;
+}
+
+void static printSectionInfo() {
+  if (!errorHandler().verbose)
+    return;
+  unsigned Bias = config->is64 ? 0 : 8;
+  ScopedPrinter W(fouts());
+  auto &OS = static_cast<formatted_raw_ostream &>(W.getOStream());
+  OS << "Section Headers:\n";
+  OS.flush();
+
+  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 auto &F : Fields) {
+    printField(F, OS);
+  }
+  OS << "\n";
+  for (const OutputSection *out : outputSections) {
+    Fields[0].Str = to_string(out->sectionIndex);
+    Fields[1].Str = out->name.str();
+    Fields[2].Str = getSectionTypeString(config->emachine, out->type);
+    Fields[3].Str =
+        to_string(format_hex_no_prefix(out->addr, config->is64 ? 16 : 8));
+    Fields[4].Str = to_string(format_hex_no_prefix(out->offset, 6));
+    Fields[5].Str = to_string(format_hex_no_prefix(out->size, 6));
+    Fields[6].Str = to_string(format_hex_no_prefix(out->entsize, 2));
+    Fields[7].Str = getGNUFlags(config->emachine, out->flags);
+    Fields[8].Str = to_string(out->link);
+    Fields[9].Str = to_string(out->info);
+    Fields[10].Str = to_string(out->alignment);
+
+    OS.PadToColumn(Fields[0].Column);
+    OS << "[" << right_justify(Fields[0].Str, 2) << "]";
+    for (int i = 1; i < 7; i++)
+      printField(Fields[i], OS);
+    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);
+    OS << "\n";
+  }
+}
+
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   copyLocalSymbols();
 
   if (config->copyRelocs)
     addSectionSymbols();
 
   // Now that we have a complete set of output sections. This function
   // completes section contents. For example, we need to add strings
   // to the string table, and add entries to .got and .plt.
   // finalizeSections does that.
   finalizeSections();
+  printSectionInfo();
   checkExecuteOnly();
   if (errorCount())
     return;
 
   // If -compressed-debug-sections is specified, we need to compress
   // .debug_* sections. Do it right now because it changes the size of
   // output sections.
   for (OutputSection *sec : outputSections)

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_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")};
+
+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>";
+}
+
+inline 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);
+}
+
+inline 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";
+
+  if (EMachine == EM_X86_64)
+    OS << "  l (large), ";
+  else if (EMachine == EM_ARM)
+    OS << "  y (purecode), ";
+  else
+    OS << "  ";
+
+  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> class DumpStyle;
 
 template <class ELFT> struct RelSymbol {
   RelSymbol(const typename ELFT::Sym *S, StringRef N)
       : Sym(S), Name(N.str()) {}
   const typename ELFT::Sym *Sym;

 
 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_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:
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";
-
-  if (EMachine == EM_X86_64)
-    OS << "  l (large), ";
-  else if (EMachine == EM_ARM)
-    OS << "  y (purecode), ";
-  else
-    OS << "  ";
-
-  OS << "p (processor specific)\n";
-}
-
 template <class ELFT> void GNUStyle<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] = {

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;