[llvm-readobj] Allow printing of the watermark note section proposed in D66426

[chrisjackson]

Summary

This revision separates the changes to readobj that enable the watermark note section to be dumped. See D66426.

readobj can also compute the watermark hash. This computed value can then be checked against the value dumped from the proposed .note.llvm.watermark section.

[chrisjackson]

Added --compute-watermark, additional tests, use of library from update to D66426.

[chrisjackson]

Removed library test accidentally added in last update.

[jhenderson]

I've not looked at the code here yet. I'll do that once there's a consensus on D66426.

llvm/test/tools/llvm-readobj/elf-watermark.test

1

Assembly tests should have a '.s' extension. Also, since this is using X86_64 assembly, it needs a REQUIRES: x86. Finally, please rebase this change (there have been significant changes to the test directory structure recently).

6

LLD can't be used in an llvm-readobj test I'm afraid (it is not required to build check-llvm). You'll need a different way to setup this test somehow, or possibly this should be moved into the LLD testing if no sensible way can be come up with. One option might be to pre-calculate the watermark for a given set of content and use yaml2obj to generate the file with that watermark in it.

7

-check-prefix -> --check-prefix (also below)

10

Minor nit: add extra spacing to make the value being checked line up with the following lines.

llvm/test/tools/llvm-readobj/note-llvm.test

1

This test's name is note-llvm.test, but the test is specifically about the watermark note?

3–4

This part feels like it's more generically "notes can be dumped after --strip-sections has been used". Why is the watermark here special?

6

General consensus is to use -o rather than shell redirection in new tests.

Also --docnum.

41

Nit: too many blank lines

43

Same as above.

76

Same as above.

The comment related to this section should be moved to here.

114–115

The spacing looks all off here. Either remove excessive spacing so that it all lines up, or add --strict-whitespace to show that you're testing the latter.

[chrisjackson]

This revision will soon be abandoned along with D66426, unless there are any further comments.

llvm/test/tools/llvm-readobj/elf-watermark.test

+## Test that we can calculate and print the loadable segment watermark for an
+## elf file and ensure this watermark matches that computed by lld.
+## lld writes the watermark to a ".note.llvm.watermark" section which is placed
+## in a PT_NOTE segment.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld --watermark %t -o %t.watermark
+# RUN: llvm-readelf -x .note.llvm.watermark %t.watermark | FileCheck --strict-whitespace -check-prefix=DUMP %s
+# RUN: llvm-readobj --compute-watermark %t.watermark | FileCheck --strict-whitespace -check-prefix=COMPUTE %s
+
+# DUMP: Hex dump of section '.note.llvm.watermark':
+# DUMP-NEXT: 05000000 0c000000 04000000 4c4c564d ............LLVM
+# DUMP-NEXT: 00000000 01000000 f9ceaa42 d8d7016d ...........B...m
+
+# COMPUTE:      Computed loadable segments watermark {
+# COMPUTE-NEXT: Version: 1
+# COMPUTE-NEXT: Value: 0x6D01D7D842AACEF9
+
+.globl _start
+_start:
+nop

llvm/test/tools/llvm-readobj/note-llvm.test

