[llvm-objcopy] Support --{,de}compress-debug-sections for zstd

[MaskRay]

Summary

Also, add ELFCOMPRESS_ZSTD (2) from the approved generic-abi proposal:
https://groups.google.com/g/generic-abi/c/satyPkuMisk
("Add new ch_type value: ELFCOMPRESS_ZSTD")

Link: https://discourse.llvm.org/t/rfc-zstandard-as-a-second-compression-method-to-llvm/63399
("[RFC] Zstandard as a second compression method to LLVM")

[MaskRay]

To test a LLVM_ENABLE_ZSTD=on build:

git clone https://github.com/facebook/zstd --depth 1
cd zstd
cmake -Hbuild/cmake -Bout/release -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/tmp/opt/zstd
ninja -C out/release install

...
cmake ... -DLLVM_ENABLE_ZSTD=on -DCMAKE_PREFIX_PATH=/tmp/opt/zstd

[MaskRay]

add more test

[dblaikie]

llvm/docs/CommandGuide/llvm-objcopy.rst

300–301

Might be worth removing zlib-gnu in a separate patch before this one, so if zstd is reverted we don't lose the fix to remove zlib-gnu?

llvm/lib/ObjCopy/ELF/ELFObject.cpp

437–438

Could probably do this refactor/inlining in a separate commit.

443

uncompress V decompress? Seems most of the wording here uses decompress & by google search results it seems the more common term.

448–456

sounded like the folks contributing zstd support had some plans to make modular compression algorithm wrappers - that I'd guess would look more like "get the compression handler, given the compression type, then use it" so wouldn't need to have two separate calls to uncompress here?

451–461

Was there no error handling before & any compression type was treated as zlib & decompressed using zlib?

540–541

Might be better to add the case for DebugCompressionType::None here so that we get a compilation error (uncovered switch) next time a compression algorithm is added to the enum?

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

720–735

Maybe make these a switch over DebugCompressionType so we can catch this as a compilation error if a new one is added?

[MaskRay]

address comments

llvm/docs/CommandGuide/llvm-objcopy.rst

300–301

Will do. I wanted to check the wording here: whether style should be changed to format and how we should state Use zlib if <format> is omitted.

Just jumped the gun a bit and pushed a commit to remove zlib-gnu and switch to format.
style makes less sense now as the zlib-gnu style has been removed.

llvm/lib/ObjCopy/ELF/ELFObject.cpp

443

"decompress" makes sense to me. I used "uncompress" because the API and many compression libraries use the name.

https://datatracker.ietf.org/doc/html/rfc8478 says that "uncompressed" is related to the state and "decompress" seems preferred for the act of processing.

448–456

This can be a future improvement when the API is available.

451–461

Right. There was no test before.

[dblaikie]

llvm/lib/ObjCopy/ELF/ELFObject.cpp

448–456

Some coordination might be good if those folks already have outstanding patches/some planned direction, though?

[MaskRay]

rebase on D130506

[jhenderson]

llvm/lib/ObjCopy/ELF/ELFObject.h

539

There's only one ChType in this context, not an original and a modified one, so I'm not sure we need the Orig prefix? (Also applies to the getter obviously)

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd.test

3

To me, "decompression" sounds much more natural than "uncompression" (FWIW, I'm not sure I'd ever use the verb "uncompress").

