[MTE] [llvm-readobj] Add globals section parsing to --memtag

[hctim]

Summary

Global variables are described in a metadata table called
SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC. It's basically a ULEB-encoded skip
list with some other fancy encoding tricks to make it smaller. You can
see the ABI at
https://github.com/ARM-software/abi-aa/blob/main/memtagabielf64/memtagabielf64.rst#83encoding-of-sht_aarch64_memtag_globals_dynamic

This extends readelf/readobj to understand these sections.

[jhenderson]

llvm/lib/ObjectYAML/ELFYAML.cpp

711–712

Could you please check to see if the other machine-specific section types have any specific YAML testing, please? (Usually in the form of a yaml2obj lit test, but could be in obj2yaml lit tests or ObjectYAML unit tests).

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

150

Honestly, I'm finding this comment incomprehensible (possibly because I know nothing about memtags). What is it trying to show?

llvm/tools/llvm-readobj/ELFDumper.cpp

5230

This seems unrelated?

5257

Can you use the new C++17 structured bindings to name both first and second values here, rather than just doing Descriptors.first and Descriptors.second, please?

5258–5259

You don't need the llvm:: prefixes here.

5913

Are you sure cantFail is appropriate here? What happens if the sh_offset field of the section is invalid? In fact, if you're using cantFail, why are you storing the result in an Expected?

5915–5916

This isn't how errors or warnings are reported in llvm-readobj. Please take a look at other examples and fix appropriately. (You probably want reportUniqueWarning)

5927–5928

These aren't named in compliance with LLVM's naming scheme.

5966–5969

See above re. errors and warnings in llvm-readobj.

Also please refer to https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

5976

I not i.

5983–5984

As above.

5995–5996

As above

7409

Drop llvm::. Also, the std::string construction is unnecessary. Also, consider using Twine here and in other string concatenation places.

[MaskRay]

(I'm going to be out for 3 weeks in the next 4 weeks. Happy if others are happy. Don't wait on me :) )

llvm/tools/llvm-readobj/ELFDumper.cpp

5974

Delete blank line.

Also, add a link to the ABI doc describing the encoding scheme?

7409

std::string("0x") => "0x" as llvm::utohexstr returns a std::string.

printHex takes a StringRef, so Twine cannot be used (without toStringRef).

[hctim]

Address jhenderson@'s comments.

llvm/lib/ObjectYAML/ELFYAML.cpp

711–712

sure, added bits to machine-specific-section-types.test

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

150

I've tried to flesh out the comments so that it's clear that this is the hand-asembling of the .memtag.globals.dynamic section contents. HTH.

llvm/tools/llvm-readobj/ELFDumper.cpp

5230

It's a slight formatting fix that I found during this patch. There's an extra unnecessary newline between the Android note (if present) and the

Given that this is all --memtag related parsing, seems right to clean up this spurious newline while we're adding more text.

5913

yeah, i reckon the cantFail wrapping here was vestigial. removed.

7409

dropped the namespace prefix and explicit construction of 0x, but yeah, can't use twine here unfortunately

[jhenderson]

This is going to need review by somebody with memtag experience still.

Meanwhile, I think some test cases are needed for a few of the warnings.

llvm/tools/llvm-readobj/ELFDumper.cpp

5913

I don't think this is tested?

5981

Test case?

5993

Test case?

[hctim]

llvm/tools/llvm-readobj/ELFDumper.cpp

5913

this isn't really testable here; getSectionContents() has a few failure conditions but none of them are really memtag-relevant.

i have however added a check that the address of the SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section is the same as the DT_AARCH64_MEMTAG_GLOBALS dynamic table entry, and tested it.

[hctim]

Add some extra edge case tests.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

321

I think you need to check the context of the message to show that the right warning is being emitted (since there are two possible locations where this could come from). This will make the test less at risk of rotting in the future too.

llvm/tools/llvm-readobj/ELFDumper.cpp

5913

We should still have a test that shows that if getSectionContents fails, we handle the failure appropriately. The easiest way of doing this is probably to simply override the sh_offset value of the section, using the ShOffset YAML key. There are a number of good examples of things like this in llvm-readobj tests. A simple one is in stackmap.test, where the same YAML is used, but with the yaml2obj -D option used to provide a specific sh_offset value for one test case that is for the equivalent of what you're checking here.