+## Test tools are able to dump the LLVM Watermark note section. Also test the
+## output when the type field is incorrect.
+## Show also that if the watermark is mapped to a PT_NOTE segment that the
+## watermark can be dumped even if llvm-objcopy --strip-sections has been used.
+
+# RUN: yaml2obj -docnum=1 %s > %t1.o
+# RUN: llvm-readobj --notes %t1.o | FileCheck %s --check-prefix=LLVM
+# RUN: llvm-readelf --notes %t1.o | FileCheck %s --check-prefix=GNU
+
+# LLVM:      Notes [
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Offset: 0x40
+# LLVM-NEXT:     Size: 0x20
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: LLVM
+# LLVM-NEXT:       Data size: 0xC
+# LLVM-NEXT:       Type: NT_LLVM_WATERMARK (Loadable sections watermark)
+# LLVM-NEXT:       Version: 01000000
+# LLVM-NEXT:       Watermark: 45e69f81a671eaac
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]
+
+# GNU:      Displaying notes found at file offset 0x00000040 with length 0x00000020:
+# GNU-NEXT: Owner                Data size    Description
+# GNU-NEXT: LLVM                 0x0000000c       NT_LLVM_WATERMARK (Loadable sections watermark)
+# GNU-NEXT:    LLVM Watermark: 45e69f81a671eaac Version: 0x01000000
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .note.llvm.watermark
+    Type:         SHT_NOTE
+    AddressAlign: 0x0000000000000004
+    Size:         32
+    Content:      050000000c000000040000004c4c564d000000000100000045e69f81a671eaac
+
+
+# RUN: yaml2obj -docnum=2 %s > %t2.o
+# RUN: llvm-readobj --notes %t2.o | FileCheck %s --check-prefix=LLVM_UNKNOWNTYPE
+# RUN: llvm-readelf --notes %t2.o | FileCheck %s --check-prefix=GNU_UNKNOWNTYPE
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .note.llvm.watermark
+    Type:         SHT_NOTE
+    AddressAlign: 0x0000000000000004
+    Size:         32
+    Content: 050000000c000000ff0000004c4c564d000000000100000045e69f81a671eaac
+
+# LLVM_UNKNOWNTYPE:      Notes [
+# LLVM_UNKNOWNTYPE-NEXT:  NoteSection {
+# LLVM_UNKNOWNTYPE-NEXT:    Offset: 0x40
+# LLVM_UNKNOWNTYPE-NEXT:    Size: 0x20
+# LLVM_UNKNOWNTYPE-NEXT:    Note {
+# LLVM_UNKNOWNTYPE-NEXT:      Owner: LLVM
+# LLVM_UNKNOWNTYPE-NEXT:      Data size: 0xC
+# LLVM_UNKNOWNTYPE-NEXT:      Type: Unknown note type (0x000000ff)
+# LLVM_UNKNOWNTYPE-NEXT:     }
+# LLVM_UNKNOWNTYPE-NEXT:   }
+# LLVM_UNKNOWNTYPE-NEXT: ]
+
+# GNU_UNKNOWNTYPE:      Displaying notes found at file offset 0x00000040 with length 0x00000020:
+# GNU_UNKNOWNTYPE-NEXT: Owner                Data size        Description
+# GNU_UNKNOWNTYPE-NEXT: LLVM                 0x0000000c       Unknown note type (0x000000ff)
+
+# RUN: yaml2obj -docnum=3 %s > %t3.o
+# RUN: llvm-objcopy --strip-sections %t3.o %t3.stripped.o
+# RUN: llvm-readobj --notes %t3.stripped.o | FileCheck %s --check-prefix=LLVM_STRIPPED
+# RUN: llvm-readelf --notes %t3.stripped.o | FileCheck %s --check-prefix=GNU_STRIPPED
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+  Entry:   0x0000000000400000
+Sections:
+  - Name:         .note.llvm.watermark
+    Type:         SHT_NOTE
+    AddressAlign: 0x0000000000000004
+    Size:         32
+    Content:      050000000c000000040000004c4c564d0000000001000000beeeeeeeeeeeeeef
+ProgramHeaders:
+  - Type:     PT_NOTE
+    Sections:
+      - Section: .note.llvm.watermark
+
+# LLVM_STRIPPED:      Notes [
+# LLVM_STRIPPED-NEXT:   NoteSection {
+# LLVM_STRIPPED-NEXT:     Offset: 0x40
+# LLVM_STRIPPED-NEXT:     Size: 0x20
+# LLVM_STRIPPED-NEXT:     Note {
+# LLVM_STRIPPED-NEXT:       Owner: LLVM
+# LLVM_STRIPPED-NEXT:       Data size: 0xC
+# LLVM_STRIPPED-NEXT:       Type: NT_LLVM_WATERMARK (Loadable sections watermark)
+# LLVM_STRIPPED-NEXT:       Version: 01000000
+# LLVM_STRIPPED-NEXT:       Watermark: beeeeeeeeeeeeeef
+# LLVM_STRIPPED-NEXT:     }
+# LLVM_STRIPPED-NEXT:   }
+# LLVM_STRIPPED-NEXT: ]
+
+# GNU_STRIPPED:      Displaying notes found at file offset 0x00000040 with length 0x00000020:
+# GNU_STRIPPED-NEXT: Owner                Data size    Description
+# GNU_STRIPPED-NEXT: LLVM                 0x0000000c       NT_LLVM_WATERMARK (Loadable sections watermark)
+# GNU_STRIPPED-NEXT:    LLVM Watermark: beeeeeeeeeeeeeef Version: 0x01000000