Later on, UNCOMPRESSED should probably be the more specific DECOMPRESSED (see https://english.stackexchange.com/a/56483), since it's a reference to something that has undergone the reverse of compression.

30–31

This comment makes me think it might be good to have a test case that shows we don't convert a zstd section to a zlib section if specified with --compress-debug-sections=zlib and vice versa.

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

742

FWIW, it should be "cannot", to conform to modern English trends ("can not" means the same, but is much less common).

[MaskRay]

address comments

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd.test

3

Thanks for the reference. It matches the terminology in https://datatracker.ietf.org/doc/html/rfc8478#section-2 , too. I fixed some places to use "decompress" but forgot this one.

30–31

# RUN: %if zlib provides the test.

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd.test

3

Looks like you didn't change the check prefixes?

30–31

Sorry, misread the test somehow.

[MaskRay]

update test check prefix: UNCOMPRESSED=>DECOMPRESSED

[jhenderson]

Looks good. Might want to give @dblaikie a bit in case he wants to add anything else.

[dblaikie]

looks like the alternative (with other changes) is posted here: https://reviews.llvm.org/D130516 so would be good to resolve the design tradeoffs between these before committing either.

[MaskRay]

Yes!

compression::Param P;
P.Format = CompressionType;
compression::compress(P, OriginalData, CompressedData);

is a lightweight use of the compression interface. I could move back the previous version which uses the slightly verbose switch, then this patch will have no dependency on D130506.

@ckissane What I want to demonstrate in this patch is that we should use multiple patches adding zstd support to different components, instead of having a monolithic D130516.

• https://gregoryszorc.com/blog/2020/01/07/problems-with-pull-requests-and-how-to-fix-them/ "Previous studies have found that the number of useful comments decreases and the review latency increases as the size of the change increases."
• When we add zstd support to various components, they should have dedicated tests.
• Each component is cared by its maintainers/regular reviewers/users. Having a refactoring is fine, but bundling zstd features in the huge patch may surprise them. There are many factors to consider, including what to do when zstd support is unavailable.
• Many components don't necessarily migrate to zstd.

Note: Having the big change including everything is still very useful, as it gives the full picture and may enlighten useful design discussions.

FWIW if I were to create all patches, I would do these. The ordering is somewhat loose, but I'll start with llvm-objcopy

• add llvm-objcopy support
• add MC support (this can be tested with llvm-objcopy)
• add clang -gz=zstd support
• add lld input support (D129406)
• add lld output support (after MC support, I actually have a local patch)
• add lldb support
• ...

[ckissane]

In D130458#3683370, @MaskRay wrote:

Yes!

compression::Param P;
P.Format = CompressionType;
compression::compress(P, OriginalData, CompressedData);

is a lightweight use of the compression interface. I could move back the previous version which uses the slightly verbose switch, then this patch will have no dependency on D130506.

@ckissane What I want to demonstrate in this patch is that we should use multiple patches adding zstd support to different components, instead of having a monolithic D130516.

• https://gregoryszorc.com/blog/2020/01/07/problems-with-pull-requests-and-how-to-fix-them/ "Previous studies have found that the number of useful comments decreases and the review latency increases as the size of the change increases."
• When we add zstd support to various components, they should have dedicated tests.
• Each component is cared by its maintainers/regular reviewers/users. Having a refactoring is fine, but bundling zstd features in the huge patch may surprise them. There are many factors to consider, including what to do when zstd support is unavailable.
• Many components don't necessarily migrate to zstd.

Note: Having the big change including everything is still very useful, as it gives the full picture and may enlighten useful design discussions.

FWIW if I were to create all patches, I would do these. The ordering is somewhat loose, but I'll start with llvm-objcopy

• add llvm-objcopy support
• add MC support (this can be tested with llvm-objcopy)
• add clang -gz=zstd support
• add lld input support (D129406)
• add lld output support (after MC support, I actually have a local patch)
• add lldb support
• ...

I totally agree!
we could try to at least get in my compression class refactor and cl::opt<CompressionAlgorithm*> support as a patch though if you think that's appropriate?

[dblaikie]

Yeah, I'm all in favor of smaller incremental patches - but more a question of the general API direction here. Whether to go with multiple entry points that each take the compression scheme and switch over it, or something with inheritance that switches over compression scheme once and then uses dynamic dispatch for compression/decompression/etc. I do see the point of ( https://reviews.llvm.org/D130516#3677580 ) that the inheritance scheme might be overkill for two (maybe three if the default/null/no-op compression scheme is worth having) implementations, but might still be suitable - I think it'll be easier to compare once patches are split up/more isolated.

[MaskRay]

Thanks for the replys! Personally I think the object-oriented style design is a bit overkill. I think most call sites really don't care about constructing a compression/decompression class. A free function call like

compression::Param P;
P.Format = CompressionType;
// Some callers may want to set --threads here. The user needs to be aware that different threads may lead to different output. For the same number of threads, the output should be deterministic, as guaranteed by zstd.
compression::compress(P, OriginalData, CompressedData);

is just fine. If you can simplify the OO enough so that there is less boilerplate for each call site, happy to take another look. Note: even if an OO design is used, it's possible that we may want to introduce free functions and the end result looks exactly very similar to this patch.

If you consider that even if D130506 is not the final form, it will be close enough to the final form. We can push the two patches and you can continue refining the interface.
The llvm-objcopy serves as an example for you to add support for other components.

[MaskRay]

remove dependency on the API change (i.e. switch to a previous revision)

[MaskRay]

In D130458#3685479, @MaskRay wrote:

remove dependency on the API change (i.e. switch to a previous revision)

Sorry, I made a mistake here. The patch did not depend on D130506. A second-to-last update added the dependency and made it subject to the D130506/D130516 API design debate.

@dblaikie Realized I didn't make sure you were fine with this incremental direction - would you like me to revert while we settle on free function/classe based design first?

[dblaikie]

In D130458#3688099, @MaskRay wrote:

In D130458#3685479, @MaskRay wrote:

remove dependency on the API change (i.e. switch to a previous revision)

Sorry, I made a mistake here. The patch did not depend on D130506. A second-to-last update added the dependency and made it subject to the D130506/D130516 API design debate.

I think I follow that/understood that to be what you were saying originally. Though I think either way this patch is part of that design discussion - not designing the API and using a switch is a design choice in this space/one option to consider, but I'd like to consider them before going ahead with any.

@dblaikie Realized I didn't make sure you were fine with this incremental direction - would you like me to revert while we settle on free function/classe based design first?

Yeah, I think it'd be good to revert this for now, thanks - this patch might be a good one to compare side-by-side with alternatives.

[MaskRay]

rebase

[dblaikie]

OK

[MaskRay]

rebase

[MaskRay]

Thanks for review. (Doing a final round of testing like asan, .-DLLVM_ENABLE_ZSTD=FORCE_ON -DCMAKE_PREFIX_PATH=/tmp/opt/zstd, etc before re-landing)

llvm/docs/CommandGuide/llvm-objcopy.rst

  section references. Any invalid sh_link fields will be set to zero.
 
 .. option:: --change-start <incr>, --adjust-start
 
  Add ``<incr>`` to the program's start address. Can be specified multiple
  times, in which case the values will be applied cumulatively.
 
 .. option:: --compress-debug-sections [<format>]
 
  Compress DWARF debug sections in the output, using the specified format.
- Supported formats are ``zlib``. Use ``zlib`` if ``<format>`` is omitted.
+ Supported formats are ``zlib`` and ``zstd``. Use ``zlib`` if ``<format>`` is omitted.
 
 .. option:: --decompress-debug-sections
 
  Decompress any compressed DWARF debug sections in the output.
 
 .. option:: --discard-locals, -X
 
  Remove local symbols starting with ".L" from the output.

llvm/include/llvm/BinaryFormat/ELF.h

struct Elf64_Nhdr {
   Elf64_Word n_namesz;
   Elf64_Word n_descsz;
   Elf64_Word n_type;
 };
 
 // Legal values for ch_type field of compressed section header.
 enum {
   ELFCOMPRESS_ZLIB = 1,            // ZLIB/DEFLATE algorithm.
+  ELFCOMPRESS_ZSTD = 2,            // Zstandard algorithm
   ELFCOMPRESS_LOOS = 0x60000000,   // Start of OS-specific.
   ELFCOMPRESS_HIOS = 0x6fffffff,   // End of OS-specific.
   ELFCOMPRESS_LOPROC = 0x70000000, // Start of processor-specific.
   ELFCOMPRESS_HIPROC = 0x7fffffff  // End of processor-specific.
 };
 
 /// Convert an architecture name into ELF's e_machine value.
 uint16_t convertArchNameToEMachine(StringRef Arch);
 
 /// Convert an ELF's e_machine value into an architecture name.
 StringRef convertEMachineToArchName(uint16_t EMachine);
 
 } // end namespace ELF
 } // end namespace llvm
 
 #endif // LLVM_BINARYFORMAT_ELF_H

