[ELF] Add --compress-sections

[MaskRay]

Summary

--compress-sections <section-glib>=[zlib|zstd] is like a generalized
--compress-debug-sections that applies to arbitrary sections, including
SHF_ALLOC ones. This option has a number of candidate use cases for metadata
sections, including:

• code coverage sections https://github.com/llvm/llvm-project/issues/48499
• __asan_globals section
• -fexperimental-sanitize-metadata= sections

For SHF_ALLOC use cases, a supporting runtime library can identify the section
content with a pair of symbols __start_<sectionname> and
__stop_<sectionname> and check the header to know whether it is compressed or
not. There are some caveats:

• We compute the section content/size once in finalizeAddressDependentContent before compression. If the content or size changes, the compressed content will be invalid, but we don't detect changed content (e.g., data commands). However, we detect size changes in assignOffsets.
• If there are dynamic relocations, rtld do not skip these relocations and will cause runtime crash or writable data corruption. In general, label differences should be used (see foo0 in the test) and the runtime library needs to adjust the differences.
• Symbols defined relative to the output section desginate the offsets to the uncompressed content.

In addition, compressing synthetic sections like .symtab/.strtab and regular
data/code sections will be problematic, but we don't report an error.

GNU ld feature request: https://sourceware.org/bugzilla/show_bug.cgi?id=27452

Link: https://discourse.llvm.org/t/rfc-compress-arbitrary-sections-with-ld-lld-compress-sections/71674
Link: https://groups.google.com/g/generic-abi/c/HUVhliUrTG0 ("Allow SHF_ALLOC | SHF_COMPRESSED sections")

[ikudrin]

The code overall looks OK, but am I understand it right that the discussion on the Generic System V ABI mailing list is not finished yet?

[ELF] Add --compress-ections

Please, don't forget to fix the typo in the title and in the first line of the description.

lld/ELF/OutputSections.cpp

333–338

461–463

The comment needs to be updated

lld/ELF/Writer.cpp

539–540

This comment should be removed

1618–1620

A few words about how this requirement is enforced would be great.

By the way, where does this requirement come from? Do you think that code sections shouldn't be compressed at all, or only those that need thunks or other fixes? Why?

[MaskRay]

thanks for the quick comments!

[MaskRay]

remove a stale comment

[MaskRay]

In D154641#4479022, @ikudrin wrote:

The code overall looks OK, but am I understand it right that the discussion on the Generic System V ABI mailing list is not finished yet?

Not finished yet. I think people have misunderstanding. foo0 and nonalloc0 in lld/test/ELF/compress-sections.s demonstrate possible metadata section uses.
write0 (dynamic relocations) is problematic and should be avoided.

[MaskRay]

Just created a write-up about the caveats of SHF_ALLOC|SHF_COMPRESSED sections and other things: https://maskray.me/blog/2023-07-07-compressed-arbitrary-sections :)

[peter.smith]

We compute the section content/size once in finalizeAddressDependentContent before compression. If the content or size changes, the compressed content will be invalid, but we don't detect changed content (e.g., data commands). However, we detect size changes in assignOffsets.