llvm/tools/llvm-readobj/ELFDumper.cpp

 #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/Object/Watermark.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"
public:
 
   void printCGProfile() override;
   void printAddrsig() override;
 
   void printNotes() override;
 
   void printELFLinkerOptions() override;
   void printStackSizes() override;
+  void printWatermark() override;
 
   const object::ELFObjectFile<ELFT> *getElfObject() const { return ObjF; };
 
 private:
   std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
 
   TYPEDEF_ELF_TYPES(ELFT)
 
public:
   virtual void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                              const Elf_Shdr *Sec) = 0;
   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
   virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0;
   virtual void printAddrsig(const ELFFile<ELFT> *Obj) = 0;
   virtual void printNotes(const ELFFile<ELFT> *Obj) = 0;
   virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0;
   virtual void printStackSizes(const ELFObjectFile<ELFT> *Obj) = 0;
+  virtual void printWatermark(const ELFObjectFile<ELFT> *Obj) = 0;
   void printNonRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj,
                                      std::function<void()> PrintHeader);
   void printRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj,
                                   std::function<void()> PrintHeader);
   void printFunctionStackSize(const ELFObjectFile<ELFT> *Obj, uint64_t SymValue,
                               SectionRef FunctionSec,
                               const StringRef SectionName, DataExtractor Data,
                               uint64_t *Offset);
void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printStackSizes(const ELFObjectFile<ELFT> *Obj) override;
   void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