llvm/lib/ObjCopy/ELF/ELFObject.h

public:
   Error accept(SectionVisitor &Sec) const override;
   Error accept(MutableSectionVisitor &Visitor) override;
   bool hasContents() const override { return true; }
 };
 
 class CompressedSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
+  uint32_t ChType = 0;
   DebugCompressionType CompressionType;
   uint64_t DecompressedSize;
   uint64_t DecompressedAlign;
   SmallVector<uint8_t, 128> CompressedData;
 
 public:
   CompressedSection(const SectionBase &Sec,
                     DebugCompressionType CompressionType);
-  CompressedSection(ArrayRef<uint8_t> CompressedData, uint64_t DecompressedSize,
-                    uint64_t DecompressedAlign);
+  CompressedSection(ArrayRef<uint8_t> CompressedData, uint32_t ChType,
+                    uint64_t DecompressedSize, uint64_t DecompressedAlign);
 
   uint64_t getDecompressedSize() const { return DecompressedSize; }
   uint64_t getDecompressedAlign() const { return DecompressedAlign; }
+  uint64_t getChType() const { return ChType; }
 
   Error accept(SectionVisitor &Visitor) const override;
   Error accept(MutableSectionVisitor &Visitor) override;
 
   static bool classof(const SectionBase *S) {
     return S->OriginalFlags & ELF::SHF_COMPRESSED;
   }
 };
 
 class DecompressedSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
 public:
+  uint32_t ChType;
   explicit DecompressedSection(const CompressedSection &Sec)
-      : SectionBase(Sec) {
+      : SectionBase(Sec), ChType(Sec.getChType()) {
     Size = Sec.getDecompressedSize();
     Align = Sec.getDecompressedAlign();
     Flags = OriginalFlags = (Flags & ~ELF::SHF_COMPRESSED);
   }
 
   Error accept(SectionVisitor &Visitor) const override;
   Error accept(MutableSectionVisitor &Visitor) override;
 };

llvm/lib/ObjCopy/ELF/ELFObject.cpp

Error Section::accept(MutableSectionVisitor &Visitor) {
   return Visitor.visit(*this);
 }
 
 Error SectionWriter::visit(const OwnedDataSection &Sec) {
   llvm::copy(Sec.Data, Out.getBufferStart() + Sec.Offset);
   return Error::success();
 }
 
 template <class ELFT>
 Error ELFSectionWriter<ELFT>::visit(const DecompressedSection &Sec) {
   ArrayRef<uint8_t> Compressed =
       Sec.OriginalData.slice(sizeof(Elf_Chdr_Impl<ELFT>));
-  SmallVector<uint8_t, 128> DecompressedContent;
-  if (Error Err = compression::zlib::uncompress(Compressed, DecompressedContent,
-                                                static_cast<size_t>(Sec.Size)))
+  SmallVector<uint8_t, 128> Decompressed;
+  DebugCompressionType Type;
+  switch (Sec.ChType) {
+  case ELFCOMPRESS_ZLIB:
+    Type = DebugCompressionType::Z;
+    break;
+  case ELFCOMPRESS_ZSTD:
+    Type = DebugCompressionType::Zstd;
+    break;
+  default:
+    return createStringError(errc::invalid_argument,
+                             "--decompress-debug-sections: ch_type (" +
+                                 Twine(Sec.ChType) + ") of section '" +
+                                 Sec.Name + "' is unsupported");
+  }
+  if (Error E = compression::decompress(Type, Compressed, Decompressed,
     return createStringError(errc::invalid_argument,
-                             "'" + Sec.Name + "': " + toString(std::move(Err)));
+                             "failed to decompress section '" + Sec.Name +
+                                 "': " + toString(std::move(E)));
 
   uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset;
-  std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
+  std::copy(Decompressed.begin(), Decompressed.end(), Buf);
 
   return Error::success();
 }
 
 Error BinarySectionWriter::visit(const DecompressedSection &Sec) {
   return createStringError(errc::operation_not_permitted,
                            "cannot write compressed section '" + Sec.Name +
                                "' ");
Error ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
   Elf_Chdr_Impl<ELFT> Chdr = {};
   switch (Sec.CompressionType) {
   case DebugCompressionType::None:
     std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(), Buf);
     return Error::success();
   case DebugCompressionType::Z:
     Chdr.ch_type = ELF::ELFCOMPRESS_ZLIB;
     break;
+  case DebugCompressionType::Zstd:
+    Chdr.ch_type = ELF::ELFCOMPRESS_ZSTD;
+    break;
   }
   Chdr.ch_size = Sec.DecompressedSize;
   Chdr.ch_addralign = Sec.DecompressedAlign;
   memcpy(Buf, &Chdr, sizeof(Chdr));
   Buf += sizeof(Chdr);
 
   std::copy(Sec.CompressedData.begin(), Sec.CompressedData.end(), Buf);
   return Error::success();
 }
 
 CompressedSection::CompressedSection(const SectionBase &Sec,
                                      DebugCompressionType CompressionType)
     : SectionBase(Sec), CompressionType(CompressionType),
       DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) {
-  compression::zlib::compress(OriginalData, CompressedData);
+  compression::compress(compression::Params(CompressionType), OriginalData,
+                        CompressedData);
 
-  assert(CompressionType != DebugCompressionType::None);
   Flags |= ELF::SHF_COMPRESSED;
   size_t ChdrSize =
       std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
                         sizeof(object::Elf_Chdr_Impl<object::ELF64BE>)),
                std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
                         sizeof(object::Elf_Chdr_Impl<object::ELF32BE>)));
   Size = ChdrSize + CompressedData.size();
   Align = 8;
 }
 
 CompressedSection::CompressedSection(ArrayRef<uint8_t> CompressedData,
-                                     uint64_t DecompressedSize,
+                                     uint32_t ChType, uint64_t DecompressedSize,
                                      uint64_t DecompressedAlign)