[hctim]

Add more tests for edge cases in decoding.

llvm/tools/llvm-readobj/ELFDumper.cpp

5913

thanks for the handy link to stackmap.test, done.

[jhenderson]

No more comments from me, as aside from one minor suggestion in the test.

It probably needs a review from someone familiar with the memtag encoding though, as I'm not.

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

313

I don't think we have the same line length expectations in lit tests, so I personally wouldn't split the messages across multiple checks like this, due to the fact they have a slight difference in behaviour. However, I don't have a strong opinion on it, so if you prefer it this way, that's fine. I would make it a CHECK-SAME directive though (and if you do that, I'd add some spaces before "warning" to make the second CHECK's contents line up with the first one i.e.

# BAD-STREAM1:      warning: ...
# BAD-STREAM1-SAME: SHT_...

Same comment applies below.

[pcc]

LGTM

[hctim]

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

313

sure, done, in submit.

llvm/lib/ObjectYAML/ELFYAML.cpp

case ELF::EM_MIPS:
     ECase(SHT_MIPS_ABIFLAGS);
     break;
   case ELF::EM_RISCV:
     ECase(SHT_RISCV_ATTRIBUTES);
     break;
   case ELF::EM_MSP430:
     ECase(SHT_MSP430_ATTRIBUTES);
     break;
+  case ELF::EM_AARCH64:
+    ECase(SHT_AARCH64_MEMTAG_GLOBALS_STATIC);
+    ECase(SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);
+    break;
   default:
     // Nothing to do.
     break;
   }
 #undef ECase
   IO.enumFallback<Hex32>(Value);
 }
 

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

 # NOSTACK-SAME: AARCH64_MEMTAG_STACK
 # NOSTACK-SAME: Disabled (0)
 
 # INVALID:      0x000000007000000{{[cC]}}
 # INVALID-SAME: AARCH64_MEMTAG_STACK
 # INVALID-SAME: Unknown (2)
 
 # LLVM:  0x000000007000000D AARCH64_MEMTAG_GLOBALS   0xdeadbeef
-# LLVM:  0x000000007000000F AARCH64_MEMTAG_GLOBALSSZ 1234
+# LLVM:  0x000000007000000F AARCH64_MEMTAG_GLOBALSSZ 15
 
 # GNU: 0x000000007000000d (AARCH64_MEMTAG_GLOBALS)   0xdeadbeef0
-# GNU: 0x000000007000000f (AARCH64_MEMTAG_GLOBALSSZ) 1234
+# GNU: 0x000000007000000f (AARCH64_MEMTAG_GLOBALSSZ) 15
 
 # GNU:          Displaying notes found in: .note.android.memtag
 # GNU-NEXT:     Owner    Data size   Description
 # GNU-OK-NEXT:  Android  0x00000004  NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)
 # GNU-BAD-NEXT: Android  0x00000000  NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {

 # SYNC:    AARCH64_MEMTAG_MODE: Synchronous (0)
 # ASYNC:   AARCH64_MEMTAG_MODE: Asynchronous (1)
 # HEAP:    AARCH64_MEMTAG_HEAP: Enabled (1)
 # NOHEAP:  AARCH64_MEMTAG_HEAP: Disabled (0)
 # STACK:   AARCH64_MEMTAG_STACK: Enabled (1)
 # NOSTACK: AARCH64_MEMTAG_STACK: Disabled (0)
 # LLVM:    AARCH64_MEMTAG_GLOBALS: 0xdeadbeef0
 # GNU:     AARCH64_MEMTAG_GLOBALS: 0xdeadbeef0
-# LLVM:    AARCH64_MEMTAG_GLOBALSSZ: 1234
-# GNU:     AARCH64_MEMTAG_GLOBALSSZ: 1234
+# LLVM:    AARCH64_MEMTAG_GLOBALSSZ: 15
+# GNU:     AARCH64_MEMTAG_GLOBALSSZ: 15
 
 # LLVM-OK: Memtag Android Note
 # GNU-OK:  Memtag Android Note
 
 # SYNC:    Tagging Mode: SYNC
 # ASYNC:   Tagging Mode: ASYNC
 # UNKNOWN: Tagging Mode: Unknown (3)
 # HEAP:    Heap: Enabled
 # NOHEAP:  Heap: Disabled
 # STACK:   Stack: Enabled
 # NOSTACK: Stack: Disabled
 