I guess this means that if the writeTo() has any relocations they won't work with compression. The presence of relocations or possibly use of one of the relocate functions could generate an error. It probably wouldn't be intuitive to a user, but would protect them from wasting hours wondering why their data was corrupt (I'm assuming few people read the documentation). Off the top of my head "Cannot compress <output section>, <input section> from <object> contains relocations."

In armlink which does read-write data compression, we have this rather complicated scheme:

• Allocate Final VMA Addresses, with predictions for LMA
• Filter out relocations (in non compressed sections) to linker defined symbols that depend on a compressed address, this is easier in armlink as linker defined symbols are heavily constrained.
• Resolve relocation
• Compress RW Data
• Allocate post compression addresses, VMA remain the same, LMA Addresses may change.
• Resolve the filtered relocations

This adds considerable complexity though.

Not had a chance to go through the code and tests yet, been a very busy week. Will try and do that as soon as possible.

[MaskRay]

In D154641#4479852, @peter.smith wrote:

We compute the section content/size once in finalizeAddressDependentContent before compression. If the content or size changes, the compressed content will be invalid, but we don't detect changed content (e.g., data commands). However, we detect size changes in assignOffsets.

I guess this means that if the writeTo() has any relocations they won't work with compression. The presence of relocations or possibly use of one of the relocate functions could generate an error. It probably wouldn't be intuitive to a user, but would protect them from wasting hours wondering why their data was corrupt (I'm assuming few people read the documentation). Off the top of my head "Cannot compress <output section>, <input section> from <object> contains relocations."

I agree. The current compressing once approach has a severe limitation and is error-prone. Worse, it does not consider thunks:

• The uncompressed section content decides the compressed section size.
• The compressed section size affects addresses of subsequent sections and symbol assignments. The affected sections include text sections that use range extension thunks.
• Subsequent sections and symbol assignments may affect the uncompressed section content. + PC-relative references to text sections (e.g., .quad .text.foo-.) change values when the text section address changes. + data commands in an output section description may change. + location counter increments (e.g., . += expr;) in an output section description may change.

SECTIONS {
  ...
  foo : { *(foo*) QUAD(expr1) . += expr2; }
}

In armlink which does read-write data compression, we have this rather complicated scheme:

• Allocate Final VMA Addresses, with predictions for LMA
• Filter out relocations (in non compressed sections) to linker defined symbols that depend on a compressed address, this is easier in armlink as linker defined symbols are heavily constrained.
• Resolve relocation
• Compress RW Data
• Allocate post compression addresses, VMA remain the same, LMA Addresses may change.
• Resolve the filtered relocations

This adds considerable complexity though.

Not had a chance to go through the code and tests yet, been a very busy week. Will try and do that as soon as possible.

I am curious how Final VMA Addresses are determined. Doesn't relocations in an uncompressed section content affect the compressed section size?

[peter.smith]

I am curious how Final VMA Addresses are determined. Doesn't relocations in an uncompressed section content affect the compressed section size?

In armlink the assumption is that all VMA operates on uncompressed data. With the decompressor running very early in the startup sequence so all running code only sees uncompressed data. Compressed data is only in LMA.

I guess LLD we are making life hard by having user code do the decompression on demand rather than insist that everything is done at once by startup code

In armlink scatter file notation:

ER_RO 0x8000 {
# all read-only sections
  *(+ro)
}
ER_RW 0x10000000 {
# all read-write sections, implicitly marked for compression
  *(+rw)
}
ER_ZI +0 {
# zero initialized data follows (in VMA) after compressed RW
}

The ER_RW load size depends on compression, but its run-time size is always the uncompressed size.

At startup, the first routine sets up a stack, usually using the space reserved for ZI, then it calls the routine to decompress all the data from LMA to VMA. User code can't easily get at the compressed data after that time.

lld/ELF/Config.h

struct Config {
   bool armCMSESupport = false;
   bool asNeeded = false;
   bool armBe8 = false;
   BsymbolicKind bsymbolic = BsymbolicKind::None;
   bool callGraphProfileSort;
   bool checkSections;
   bool checkDynamicRelocs;
   llvm::DebugCompressionType compressDebugSections;
+  llvm::SmallVector<std::pair<llvm::GlobPattern, llvm::DebugCompressionType>, 0>
+      compressSections;
   bool cref;
   llvm::SmallVector<std::pair<llvm::GlobPattern, uint64_t>, 0>
       deadRelocInNonAlloc;
   bool demangle = true;
   bool dependentLibraries;
   bool disableVerify;
   bool ehFrameHdr;
   bool emitLLVM;

lld/ELF/Driver.cpp

for (auto reportArg : reports) {
         error(Twine("-z ") + reportArg.first + "= parameter " + option.second +
               " is not recognized");
         continue;
       }
       *reportArg.second = option.second;
     }
   }
 
+  for (opt::Arg *arg : args.filtered(OPT_compress_sections)) {
+    SmallVector<StringRef, 0> fields;
+    StringRef(arg->getValue()).split(fields, '=');
+    if (fields.size() != 2 || fields[1].empty()) {
+      error(arg->getSpelling() +
+            ": parse error, not 'section-glob=[zlib|zstd]'");
+      continue;
+    }
+    auto type = getCompressionType(fields[1], arg->getSpelling());
+    if (Expected<GlobPattern> pat = GlobPattern::create(fields[0])) {
+      config->compressSections.emplace_back(std::move(*pat), type);
+    } else {
+      error(arg->getSpelling() + ": " + toString(pat.takeError()));
+      continue;
+    }
+  }
+
   for (opt::Arg *arg : args.filtered(OPT_z)) {
     std::pair<StringRef, StringRef> option =
         StringRef(arg->getValue()).split('=');
     if (option.first != "dead-reloc-in-nonalloc")
       continue;
     constexpr StringRef errPrefix = "-z dead-reloc-in-nonalloc=: ";
     std::pair<StringRef, StringRef> kv = option.second.split('=');
     if (kv.first.empty() || kv.second.empty()) {

lld/ELF/LinkerScript.cpp

if (sec->lmaExpr) {
     state->lmaOffset = 0;
   }
 
   // Propagate state->lmaOffset to the first "non-header" section.
   if (PhdrEntry *l = sec->ptLoad)
     if (sec == findFirstSection(l))
       l->lmaOffset = state->lmaOffset;
 
+  const uint64_t savedDot2 = dot;
+  const size_t savedSize = sec->size;
   // We can call this method multiple times during the creation of
   // thunks and want to start over calculation each time.
   sec->size = 0;
 
   // We visited SectionsCommands from processSectionCommands to
   // layout sections. Now, we visit SectionsCommands again to fix
   // section offsets.
   for (SectionCommand *cmd : sec->commands) {
for (InputSection *isec : cast<InputSectionDescription>(cmd)->sections) {
 
       // Update output section size after adding each section. This is so that
       // SIZEOF works correctly in the case below:
       // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
       expandOutputSection(dot - pos);
     }
   }
 
+  // See the comment in finalizeAddressDependentContent.
+  if (sec->compressed.shards) {
+    if (sec->size != sec->compressed.uncompressedSize)
+      fatal("uncompressed size of SHF_COMPRESSED section '" + sec->name +
+            "' is dependent on linker script commands");
+    sec->size = savedSize;
+    dot = savedDot2 + savedSize;
+  }
+
   // Non-SHF_ALLOC sections do not affect the addresses of other OutputSections
   // as they are not part of the process image.
   if (!(sec->flags & SHF_ALLOC)) {
     dot = savedDot;
   } else if (isTbss) {
     // NOBITS TLS sections are similar. Additionally save the end address.
     state->tbssAddr = dot;
     dot = savedDot;

lld/ELF/Options.td

 defm check_sections: B<"check-sections",
     "Check section addresses for overlaps (default)",
     "Do not check section addresses for overlaps">;
 
 defm compress_debug_sections:
   Eq<"compress-debug-sections", "Compress DWARF debug sections">,
   MetaVarName<"[none,zlib,zstd]">;
 
+defm compress_sections: EEq<"compress-sections", "Compress output sections matching <section-glob>">,
+  MetaVarName<"<section-glob>=[zlib|zstd]">;
+
 defm defsym: Eq<"defsym", "Define a symbol alias">, MetaVarName<"<symbol>=<value>">;
 
 defm optimize_bb_jumps: BB<"optimize-bb-jumps",
     "Remove direct jumps at the end to the next basic block",
     "Do not remove any direct jumps at the end to the next basic block (default)">;
 
 defm fortran_common : BB<"fortran-common",
     "Search archive members for definitions to override COMMON symbols (default)",

lld/ELF/OutputSections.h

 #include <array>
 
 namespace lld::elf {
 
 struct PhdrEntry;
 
 struct CompressedData {
   std::unique_ptr<SmallVector<uint8_t, 0>[]> shards;
+  uint32_t type = 0;
   uint32_t numShards = 0;
   uint32_t checksum = 0;
   uint64_t uncompressedSize;
 };
 
 // This represents a section in an output file.
 // It is composed of multiple InputSections.
 // The writer creates multiple OutputSections and assign them unique,
public:
   // Check that the addends for dynamic relocations were written correctly.
   void checkDynRelAddends(const uint8_t *bufStart);
   template <class ELFT> void maybeCompress();
 
   void sort(llvm::function_ref<int(InputSectionBase *s)> order);
   void sortInitFini();
   void sortCtorsDtors();
 
+  // Used for implementation of --compress-debug-sections and
+  // --compress-sections.
+  CompressedData compressed;
+
 private:
   SmallVector<InputSection *, 0> storage;
 
-  // Used for implementation of --compress-debug-sections option.
-  CompressedData compressed;
-
   std::array<uint8_t, 4> getFiller();
 };
 
 struct OutputDesc final : SectionCommand {
   OutputSection osec;
   OutputDesc(StringRef name, uint32_t type, uint64_t flags)
       : SectionCommand(OutputSectionKind), osec(name, type, flags) {}
 

lld/ELF/OutputSections.cpp

 }
 #endif
 
 // Compress section contents if this section contains debug info.
 template <class ELFT> void OutputSection::maybeCompress() {
   using Elf_Chdr = typename ELFT::Chdr;
   (void)sizeof(Elf_Chdr);
 
-  // Compress only DWARF debug sections.
-  if (config->compressDebugSections == DebugCompressionType::None ||
-      (flags & SHF_ALLOC) || !name.starts_with(".debug_") || size == 0)
+  // Compress DWARF debug sections for --compress-debug-sections or arbitrary
+  // sections for --compress-sections.
+  DebugCompressionType type = DebugCompressionType::None;
+  if (config->compressDebugSections != DebugCompressionType::None &&
+      !(flags & SHF_ALLOC) && name.starts_with(".debug_") && size) {
+    type = config->compressDebugSections;
+  } else {
+    for (auto &[glob, t] : config->compressSections)
+      if (glob.match(name))
+        type = t;
+  }
+  if (type == DebugCompressionType::None)
     return;
 
   llvm::TimeTraceScope timeScope("Compress debug sections");
   compressed.uncompressedSize = size;
   auto buf = std::make_unique<uint8_t[]>(size);
   // Write uncompressed data to a temporary zero-initialized buffer.
   {
     parallel::TaskGroup tg;
     writeTo<ELFT>(buf.get(), tg);
   }
 
 #if LLVM_ENABLE_ZSTD
   // Use ZSTD's streaming compression API which permits parallel workers working
   // on the stream. See http://facebook.github.io/zstd/zstd_manual.html
   // "Streaming compression - HowTo".
-  if (config->compressDebugSections == DebugCompressionType::Zstd) {
+  if (type == DebugCompressionType::Zstd) {
     // Allocate a buffer of half of the input size, and grow it by 1.5x if
     // insufficient.
+    compressed.type = ELFCOMPRESS_ZSTD;
     compressed.shards = std::make_unique<SmallVector<uint8_t, 0>[]>(1);
     SmallVector<uint8_t, 0> &out = compressed.shards[0];
     out.resize_for_overwrite(std::max<size_t>(size / 2, 32));
     size_t pos = 0;
 
     ZSTD_CCtx *cctx = ZSTD_createCCtx();
     // Ignore error if zstd was not built with ZSTD_MULTITHREAD.
     (void)ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers,
#if LLVM_ENABLE_ZLIB
   uint32_t checksum = 1;       // Initial Adler-32 value
   size = sizeof(Elf_Chdr) + 2; // Elf_Chdir and zlib header
   for (size_t i = 0; i != numShards; ++i) {
     size += shardsOut[i].size();
     checksum = adler32_combine(checksum, shardsAdler[i], shardsIn[i].size());
   }
   size += 4; // checksum
 
+  compressed.type = ELFCOMPRESS_ZLIB;
   compressed.shards = std::move(shardsOut);
   compressed.numShards = numShards;
   compressed.checksum = checksum;
   flags |= SHF_COMPRESSED;
 #endif
 }
 
 static void writeInt(uint8_t *buf, uint64_t data, uint64_t size) {
else
     llvm_unreachable("unsupported Size argument");
 }
 
 template <class ELFT>
 void OutputSection::writeTo(uint8_t *buf, parallel::TaskGroup &tg) {
   llvm::TimeTraceScope timeScope("Write sections", name);
   if (type == SHT_NOBITS)
     return;
 
-  // If --compress-debug-section is specified and if this is a debug section,
-  // we've already compressed section contents. If that's the case,
-  // just write it down.
+  // If the section is compressed due to
+  // --compress-debug-section/--compress-sections, the content is already known.
   if (compressed.shards) {
     auto *chdr = reinterpret_cast<typename ELFT::Chdr *>(buf);
+    chdr->ch_type = compressed.type;
     chdr->ch_size = compressed.uncompressedSize;
     chdr->ch_addralign = addralign;
     buf += sizeof(*chdr);
-    if (config->compressDebugSections == DebugCompressionType::Zstd) {
-      chdr->ch_type = ELFCOMPRESS_ZSTD;
+    if (compressed.type == ELFCOMPRESS_ZSTD) {
       memcpy(buf, compressed.shards[0].data(), compressed.shards[0].size());
       return;
     }
-    chdr->ch_type = ELFCOMPRESS_ZLIB;
 
     // Compute shard offsets.
     auto offsets = std::make_unique<size_t[]>(compressed.numShards);
     offsets[0] = 2; // zlib header
     for (size_t i = 1; i != compressed.numShards; ++i)
       offsets[i] = offsets[i - 1] + compressed.shards[i - 1].size();
 
     buf[0] = 0x78; // CMF

lld/ELF/Writer.cpp

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();
   checkExecuteOnly();
 
-  // If --compressed-debug-sections is specified, compress .debug_* sections.
-  // Do it right now because it changes the size of output sections.
-  for (OutputSection *sec : outputSections)
-    sec->maybeCompress<ELFT>();
-
   if (script->hasSectionsCommand)
     script->allocateHeaders(mainPart->phdrs);
 
   // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
   // 0 sized region. This has to be done late since only after assignAddresses
   // we know the size of the sections.
   for (Partition &part : partitions)
     removeEmptyPTLoad(part.phdrs);
 
template <class ELFT> void Writer<ELFT>::finalizeAddressDependentContent() {
   for (Partition &part : partitions)
     finalizeSynthetic(part.armExidx.get());
   resolveShfLinkOrder();
 
   // Converts call x@GDPLT to call __tls_get_addr
   if (config->emachine == EM_HEXAGON)
     hexagonTLSSymbolUpdate(outputSections);
 
+  // Compress SHF_COMPRESSED sections using assignAddresses computed content and
+  // sizes. If there are data commands with changed values, the compressed
+  // content will be invalid, but we do not detect the case. If the section has
+  // changes size due to future assignAddresses calls, we will report an error
+  // in assignOffsets.
+  for (OutputSection *sec : outputSections)
+    sec->maybeCompress<ELFT>();
+
   uint32_t pass = 0, assignPasses = 0;
   for (;;) {
     bool changed = target->needsThunks ? tc.createThunks(pass, outputSections)
                                        : target->relaxOnce(pass);
     ++pass;
 
     // With Thunk Size much smaller than branch range we expect to
     // converge quickly; if we get to 30 something has gone wrong.

lld/docs/ld.lld.1

 compresses well at that level. If you want to compress it more,
 you can specify
 .Fl O2
 to set the compression level to 6.
 .It Cm zstd
 The compression level is 5.
 .El
 .Pp
+.It Fl -compress-sections Ns = Ns Ar section-glob=[zlib|zstd]
+Compress output sections matching the glob with zlib or zstd.
 .It Fl -cref
 Output cross reference table. If
 .Fl Map
 is specified, print to the map file.
 .It Fl -defsym Ns = Ns Ar symbol Ns = Ns Ar expression
 Define a symbol alias.
 .Ar expression
 may be another symbol or a linker script expression.

lld/test/ELF/compress-sections-err.s

 # REQUIRES: x86
 # UNSUPPORTED: zlib
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
 # RUN: ld.lld %t.o --compress-debug-sections=zlib --compress-debug-sections=none -o /dev/null 2>&1 | count 0
 # RUN: not ld.lld %t.o --compress-debug-sections=zlib -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --implicit-check-not=error:
+# RUN: not ld.lld %t.o --compress-sections=foo=zlib -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CHECK2 --implicit-check-not=error:
 
 # CHECK: error: --compress-debug-sections: LLVM was not built with LLVM_ENABLE_ZLIB or did not find zlib at build time
+# CHECK2: error: --compress-sections: LLVM was not built with LLVM_ENABLE_ZLIB or did not find zlib at build time
 
 .globl _start
 _start:

lld/test/ELF/compress-sections.s

+# REQUIRES: x86, zlib, zstd
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: ld.lld -pie %t.o -o %t --compress-sections '*0=zlib' --compress-sections '*0=none'
+# RUN: llvm-readelf -Srs %t | FileCheck %s --check-prefix=CHECK1
+
+# CHECK1:      foo0       PROGBITS [[#%x,FOO0:]]    [[#%x,]] [[#%x,]] 00 A   0 0  1
+# CHECK1-NEXT: foo1       PROGBITS [[#%x,FOO1:]]    [[#%x,]] [[#%x,]] 00 A   0 0  1
+# CHECK1-NEXT: .text      PROGBITS [[#%x,TEXT:]]    [[#%x,]] [[#%x,]] 00 AX  0 0  4
+# CHECK1:      write0     PROGBITS [[#%x,WRITE0:]]  [[#%x,]] [[#%x,]] 00 WA  0 0  1
+# CHECK1-NEXT: nonalloc0  PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 00     0 0  1
+# CHECK1-NEXT: nonalloc1  PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 00     0 0  1
+# CHECK1-NEXT: .debug_str PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 01 MS  0 0  1
+
+# CHECK1:          Offset          {{.*}} Type              Symbol's Value  Symbol's Name + Addend
+# CHECK1-NEXT: {{0*}}[[#WRITE0]]   {{.*}} R_X86_64_RELATIVE                 [[#TEXT]]
+# CHECK1-NEXT: {{0*}}[[#WRITE0+8]] {{.*}} R_X86_64_RELATIVE                 [[#TEXT]]
+
+# CHECK1: [[#FOO0]]      0 NOTYPE  LOCAL  DEFAULT   [[#]] foo0_sym
+# CHECK1: [[#FOO1]]      0 NOTYPE  LOCAL  DEFAULT   [[#]] foo1_sym
+# CHECK1: [[#FOO0]]      0 NOTYPE  GLOBAL PROTECTED [[#]] __start_foo0
+# CHECK1: [[#FOO1]]      0 NOTYPE  GLOBAL PROTECTED [[#]] __stop_foo0
+
+# RUN: ld.lld -pie %t.o -o %t --compress-sections '*0=zlib' --compress-sections .debug_str=zstd
+# RUN: llvm-readelf -Srs -x foo0 -x write0 -x nonalloc0 -x .debug_str %t | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:      foo0       PROGBITS [[#%x,FOO0:]]    [[#%x,]] [[#%x,]] 00 AC  0 0  1
+# CHECK2-NEXT: foo1       PROGBITS [[#%x,FOO1:]]    [[#%x,]] [[#%x,]] 00 A   0 0  1
+# CHECK2-NEXT: .text      PROGBITS [[#%x,TEXT:]]    [[#%x,]] [[#%x,]] 00 AX  0 0  4
+# CHECK2:      write0     PROGBITS [[#%x,WRITE0:]]  [[#%x,]] [[#%x,]] 00 WAC 0 0  1
+# CHECK2-NEXT: nonalloc0  PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 00 C   0 0  1
+# CHECK2-NEXT: nonalloc1  PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 00     0 0  1
+# CHECK2-NEXT: .debug_str PROGBITS 0000000000000000 [[#%x,]] [[#%x,]] 01 MSC 0 0  1
+
+# CHECK2:          Offset          {{.*}} Type              Symbol's Value  Symbol's Name + Addend
+# CHECK2-NEXT: {{0*}}[[#WRITE0]]   {{.*}} R_X86_64_RELATIVE                 [[#TEXT]]
+# CHECK2-NEXT: {{0*}}[[#WRITE0+8]] {{.*}} R_X86_64_RELATIVE                 [[#TEXT]]
+
+# CHECK2:      Hex dump of section 'foo0':
+## zlib with ch_size=0x10
+# CHECK2-NEXT: 01000000 00000000 10000000 00000000
+# CHECK2-NEXT: 01000000 00000000 {{.*}}
+# CHECK2:      Hex dump of section 'write0':
+## zlib with ch_size=0x10
+# CHECK2-NEXT: 01000000 00000000 10000000 00000000
+# CHECK2-NEXT: 01000000 00000000 {{.*}}
+# CHECK2:      Hex dump of section 'nonalloc0':
+## zlib with ch_size=0x10
+# CHECK2-NEXT: 01000000 00000000 10000000 00000000
+# CHECK2-NEXT: 01000000 00000000 {{.*}}
+# CHECK2:      Hex dump of section '.debug_str':
+## zstd with ch_size=0x38
+# CHECK2-NEXT: 02000000 00000000 38000000 00000000
+# CHECK2-NEXT: 01000000 00000000 {{.*}}
+
+# RUN: not ld.lld --compress-sections=foo %t.o -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ERR1 --implicit-check-not=error:
+# ERR1:      error: --compress-sections: parse error, not 'section-glob=[zlib|zstd]'
+
+# RUN: not ld.lld --compress-sections 'a[=zlib' %t.o -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ERR2 --implicit-check-not=error:
+# ERR2:      error: --compress-sections: invalid glob pattern: a[
+
+# RUN: not ld.lld %t.o -o /dev/null --compress-sections='.debug*=zlib-gabi' --compress-sections='.debug*=' 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR3 %s
+# ERR3:      unknown --compress-sections value: zlib-gabi
+# ERR3-NEXT: --compress-sections: parse error, not 'section-glob=[zlib|zstd]'
+
+.globl _start
+_start:
+  leaq __start_foo0(%rip), %rax
+  leaq __stop_foo0(%rip), %rax
+  ret
+
+.section foo0,"a"
+foo0_sym:
+.quad .text-.
+.quad .text-.
+.section foo1,"a"
+foo1_sym:
+.quad .text-.
+.quad .text-.
+.section write0,"aw"
+.quad .text
+.quad .text
+.section nonalloc0,""
+.quad .text
+.quad .text
+.section nonalloc1,""
+.quad 42
+
+.section .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz "AAAAAAAAAAAAAAAAAAAAAAAAAAA"
+.Linfo_string1:
+  .asciz "BBBBBBBBBBBBBBBBBBBBBBBBBBB"

lld/test/ELF/linkerscript/compress-sections.s

+# REQUIRES: x86, zlib
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 a.s -o a.o
+# RUN: not ld.lld -T a.lds a.o --compress-sections 'foo=zlib' 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+# ERR: error: uncompressed size of SHF_COMPRESSED section 'foo' is dependent on linker script commands
+
+# RUN: ld.lld -T b.lds a.o --compress-sections 'foo=zlib' -o a
+# RUN: llvm-readelf -Ss a | FileCheck %s
+
+# CHECK: .text    PROGBITS [[#%x,]]        [[#%x,]] [[#%x,]] 00 AX 0 0  4
+# CHECK: foo      PROGBITS [[#%x,FOO:]]    [[#%x,]] [[#%x,]] 00 AC 0 0  1
+# CHECK: bar      PROGBITS [[#%x,BAR:]]    [[#%x,]] [[#%x,]] 00 A  0 0  1
+
+# CHECK: [[#FOO]]      0 NOTYPE  LOCAL  DEFAULT   [[#]] foo0_sym
+# CHECK: [[#FOO+8]]    0 NOTYPE  LOCAL  DEFAULT   [[#]] foo1_sym
+# CHECK: [[#FOO]]      0 NOTYPE  GLOBAL PROTECTED [[#]] __start_foo
+# CHECK: [[#BAR]]      0 NOTYPE  GLOBAL PROTECTED [[#]] __stop_foo
+
+#--- a.s
+.globl _start
+_start:
+  leaq __start_foo(%rip), %rax
+  leaq __stop_foo(%rip), %rax
+  ret
+
+.section foo0,"a"
+foo0_sym:
+.quad 42
+.section foo1,"a"
+foo1_sym:
+.quad 42
+.section bar,"a"
+.quad 42
+
+#--- a.lds
+SECTIONS {
+  foo : { *(foo*) . += a; }
+  .text : { *(.text) }
+  a = b+1;
+  b = c+1;
+  c = SIZEOF(.text);
+}
+
+#--- b.lds
+SECTIONS {
+  .text : { *(.text) }
+  c = SIZEOF(.text);
+  b = c+1;
+  a = b+1;
+## In general, using data commands is error-prone. This case is correct, though.
+  foo . : { *(foo*) QUAD(SIZEOF(foo)) . += a; }
+}