-    : CompressionType(DebugCompressionType::None),
+    : ChType(ChType), CompressionType(DebugCompressionType::None),
       DecompressedSize(DecompressedSize), DecompressedAlign(DecompressedAlign) {
   OriginalData = CompressedData;
 }
 
 Error CompressedSection::accept(SectionVisitor &Visitor) const {
   return Visitor.visit(*this);
 }
 
default: {
 
     Expected<StringRef> Name = ElfFile.getSectionName(Shdr);
     if (!Name)
       return Name.takeError();
 
     if (!(Shdr.sh_flags & ELF::SHF_COMPRESSED))
       return Obj.addSection<Section>(*Data);
     auto *Chdr = reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Data->data());
-    return Obj.addSection<CompressedSection>(
-        CompressedSection(*Data, Chdr->ch_size, Chdr->ch_addralign));
+    return Obj.addSection<CompressedSection>(CompressedSection(
+        *Data, Chdr->ch_type, Chdr->ch_size, Chdr->ch_addralign));
   }
   }
 }
 
 template <class ELFT> Error ELFBuilder<ELFT>::readSectionHeaders() {
   uint32_t Index = 0;
   Expected<typename ELFFile<ELFT>::Elf_Shdr_Range> Sections =
       ElfFile.sections();

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-default.test

 # REQUIRES: zlib
 
 # RUN: yaml2obj %p/Inputs/compress-debug-sections.yaml -o %t.o
 # RUN: llvm-objcopy --compress-debug-sections %t.o %t-compressed.o
-# RUN: llvm-readobj -S %t-compressed.o | FileCheck %s
+# RUN: llvm-readobj -S --sd %t-compressed.o | FileCheck %s
 
 # CHECK: Name: .debug_foo
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT: SHF_COMPRESSED
 # CHECK-NEXT: ]
+# CHECK:      SectionData (
+## ch_type = ELFCOMPRESS_ZLIB (1)
+# CHECK-NEXT:   0000: 01000000 {{.*}}
 # CHECK-NOT: Name: .debug_foo
 

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zlib.test

 
 # COMPRESSED:        Hex dump of section '.debug_foo':
 # COMPRESSED-NEXT:   0x00000000 01000000 {{.*}}   08000000 00000000
 # COMPRESSED-NEXT:   0x00000010 00000000 00000000 {{.*}}
 
 ## --compress-debug-sections does not update a compressed section.
 # RUN: llvm-objcopy --compress-debug-sections=zlib %t-zlib.o %t-zlib-zlib.o
 # RUN: cmp %t-zlib.o %t-zlib-zlib.o
+
+# RUN: yaml2obj %s -o %t-corrupted
+# RUN: not llvm-objcopy --decompress-debug-sections %t-corrupted /dev/null 2>&1 | FileCheck %s -DFILE=%t-corrupted --check-prefix=ERR
+
+# ERR: error: '[[FILE]]': failed to decompress section '.debug_info': zlib error: Z_DATA_ERROR
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Type:         SHT_PROGBITS
+    Name:         .debug_info
+    Flags:        [ SHF_COMPRESSED ]
+    AddressAlign: 8
+    Content:      "010000000000000004000000000000000100000000000000ffffffff"

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd-err.test

+# UNSUPPORTED: zstd
+# RUN: yaml2obj %p/Inputs/compress-debug-sections.yaml -o %t
+# RUN: not llvm-objcopy --compress-debug-sections=zstd %t /dev/null 2>&1 | FileCheck %s
+
+# CHECK: error: LLVM was not built with LLVM_ENABLE_ZSTD or did not find zstd at build time

llvm/test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd.test

+# REQUIRES: zstd
+## Test --compress-debug-sections=zstd and decompression.
+
+# RUN: yaml2obj %p/Inputs/compress-debug-sections.yaml -o %t && llvm-objcopy %t
+# RUN: llvm-objcopy --compress-debug-sections=zstd %t %t-zstd
+# RUN: llvm-objcopy --decompress-debug-sections %t-zstd %t-de
+# RUN: cmp %t %t-de
+
+# RUN: llvm-readelf -S -r -x .debug_foo %t-zstd | FileCheck %s --check-prefixes=CHECK,COMPRESSED
+# RUN: llvm-readelf -S -r -x .debug_foo %t-de | FileCheck %s --check-prefixes=CHECK,DECOMPRESSED
+
+# CHECK:             Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# COMPRESSED:        .debug_foo        PROGBITS        0000000000000000 000040 {{.*}} 00   C  0   0  8
+# COMPRESSED-NEXT:   .notdebug_foo     PROGBITS        0000000000000000 {{.*}} 000008 00      0   0  0
+# DECOMPRESSED:      .debug_foo        PROGBITS        0000000000000000 000040 000008 00      0   0  0
+# DECOMPRESSED-NEXT: .notdebug_foo     PROGBITS        0000000000000000 {{.*}} 000008 00      0   0  0
+
+## Relocations do not change.
+# CHECK:             Relocation section '.rela.debug_foo' at offset {{.*}} contains 2 entries:
+# CHECK-NEXT:            Offset
+# CHECK-NEXT:        0000000000000001  000000010000000a R_X86_64_32            0000000000000000 .debug_foo + 0
+# CHECK-NEXT:        0000000000000002  000000020000000a R_X86_64_32            0000000000000000 .notdebug_foo + 0
+
+# COMPRESSED:        Hex dump of section '.debug_foo':
+## ch_type == ELFCOMPRESS_ZSTD (2)
+# COMPRESSED-NEXT:   0x00000000 02000000 00000000 08000000 00000000
+# COMPRESSED-NEXT:   0x00000010 00000000 00000000 {{.*}}
+
+## --compress-debug-sections does not update a compressed section. Its compression
+## type does not change.
+# RUN: llvm-objcopy --compress-debug-sections=zstd %t-zstd %t-zstd-zstd
+# RUN: cmp %t-zstd %t-zstd-zstd
+# RUN: %if zlib %{ llvm-objcopy --compress-debug-sections=zlib %t-zstd %t-zstd-zlib && cmp %t-zstd %t-zstd-zlib %}
+
+# RUN: yaml2obj %s -o %t-corrupted
+# RUN: not llvm-objcopy --decompress-debug-sections %t-corrupted /dev/null 2>&1 | FileCheck %s -DFILE=%t-corrupted --check-prefix=ERR
+
+# ERR: error: '[[FILE]]': failed to decompress section '.debug_info': Src size is incorrect
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Type:         SHT_PROGBITS
+    Name:         .debug_info
+    Flags:        [ SHF_COMPRESSED ]
+    AddressAlign: 8
+    Content:      "020000000000000004000000000000000100000000000000ffffffff"

llvm/test/tools/llvm-objcopy/ELF/decompress-debug-sections-err.test

+# REQUIRES: zlib
+# RUN: yaml2obj %s -o %t
+# RUN: not llvm-objcopy --decompress-debug-sections %t /dev/null 2>&1 | FileCheck %s -DFILE=%t
+
+# CHECK:       error: '[[FILE]]': --decompress-debug-sections: ch_type (3) of section '.debug_info' is unsupported
+# CHECK-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_info
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_COMPRESSED ]
+    Content:      030000000000000004000000000000000000000000000000789c6360
+    AddressAlign: 8
+  - Name:         .debug_str
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_COMPRESSED ]
+    Content:      030000000000000004000000000000000000000000000000789c6360
+    AddressAlign: 8

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