+## https://github.com/ARM-software/abi-aa/blob/main/memtagabielf64/memtagabielf64.rst#83encoding-of-sht_aarch64_memtag_globals_dynamic
+## 16 bytes at 0xdead0000 (0xdead0000 bytes, skip == 0xdead000 granules)
+##  -> /* skip */ (0xdead000 << 3) + /* size in granules */ 1
+##   -> 0x6f568001
+##   => 0x81 0x80 0xda 0xfa 0x06
+## 32 bytes at 0xdead0010 (adjacent)
+##  -> /* skip */ (0 << 3) + /* size in granules */ 2
+##  => 0x02
+## 64 bytes     at 0xdead0100 (0xdead0100 - 0xdead0010 - 32 == 0xd0 bytes, skip == 0xd granules)
+##  -> /* skip */ (0xd << 3) + /* size in granules */ 4
+##   -> 0x6c
+##   => 0x6c
+## 0x1000 bytes at 0xdeadf000 (0xdeadf000 - 0xdead0100 - 64 == 0xeec0 bytes, skip == 0xeec granules)
+##  -> /* skip */ (0xeec << 3) + /* size won't fit in reserved bits */ 0
+##  => 0xe0 0xee 0x01
+##  -> /* size in granules (minus 1) */ 0x100 - 1
+##  => 0xff 0x01
+## 16 bytes at 0xdeae0000 (adjacent)
+##  -> /* skip */ (0 << 3) + /* size in granules */ 1
+##  => 0x01
+## 16 bytes at 0xdeae0010 (adjacent)
+##  => 0x01
+## 16 bytes at 0xdeaef020 (adjacent)
+##  => 0x01
+
+# LLVM-OK:      Memtag Global Descriptors: [
+# LLVM-OK-NEXT:    0xDEAD0000: 0x10
+# LLVM-OK-NEXT:    0xDEAD0010: 0x20
+# LLVM-OK-NEXT:    0xDEAD0100: 0x40
+# LLVM-OK-NEXT:    0xDEADF000: 0x1000
+# LLVM-OK-NEXT:    0xDEAE0000: 0x10
+# LLVM-OK-NEXT:    0xDEAE0010: 0x10
+# LLVM-OK-NEXT:    0xDEAE0020: 0x10
+# LLVM-OK-NEXT: ]
+# GNU-OK:       Memtag Global Descriptors:
+# GNU-OK-NEXT:     0xdead0000: 0x10
+# GNU-OK-NEXT:     0xdead0010: 0x20
+# GNU-OK-NEXT:     0xdead0100: 0x40
+# GNU-OK-NEXT:     0xdeadf000: 0x1000
+# GNU-OK-NEXT:     0xdeae0000: 0x10
+# GNU-OK-NEXT:     0xdeae0010: 0x10
+# GNU-OK-NEXT:     0xdeae0020: 0x10
+# GNU-OK-NOT:   {{.}}
+
 #########################################
 ## --docnum=1 (default)
 #########################################
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
Entries:
         Value: [[MODE]]
       - Tag:   DT_AARCH64_MEMTAG_HEAP
         Value: [[HEAP]]
       - Tag:   DT_AARCH64_MEMTAG_STACK
         Value: [[STACK]]
       - Tag:   DT_AARCH64_MEMTAG_GLOBALS
         Value: 0xdeadbeef0
       - Tag:   DT_AARCH64_MEMTAG_GLOBALSSZ
-        Value: 1234
+        Value: 15
       - Tag:   DT_INIT_ARRAY
         Value: 0x1000
+  - Name:            .memtag.globals.dynamic
+    Type:            SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0xdeadbeef
+    AddressAlign:    0x4
+    Content:         8180DAFA06026CE0EE01ff01010101
+
+#########################################
+## Ensure the header is printed, even if there's no relevant dynamic entries,
+## and that nothing else is printed.
+#########################################
 
 # RUN: yaml2obj --docnum=2 %s -o %t
 # RUN: llvm-readelf --memtag %t | FileCheck %s --check-prefixes=MISSING-GNU
 # RUN: llvm-readobj --memtag %t | FileCheck %s --check-prefixes=MISSING-LLVM
 