+  void printWatermark(const ELFObjectFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) override;
 
 private:
   struct Field {
     std::string Str;
     unsigned Column;
void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printStackSizes(const ELFObjectFile<ELFT> *Obj) override;
   void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
+  void printWatermark(const ELFObjectFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
   void printSymbols(const ELFO *Obj);

 template <class ELFT> void ELFDumper<ELFT>::printELFLinkerOptions() {
   ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile());
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printStackSizes() {
   ELFDumperStyle->printStackSizes(ObjF);
 }
 
+template <class ELFT> void ELFDumper<ELFT>::printWatermark() {
+  ELFDumperStyle->printWatermark(ObjF);
+}
+
 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum)                                 \
   { #enum, prefix##_##enum }
 
 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
if (Note.ID == NT)
       return std::string(Note.Name);
 
   std::string string;
   raw_string_ostream OS(string);
   OS << format("Unknown note type (0x%08x)", NT);
   return OS.str();
 }
 
+static std::string getLLVMNoteTypeName(const uint32_t NT) {
+  if (NT == NT_LLVM_WATERMARK)
+    return std::string("NT_LLVM_WATERMARK (Loadable sections watermark)");
+
+  std::string string;
+  raw_string_ostream OS(string);
+  OS << format("Unknown note type (0x%08x)", NT);
+  return OS.str();
+}
+
 static std::string getFreeBSDNoteTypeName(const uint32_t NT) {
   static const struct {
     uint32_t ID;
     const char *Name;
   } Notes[] = {
       {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"},
       {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"},
       {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"},
case ELF::NT_AMDGPU_METADATA: {
     raw_string_ostream StrOS(HSAMetadataString);
     MsgPackDoc.toYAML(StrOS);
 
     return {"AMDGPU Metadata", StrOS.str()};
   }
   }
 }
 
+template <typename ELFT>
+static void printLLVMWatermarkLLVMStyle(uint32_t NoteType,
+                                        ArrayRef<uint8_t> Desc,
+                                        ScopedPrinter &W) {
+  if (NoteType != NT_LLVM_WATERMARK)
+    return;
+
+  // Currently there is only one version of the watermark and it has a hash size
+  // of 8.
+  auto Version = StringRef(reinterpret_cast<const char *>(Desc.data()), 4);
+  auto Hash = StringRef(reinterpret_cast<const char *>(Desc.data() + 4), 8);
+  W.printString("Version", toHex(Version, true));
+  W.printString("Watermark", toHex(Hash, true));
+}
+
+template <typename ELFT>
+static void printLLVMWatermark(raw_ostream &OS, uint32_t NoteType,
+                               ArrayRef<uint8_t> Desc) {
+  if (NoteType != NT_LLVM_WATERMARK)
+    return;
+
+  // Currently there is only one version of the watermark and it has a hash size
+  // of 8.
+  auto Version = StringRef(reinterpret_cast<const char *>(Desc.data()), 4);
+  auto Hash = StringRef(reinterpret_cast<const char *>(Desc.data() + 4), 8);
+  OS << "    LLVM Watermark: " << toHex(Hash, true) << "    Version: 0x"
+     << toHex(Version);
+}
+
 struct CoreFileMapping {
   uint64_t Start, End, Offset;
   StringRef Filename;
 };
 
 struct CoreNote {
   uint64_t PageSize;
   std::vector<CoreFileMapping> Mappings;
auto ProcessNote = [&](const Elf_Note &Note) {
     if (Name == "GNU") {
       OS << getGNUNoteTypeName(Type) << '\n';
     } else if (Name == "FreeBSD") {
       OS << getFreeBSDNoteTypeName(Type) << '\n';
     } else if (Name == "AMD") {
       OS << getAMDNoteTypeName(Type) << '\n';
     } else if (Name == "AMDGPU") {
       OS << getAMDGPUNoteTypeName(Type) << '\n';
+    } else if (Name == "LLVM") {
+      OS << getLLVMNoteTypeName(Type) << '\n';
     } else {
       StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
                                ? getCoreNoteTypeName(Type)
                                : getGenericNoteTypeName(Type);
       if (!NoteType.empty())
         OS << NoteType << '\n';
       else
         OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n";
if (Name == "GNU") {
                                     ELFT::TargetEndianness == support::little,
                                     sizeof(Elf_Addr));
         Expected<CoreNote> Note = readCoreNote(DescExtractor);
         if (Note)
           printCoreNote<ELFT>(OS, *Note);
         else
           reportWarning(Note.takeError(), this->FileName);
       }
+    } else if (Name == "LLVM") {
+      printLLVMWatermark<ELFT>(OS, Type, Descriptor);
     } else if (!Descriptor.empty()) {
       OS << "   description data:";
       for (uint8_t B : Descriptor)
         OS << " " << format("%02x", B);
       OS << '\n';
     }
   };
 
for (const auto &P :
       for (const auto &Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   }
 }
 
+// Calculate the loadable sections watermark. If the file contains
+// a watermark section this can be viewed with --notes.
+template <class ELFT>
+static Expected<std::vector<uint8_t>>
+computeWatermark(StringRef FileName, const ELFObjectFile<ELFT> *Obj, watermark::Watermarker& W) {
+  llvm::ArrayRef<ELFT::Phdr> pHdrs =
+      unwrapOrError(FileName, Obj->getELFFile()->program_headers());
+
+  std::vector<watermark::Segment> segmentInfo =
+      W.extractSegmentInfo<ELFT::Phdr>(pHdrs);
+  if (segmentInfo.empty())
+    return createError(
+        "unable to compute watermark because no PT_LOAD segments were found");
+
+  size_t programHeaderTableOffset = 0;
+  size_t programHeaderTableSize = 0;
+  auto pHdrIt = std::find_if(pHdrs.begin(), pHdrs.end(), [](ELFT::Phdr pHdr) {
+    return pHdr.p_type == PT_PHDR;
+  });
+
+  if (pHdrIt != pHdrs.end()) {
+    programHeaderTableOffset = pHdrIt->p_offset;
+    programHeaderTableSize = pHdrIt->p_filesz;
+  }
+
+  return W.computeWatermark(
+      segmentInfo, sizeof(typename ELFT::Ehdr), programHeaderTableOffset,
+      programHeaderTableSize, Obj->getELFFile()->base());
+}
+
+template <class ELFT>
+void GNUStyle<ELFT>::printWatermark(const ELFObjectFile<ELFT> *Obj) {
+  watermark::Watermarker W;
+  std::vector<uint8_t> watermark =
+      unwrapOrError(this->FileName, computeWatermark(this->FileName, Obj, W));
+  uint64_t *watermarkVal = (uint64_t *)watermark.data();
+  OS << "Computed loadable segments watermark\n";
+  OS << "Version";
+  OS.PadToColumn(10);
+  OS << "Value\n";
+  OS << W.getVersion();
+  OS.PadToColumn(10);
+  OS << to_hexString(*watermarkVal);
+}
+
+template <class ELFT>
+void LLVMStyle<ELFT>::printWatermark(const ELFObjectFile<ELFT> *Obj) {
+  watermark::Watermarker M;
+  std::vector<uint8_t> watermark =
+      unwrapOrError(this->FileName, computeWatermark(this->FileName, Obj, M));
+  uint64_t *watermarkVal = (uint64_t *)watermark.data();
+  DictScope SS(W, "Computed loadable segments watermark");
+  {
+    W.printNumber("Version", M.getVersion());
+    W.printHex("Value", *watermarkVal);
+  }
+}
+
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
 // Used for printing section names in places where possible errors can be
 // ignored.
 static StringRef getSectionName(const SectionRef &Sec) {
auto ProcessNote = [&](const Elf_Note &Note) {
     if (Name == "GNU") {
       W.printString("Type", getGNUNoteTypeName(Type));
     } else if (Name == "FreeBSD") {
       W.printString("Type", getFreeBSDNoteTypeName(Type));
     } else if (Name == "AMD") {
       W.printString("Type", getAMDNoteTypeName(Type));
     } else if (Name == "AMDGPU") {
       W.printString("Type", getAMDGPUNoteTypeName(Type));
+    } else if (Name == "LLVM") {
+      W.printString("Type", getLLVMNoteTypeName(Type));
     } else {
       StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
                                ? getCoreNoteTypeName(Type)
                                : getGenericNoteTypeName(Type);
       if (!NoteType.empty())
         W.printString("Type", NoteType);
       else
         W.printString("Type",
if (Name == "GNU") {
                                     ELFT::TargetEndianness == support::little,
                                     sizeof(Elf_Addr));
         Expected<CoreNote> Note = readCoreNote(DescExtractor);
         if (Note)
           printCoreNoteLLVMStyle(*Note, W);
         else
           reportWarning(Note.takeError(), this->FileName);
       }
+    } else if (Name == "LLVM") {
+      printLLVMWatermarkLLVMStyle<ELFT>(Type, Descriptor, W);
     } else if (!Descriptor.empty()) {
       W.printBinaryBlock("Description data", Descriptor);
     }
   };
 
   ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
     for (const auto &S : Sections) {

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistogram() {}
   virtual void printCGProfile() {}
   virtual void printAddrsig() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
   virtual void printStackSizes() {}
+  virtual void printWatermark() {}
   virtual void printArchSpecificInfo() { }
 
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }
   virtual void printCOFFExports() { }
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
   virtual void printCOFFDebugDirectory() { }

llvm/tools/llvm-readobj/llvm-readobj.cpp

cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
                              cl::aliasopt(Relocations), cl::NotHidden);
   cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
                            cl::aliasopt(Relocations));
 
   // --notes, -n
   cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"));
   cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes));
 
+  // --compute-watermark, -cw
+  cl::opt<bool> ComputeWatermark("compute-watermark", cl::desc("Compute the loadable sections watermark"));
+  cl::alias ComputeWatermarkShort("cw", cl::desc("Alias for --compute-watermark"), cl::aliasopt(ComputeWatermark));
+
   // --dyn-relocations
   cl::opt<bool> DynRelocs("dyn-relocations",
     cl::desc("Display the dynamic relocation entries in the file"));
 
   // --symbols
   // Also -s in llvm-readelf mode, or -t in llvm-readobj mode.
   cl::opt<bool>
       Symbols("symbols",
if (Obj->isELF()) {
     if (opts::HashHistogram)
       Dumper->printHashHistogram();
     if (opts::CGProfile)
       Dumper->printCGProfile();
     if (opts::Addrsig)
       Dumper->printAddrsig();
     if (opts::Notes)
       Dumper->printNotes();
+    if(opts::ComputeWatermark)
+      Dumper->printWatermark();
   }
   if (Obj->isCOFF()) {
     if (opts::COFFImports)
       Dumper->printCOFFImports();
     if (opts::COFFExports)
       Dumper->printCOFFExports();
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();