if (OutputFormat.empty()) {
       Expected<TargetInfo> Target =
           getOutputTargetInfoByTargetName(OutputFormat);
       if (!Target)
         return Target.takeError();
       Config.OutputFormat = Target->Format;
       Config.OutputArch = Target->Machine;
     }
   }
 
   if (const auto *A = InputArgs.getLastArg(OBJCOPY_compress_debug_sections)) {
     Config.CompressionType = StringSwitch<DebugCompressionType>(A->getValue())
                                  .Case("zlib", DebugCompressionType::Z)
+                                 .Case("zstd", DebugCompressionType::Zstd)
                                  .Default(DebugCompressionType::None);
-    if (Config.CompressionType == DebugCompressionType::None)
+    if (Config.CompressionType == DebugCompressionType::None) {
       return createStringError(
           errc::invalid_argument,
           "invalid or unsupported --compress-debug-sections format: %s",
           A->getValue());
-    if (!compression::zlib::isAvailable())
-      return createStringError(
-          errc::invalid_argument,
-          "LLVM was not compiled with LLVM_ENABLE_ZLIB: can not compress");
+    }
+    if (const char *Reason = compression::getReasonIfUnsupported(
+            compression::formatFor(Config.CompressionType)))
+      return createStringError(errc::invalid_argument, Reason);
   }
 
   Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink);
   // The gnu_debuglink's target is expected to not change or else its CRC would
   // become invalidated and get rejected. We can avoid recalculating the
   // checksum for every target file inside an archive by precomputing the CRC
   // here. This prevents a significant amount of I/O.
   if (!Config.AddGnuDebugLink.empty()) {
     auto DebugOrErr = MemoryBuffer::getFile(Config.AddGnuDebugLink);
     if (!DebugOrErr)
       return createFileError(Config.AddGnuDebugLink, DebugOrErr.getError());
     auto Debug = std::move(*DebugOrErr);
     Config.GnuDebugLinkCRC32 =
         llvm::crc32(arrayRefFromStringRef(Debug->getBuffer()));
   }
   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);

llvm/tools/llvm-objcopy/ObjcopyOpts.td

defm new_symbol_visibility : Eq<"new-symbol-visibility", "Visibility of "
                                 "symbols generated for binary input or added"
                                 " with --add-symbol unless otherwise"
                                 " specified. The default value is 'default'.">;
 
 def compress_debug_sections
     : Joined<["--"], "compress-debug-sections=">,
       MetaVarName<"format">,
       HelpText<"Compress DWARF debug sections using specified format. Supported "
-               "formats: zlib">;
+               "formats: zlib, zstd. Select zlib if <format> is omitted">;
 def : Flag<["--"], "compress-debug-sections">, Alias<compress_debug_sections>,
       AliasArgs<["zlib"]>;
 def decompress_debug_sections : Flag<["--"], "decompress-debug-sections">,
                                 HelpText<"Decompress DWARF debug sections.">;
 defm split_dwo
     : Eq<"split-dwo", "Equivalent to extract-dwo on the input file to "
                       "<dwo-file>, then strip-dwo on the input file">,
       MetaVarName<"dwo-file">;

llvm/utils/lit/lit/llvm/config.py

def __init__(self, lit_config, config):
         if 'memory' in sanitizers or 'memorywithorigins' in sanitizers:
             features.add('msan')
         if 'undefined' in sanitizers:
             features.add('ubsan')
 
         have_zlib = getattr(config, 'have_zlib', None)
         if have_zlib:
             features.add('zlib')
+        have_zstd = getattr(config, 'have_zstd', None)
+        if have_zstd:
+            features.add('zstd')
 
         # Check if we should run long running tests.
         long_tests = lit_config.params.get('run_long_tests', None)
         if lit.util.pythonize_bool(long_tests):
             features.add('long_tests')
 
         if target_triple:
             if re.match(r'^x86_64.*-apple', target_triple):