-## Ensure the header is printed, even if there's no relevant dynamic entries,
-## and that nothing else is printed.
-
 # MISSING-GNU-NOT:  {{.}}
 # MISSING-GNU:      Memtag Dynamic Entries:
 # MISSING-GNU-NEXT: < none found >
 # MISSING-GNU-NOT:  {{.}}
 
 # MISSING-LLVM-NOT:  {{.}}
 # MISSING-LLVM:      File: {{.*}}memtag.test
 # MISSING-LLVM-NEXT: Format: elf64-littleaarch64
FileHeader:
   Type:    ET_DYN
   Machine: EM_AARCH64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_INIT_ARRAY
         Value: 0x1000
+
+#########################################
+## Ensure that we fail if DT_AARCH64_MEMTAG_GLOBALSSZ doesn't match the actual
+## section size.
+#########################################
+
+# RUN: yaml2obj --docnum=3 %s -o %t
+# RUN: llvm-readelf --memtag %t 2>&1 | FileCheck %s --check-prefixes=SIZE-MISMATCH
+# RUN: llvm-readobj --memtag %t 2>&1 | FileCheck %s --check-prefixes=SIZE-MISMATCH
+
+# SIZE-MISMATCH: Mismatch between DT_AARCH64_MEMTAG_GLOBALSSZ (0x1337) and
+# SIZE-MISMATCH: SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section size (0xa)
+
+#########################################
+## --docnum=3
+#########################################
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_AARCH64
+Sections:
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Entries:
+      - Tag:   DT_AARCH64_MEMTAG_MODE
+        Value: 0
+      - Tag:   DT_AARCH64_MEMTAG_HEAP
+        Value: 0
+      - Tag:   DT_AARCH64_MEMTAG_STACK
+        Value: 0
+      - Tag:   DT_AARCH64_MEMTAG_GLOBALS
+        Value: 0xdeadbeef0
+      - Tag:   DT_AARCH64_MEMTAG_GLOBALSSZ
+        Value: 0x1337
+  - Name:            .memtag.globals.dynamic
+    Type:            SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0xdeadbeef
+    AddressAlign:    0x4
+    Content:         12345678901234567890

llvm/tools/llvm-readobj/ELFDumper.cpp

virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                            bool NonVisibilityBitsUsed) const = 0;
 
   virtual void printMipsABIFlags() = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
 
   virtual void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
-      const ArrayRef<uint8_t> AndroidNoteDesc) = 0;
+      const ArrayRef<uint8_t> AndroidNoteDesc,
+      const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) = 0;
 
   Expected<ArrayRef<Elf_Versym>>
   getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab,
                   StringRef *StrTab, const Elf_Shdr **SymTabSec) const;
   StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;
 
   std::vector<GroupSection> getGroups();
 
public:
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
-      const ArrayRef<uint8_t> AndroidNoteDesc) override;
+      const ArrayRef<uint8_t> AndroidNoteDesc,
+      const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) 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 {
public:
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
-      const ArrayRef<uint8_t> AndroidNoteDesc) override;
+      const ArrayRef<uint8_t> AndroidNoteDesc,
+      const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) override;
 
 private:
   void printRelrReloc(const Elf_Relr &R) override;
   void printRelRelaReloc(const Relocation<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym) override;
 
   void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex,
                           DataRegion<Elf_Word> ShndxTable) const;

 static bool printAndroidNote(raw_ostream &OS, uint32_t NoteType,
                              ArrayRef<uint8_t> Desc) {
   // Return true if we were able to pretty-print the note, false otherwise.
   AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc);
   if (Props.empty())
     return false;
   for (const auto &KV : Props)
     OS << "    " << KV.first << ": " << KV.second << '\n';
-  OS << '\n';
   return true;
 }
 
 template <class ELFT>
 void GNUELFDumper<ELFT>::printMemtag(
     const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
-    const ArrayRef<uint8_t> AndroidNoteDesc) {
+    const ArrayRef<uint8_t> AndroidNoteDesc,
+    const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) {
   OS << "Memtag Dynamic Entries:\n";
   if (DynamicEntries.empty())
     OS << "    < none found >\n";
   for (const auto &DynamicEntryKV : DynamicEntries)
     OS << "    " << DynamicEntryKV.first << ": " << DynamicEntryKV.second
        << "\n";
 
   if (!AndroidNoteDesc.empty()) {
     OS << "Memtag Android Note:\n";
     printAndroidNote(OS, ELF::NT_ANDROID_TYPE_MEMTAG, AndroidNoteDesc);
   }
+
+  if (Descriptors.empty())
+    return;
+
+  OS << "Memtag Global Descriptors:\n";
+  for (const auto &Descriptor : Descriptors) {
+    OS << "    0x" << llvm::utohexstr(Descriptor.first, true) << ": 0x"
+       << llvm::utohexstr(Descriptor.second, true) << "\n";
+  }
 }
 
 template <typename ELFT>
 static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType,
                                     ArrayRef<uint8_t> Desc) {
   switch (NoteType) {
   default:
     return false;
auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error {
     }
     return Error::success();
   };
 
   processNotesHelper(*this, /*StartNotesFn=*/PrintHeader,
                      /*ProcessNoteFn=*/ProcessNote, /*FinishNotesFn=*/[]() {});
 }
 
+template <class ELFT>
+static ArrayRef<uint8_t>
+getMemtagGlobalsSectionContents(const ELFFile<ELFT> &File) {
+  for (const typename ELFT::Shdr &Sec : cantFail(File.sections())) {
+    if (Sec.sh_type != SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC)
+      continue;
+    Expected<ArrayRef<uint8_t>> Contents =
+        cantFail(File.getSectionContents(Sec));
+    if (auto E = Contents.takeError()) {
+      llvm::errs() << "Couldn't get SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section "
+                      "contents\n";
+      return ArrayRef<uint8_t>();
+    }
+    return Contents.get();
+  }
+  return ArrayRef<uint8_t>();
+}
+
+// Reserve the lower three bits of the first byte of the step distance when
+// encoding the memtag descriptors. Found to be the best overall size tradeoff
+// when compiling Android T with full MTE globals enabled.
+constexpr uint64_t kMemtagStepVarintReservedBits = 3;
+constexpr uint64_t kMemtagGranuleSize = 16;
+
 template <typename ELFT> void ELFDumper<ELFT>::printMemtag() {
   if (Obj.getHeader().e_machine != EM_AARCH64) return;
   std::vector<std::pair<std::string, std::string>> DynamicEntries;
+  size_t AndroidMemtagGlobalsSz = 0;
   for (const typename ELFT::Dyn &Entry : dynamic_table()) {
     uintX_t Tag = Entry.getTag();
     switch (Tag) {
+    case DT_AARCH64_MEMTAG_GLOBALSSZ:
+      AndroidMemtagGlobalsSz = Entry.getVal();
+      [[fallthrough]];
     case DT_AARCH64_MEMTAG_MODE:
     case DT_AARCH64_MEMTAG_HEAP:
     case DT_AARCH64_MEMTAG_STACK:
-    case DT_AARCH64_MEMTAG_GLOBALSSZ:
     case DT_AARCH64_MEMTAG_GLOBALS:
       DynamicEntries.emplace_back(Obj.getDynamicTagAsString(Tag),
                                   getDynamicEntry(Tag, Entry.getVal()));
     }
   }
 
   ArrayRef<uint8_t> AndroidNoteDesc;
   auto FindAndroidNote = [&](const Elf_Note &Note, bool IsCore) -> Error {
     if (Note.getName() == "Android" &&
         Note.getType() == ELF::NT_ANDROID_TYPE_MEMTAG)
       AndroidNoteDesc = Note.getDesc();
     return Error::success();
   };
 
   processNotesHelper(
       *this,
       /*StartNotesFn=*/
       [](std::optional<StringRef>, const typename ELFT::Off,
          const typename ELFT::Addr) {},
       /*ProcessNoteFn=*/FindAndroidNote, /*FinishNotesFn=*/[]() {});
 
-  printMemtag(DynamicEntries, AndroidNoteDesc);
+  ArrayRef<uint8_t> Contents = getMemtagGlobalsSectionContents(this->Obj);
+  if (Contents.size() != AndroidMemtagGlobalsSz) {
+    llvm::errs() << "Mismatch between DT_AARCH64_MEMTAG_GLOBALSSZ ("
+                 << format_hex(AndroidMemtagGlobalsSz, 0)
+                 << ") and SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section size ("
+                 << format_hex(Contents.size(), 0) << ")\n";
+    return;
+  }
+
+  std::vector<std::pair<uint64_t, uint64_t>> GlobalDescriptors;
+
+  uint64_t Address = 0;
+  for (size_t i = 0; i < Contents.size();) {
+    const char *Error = nullptr;
+    unsigned DecodedBytes = 0;
+    uint64_t Value = decodeULEB128(Contents.data() + i, &DecodedBytes,
+                                   Contents.end(), &Error);
+    i += DecodedBytes;
+    if (Error) {
+        llvm::errs() << "Error decoding SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC: \""
+                     << Twine(Error) << "\"\n";
+        break;
+    }
+    uint64_t Distance = Value >> kMemtagStepVarintReservedBits;
+    uint64_t GranulesToTag = Value & ((1 << kMemtagStepVarintReservedBits) - 1);
+    if (GranulesToTag == 0) {
+      GranulesToTag = decodeULEB128(Contents.data() + i, &DecodedBytes,
+                                    Contents.end(), &Error) +
+                      1;
+      i += DecodedBytes;
+      if (Error) {
+        llvm::errs() << "Error decoding SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC: \""
+                     << Twine(Error) << "\"\n";
+        break;
+      }
+    }
+    Address += Distance * kMemtagGranuleSize;
+    GlobalDescriptors.emplace_back(Address, GranulesToTag * kMemtagGranuleSize);
+    Address += GranulesToTag * kMemtagGranuleSize;
+  }
+
+  printMemtag(DynamicEntries, AndroidNoteDesc, GlobalDescriptors);
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printELFLinkerOptions() {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printDependentLibsHelper(
case ELF::NT_GNU_PROPERTY_TYPE_0:
     ListScope D(W, "Property");
     for (const std::string &Property : getGNUPropertyList<ELFT>(Desc))
       W.printString(Property);
     break;
   }
   return true;
 }
 
-static bool printAndroidNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
+static bool printAndroidNoteLLVMStyle(uint32_t NoteType,
+                                      ArrayRef<uint8_t> Desc,
                                       ScopedPrinter &W) {
   // Return true if we were able to pretty-print the note, false otherwise.
   AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc);
   if (Props.empty())
     return false;
   for (const auto &KV : Props)
     W.printString(KV.first, KV.second);
   return true;
 }
 
 template <class ELFT>
 void LLVMELFDumper<ELFT>::printMemtag(
     const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
-    const ArrayRef<uint8_t> AndroidNoteDesc) {
+    const ArrayRef<uint8_t> AndroidNoteDesc,
+    const ArrayRef<std::pair<uint64_t, uint64_t>> Descriptors) {
+  {
     ListScope L(W, "Memtag Dynamic Entries:");
     if (DynamicEntries.empty())
       W.printString("< none found >");
     for (const auto &DynamicEntryKV : DynamicEntries)
       W.printString(DynamicEntryKV.first, DynamicEntryKV.second);
+  }
 
   if (!AndroidNoteDesc.empty()) {
     ListScope L(W, "Memtag Android Note:");
     printAndroidNoteLLVMStyle(ELF::NT_ANDROID_TYPE_MEMTAG, AndroidNoteDesc, W);
   }
+
+  if (Descriptors.empty())
+    return;
+
+  {
+    ListScope L(W, "Memtag Global Descriptors:");
+    for (const auto &Descriptor : Descriptors) {
+      W.printHex(std::string("0x") + llvm::utohexstr(Descriptor.first),
+                Descriptor.second);
+    }
+  }
 }
 
 template <typename ELFT>
 static bool printLLVMOMPOFFLOADNoteLLVMStyle(uint32_t NoteType,
                                              ArrayRef<uint8_t> Desc,
                                              ScopedPrinter &W) {
   switch (NoteType) {
   default: