feat: use compression class for: clang ast serial zstd option + prof data compression variants + zstd elf + ztsd objcopy support

[ckissane]

Summary

uses compression classes to implement:
clang ast serial zstd option + prof data compression variants + zstd elf + ztsd objcopy support
also adds a llvm::cl::opt implementation for compression algorithms for easy drop in parsing on command line

[ckissane]

• Merge branch 'ckissane.compression-class' of github.com:ckissane/llvm-project into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class

[ckissane]

• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• remove erroneous declation of operator StringRef()

clang-tools-extra/clangd/index/Serialization.h

 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SERIALIZATION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SERIALIZATION_H
 
 #include "Headers.h"
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "clang/Tooling/CompilationDatabase.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Error.h"
 
 namespace clang {
 namespace clangd {
 
+extern llvm::compression::OptionalCompressionKind StringTableCompressionScheme;
+
 enum class IndexFileFormat {
   RIFF, // Versioned binary format, suitable for production use.
   YAML, // Human-readable format, suitable for experiments and debugging.
 };
 
 // Holds the contents of an index file that was read.
 struct IndexFileIn {
   llvm::Optional<SymbolSlab> Symbols;

clang-tools-extra/clangd/index/Serialization.cpp

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <vector>
 
 namespace clang {
 namespace clangd {
+
+llvm::compression::OptionalCompressionKind StringTableCompressionScheme =
+    llvm::compression::CompressionKind::Zlib;
+
 namespace {
 
 // IO PRIMITIVES
 // We use little-endian 32 bit ints, sometimes with variable-length encoding.
 //
 // Variable-length int encoding (varint) uses the bottom 7 bits of each byte
 // to encode the number, and the top bit to indicate whether more bytes follow.
 // e.g. 9a 2f means [0x1a and keep reading, 0x2f and stop].
for (unsigned I = 0; I < Sorted.size(); ++I)
       Index.try_emplace({Sorted[I].data(), Sorted[I].size()}, I);
 
     std::string RawTable;
     for (llvm::StringRef S : Sorted) {
       RawTable.append(std::string(S));
       RawTable.push_back(0);
     }
     llvm::compression::OptionalCompressionKind OptionalCompressionScheme =
-        llvm::compression::CompressionKind::Zlib;
-    OptionalCompressionScheme =
-        compression::noneIfUnsupported(OptionalCompressionScheme);
+        compression::noneIfUnsupported(StringTableCompressionScheme);
     if (OptionalCompressionScheme) {
       llvm::compression::CompressionKind CompressionScheme =
           *OptionalCompressionScheme;
       llvm::SmallVector<uint8_t, 0> Compressed;
       CompressionScheme->compress(llvm::arrayRefFromStringRef(RawTable),
                                   Compressed);
       write32(RawTable.size(), OS);
       OS << llvm::toStringRef(Compressed);
llvm::Expected<StringTableIn> readStringTable(llvm::StringRef Data) {
   if (R.err())
     return error("Truncated string table");
 
   llvm::StringRef Uncompressed;
   llvm::SmallVector<uint8_t, 0> UncompressedStorage;
   if (UncompressedSize == 0) // No compression
     Uncompressed = R.rest();
   else {
+    llvm::compression::OptionalCompressionKind OptionalCompressionScheme =
+        StringTableCompressionScheme;
+    if (!OptionalCompressionScheme) {
+      Uncompressed = R.rest();
+    } else {
       llvm::compression::CompressionKind CompressionScheme =
-        llvm::compression::CompressionKind::Zlib;
+          *OptionalCompressionScheme;
       if (CompressionScheme) {
         // Don't allocate a massive buffer if UncompressedSize was corrupted
         // This is effective for sharded index, but not big monolithic ones, as
         // once compressed size reaches 4MB nothing can be ruled out.
         // Theoretical max ratio from https://zlib.net/zlib_tech.html
         constexpr int MaxCompressionRatio = 1032;
         if ((CompressionScheme == llvm::compression::CompressionKind::Zlib) &&
             UncompressedSize / MaxCompressionRatio > R.rest().size())
           return error(
               "Bad stri table: uncompress {0} -> {1} bytes is implausible",
               R.rest().size(), UncompressedSize);
 
         if (llvm::Error E = CompressionScheme->decompress(
                 llvm::arrayRefFromStringRef(R.rest()), UncompressedStorage,
                 UncompressedSize))
           return std::move(E);
         Uncompressed = toStringRef(UncompressedStorage);
-    } else
-      return error("Compressed string table, but " +
+      }
+    }
+    else return error("Compressed string table, but " +
                       (CompressionScheme->Name + " is unavailable").str());
   }
 
   StringTableIn Table;
   llvm::StringSaver Saver(Table.Arena);
   R = Reader(Uncompressed);
   for (Reader R(Uncompressed); !R.eof();) {
     auto Len = R.rest().find(0);
     if (Len == llvm::StringRef::npos)

clang/include/clang/Serialization/ASTBitCodes.h

enum SourceManagerRecordTypes {
   SM_SLOC_BUFFER_BLOB = 3,
 
   /// Describes a zlib-compressed blob that contains the data for
   /// a buffer entry.
   SM_SLOC_BUFFER_BLOB_COMPRESSED = 4,
 
   /// Describes a source location entry (SLocEntry) for a
   /// macro expansion.
-  SM_SLOC_EXPANSION_ENTRY = 5
+  SM_SLOC_EXPANSION_ENTRY = 5,
+
+  /// Describes a compressed blob that contains the data for
+  /// a buffer entry with a size header (like SM_SLOC_BUFFER_BLOB_COMPRESSED)
+  /// but also a part in the record to indicate which compression algorithm.
+  SM_SLOC_BUFFER_BLOB_COMPRESSED_DYNAMIC = 6,
 };
 
 /// Record types used within a preprocessor block.
 enum PreprocessorRecordTypes {
   // The macros in the PP section are a PP_MACRO_* instance followed by a
   // list of PP_TOKEN instances for each token in the definition.
 
   /// An object-like macro definition.

clang/include/clang/Serialization/ASTWriter.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
+#include "llvm/Support/Compression.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <ctime>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
public:
   friend class ASTDeclWriter;
   friend class ASTRecordWriter;
 
   using RecordData = SmallVector<uint64_t, 64>;
   using RecordDataImpl = SmallVectorImpl<uint64_t>;
   using RecordDataRef = ArrayRef<uint64_t>;
 
 private:
+  llvm::compression::OptionalCompressionKind OptionalCompressionScheme;
   /// Map that provides the ID numbers of each type within the
   /// output stream, plus those deserialized from a chained PCH.
   ///
   /// The ID numbers of types are consecutive (in order of discovery)
   /// and start at 1. 0 is reserved for NULL. When types are actually
   /// stored in the stream, the ID number is shifted by 2 bits to
   /// allow for the const/volatile qualifiers.
   ///
private:
   void WriteDecl(ASTContext &Context, Decl *D);
 
   ASTFileSignature WriteASTCore(Sema &SemaRef, StringRef isysroot,
                                 StringRef OutputFile, Module *WritingModule);
 
 public:
   /// Create a new precompiled header writer that outputs to
   /// the given bitstream.
-  ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
-            InMemoryModuleCache &ModuleCache,
-            ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
-            bool IncludeTimestamps = true);
+  ASTWriter(
+      llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
+      llvm::compression::OptionalCompressionKind OptionalCompressionScheme,
   ~ASTWriter() override;
 
   ASTContext &getASTContext() const {
     assert(Context && "requested AST context when not writing AST");
     return *Context;
   }
 
   const LangOptions &getLangOpts() const;

clang/lib/CodeGen/CoverageMappingGen.cpp

 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
 #include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
 #include "llvm/ProfileData/InstrProfReader.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 // This selects the coverage mapping format defined when `InstrProfData.inc`
 // is textually included.
 #define COVMAP_V3
 
 static llvm::cl::opt<bool> EmptyLineCommentCoverage(
void CoverageMappingModuleGen::emit() {
   for (const auto &Entry : FileEntries) {
     auto I = Entry.second;
     FilenameStrs[I] = normalizeFilename(Entry.first->getName());
   }
 
   std::string Filenames;
   {
     llvm::raw_string_ostream OS(Filenames);
-    CoverageFilenamesSectionWriter(FilenameStrs).write(OS);
+    CoverageFilenamesSectionWriter(FilenameStrs)
+        .write(OS, llvm::compression::ZlibCompression);
   }
   auto *FilenamesVal =
       llvm::ConstantDataArray::getString(Ctx, Filenames, false);
   const int64_t FilenamesRef = llvm::IndexedInstrProf::ComputeHash(Filenames);
 
   // Emit the function records.
   for (const FunctionInfo &Info : FunctionRecords)
     emitFunctionMappingRecord(Info, FilenamesRef);

clang/lib/Driver/ToolChains/Clang.cpp

if (Value == "none") {
       CmdArgs.push_back("--compress-debug-sections=none");
     } else if (Value == "zlib") {
       if (llvm::compression::CompressionKind::Zlib) {
         CmdArgs.push_back(
             Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
       } else {
         D.Diag(diag::warn_debug_compression_unavailable);
       }
+    } else if (Value == "zstd") {
+      if (llvm::compression::CompressionKind::ZStd->supported()) {
+        CmdArgs.push_back(
+            Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
+      } else {
+        D.Diag(diag::warn_debug_compression_unavailable);
+      }
     } else {
       D.Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
 }
 
 static const char *RelocationModelName(llvm::Reloc::Model Model) {

clang/lib/Frontend/ASTUnit.cpp

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/DJB.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Timer.h"

 }
 
 struct ASTUnit::ASTWriterData {
   SmallString<128> Buffer;
   llvm::BitstreamWriter Stream;
   ASTWriter Writer;
 
   ASTWriterData(InMemoryModuleCache &ModuleCache)
-      : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {}) {}
+      : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {},
+                               llvm::compression::ZlibCompression) {}
 };
 
 void ASTUnit::clearFileLevelDecls() {
   FileDecls.clear();
 }
 
 /// After failing to build a precompiled preamble (due to
 /// errors in the source that occurs in the preamble), the number of
bool ASTUnit::serialize(raw_ostream &OS) {
 
   if (WriterData)
     return serializeUnit(WriterData->Writer, WriterData->Buffer,
                          getSema(), hasErrors, OS);
 
   SmallString<128> Buffer;
   llvm::BitstreamWriter Stream(Buffer);
   InMemoryModuleCache ModuleCache;
-  ASTWriter Writer(Stream, Buffer, ModuleCache, {});
+  ASTWriter Writer(Stream, Buffer, ModuleCache, {},
+                   llvm::compression::ZlibCompression);
   return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS);
 }
 
 using SLocRemap = ContinuousRangeMap<unsigned, int, 2>;
 
 void ASTUnit::TranslateStoredDiagnostics(
                           FileManager &FileMgr,
                           SourceManager &SrcMgr,

clang/lib/Serialization/ASTReader.cpp

auto ReadBuffer = [this](
     Expected<unsigned> MaybeRecCode =
         SLocEntryCursor.readRecord(Code, Record, &Blob);
     if (!MaybeRecCode) {
       Error(MaybeRecCode.takeError());
       return nullptr;
     }
     unsigned RecCode = MaybeRecCode.get();
 
-    if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
-      uint8_t CompressionSchemeId = llvm::compression::CompressionKind::Zlib;
+    if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED ||
+        RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED_DYNAMIC) {
+      uint8_t CompressionSchemeId =
+          RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED
+              ? uint8_t(llvm::compression::CompressionKind::Zlib)
+              : Record[1];
       llvm::compression::OptionalCompressionKind OptionalCompressionScheme =
           llvm::compression::getOptionalCompressionKind(CompressionSchemeId);
       if (!OptionalCompressionScheme) {
         return llvm::MemoryBuffer::getMemBuffer(Blob, Name, true);
       }
       llvm::compression::CompressionKind CompressionScheme =
           *OptionalCompressionScheme;
       if (!CompressionScheme) {
         Error("compression class " +
               (CompressionScheme->Name + " is not available").str());
         return nullptr;
       }
       SmallVector<uint8_t, 0> Uncompressed;
       if (llvm::Error E = CompressionScheme->decompress(
               llvm::arrayRefFromStringRef(Blob), Uncompressed, Record[0])) {
         Error("could not decompress embedded file contents: " +
               llvm::toString(std::move(E)));
         return nullptr;
       }
       return llvm::MemoryBuffer::getMemBufferCopy(
           llvm::toStringRef(Uncompressed), Name);
+
     } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
       return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
     } else {
       Error("AST record has invalid code");
       return nullptr;
     }
   };
 

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
 
   // SourceManager Block.
   BLOCK(SOURCE_MANAGER_BLOCK);
   RECORD(SM_SLOC_FILE_ENTRY);
   RECORD(SM_SLOC_BUFFER_ENTRY);
   RECORD(SM_SLOC_BUFFER_BLOB);
   RECORD(SM_SLOC_BUFFER_BLOB_COMPRESSED);
   RECORD(SM_SLOC_EXPANSION_ENTRY);
+  RECORD(SM_SLOC_BUFFER_BLOB_COMPRESSED_DYNAMIC);
 
   // Preprocessor Block.
   BLOCK(PREPROCESSOR_BLOCK);
   RECORD(PP_MACRO_DIRECTIVE_HISTORY);
   RECORD(PP_MACRO_FUNCTION_LIKE);
   RECORD(PP_MACRO_OBJECT_LIKE);
   RECORD(PP_MODULE_MACRO);
   RECORD(PP_TOKEN);
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
   return Stream.EmitAbbrev(std::move(Abbrev));
 }
 
 /// Create an abbreviation for the SLocEntry that refers to a
 /// buffer's blob.
 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream,
-                                           bool Compressed) {
+                                           bool Compressed,
+                                           bool CompressedDynamic) {
   using namespace llvm;
 
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
-  Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED
-                                         : SM_SLOC_BUFFER_BLOB));
-  if (Compressed)
+  Abbrev->Add(BitCodeAbbrevOp(CompressedDynamic
+                                  ? SM_SLOC_BUFFER_BLOB_COMPRESSED_DYNAMIC
+                                  : (Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED
+                                                : SM_SLOC_BUFFER_BLOB)));
+
+  if (Compressed || CompressedDynamic)
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size
+  if (CompressedDynamic) {
+    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Compression Scheme
+  }
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
   return Stream.EmitAbbrev(std::move(Abbrev));
 }
 
 /// Create an abbreviation for the SLocEntry that refers to a macro
 /// expansion.
 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
   using namespace llvm;
void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) {
   TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
   Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData);
 
   // Free all of the strings we had to duplicate.
   for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
     free(const_cast<char *>(SavedStrings[I]));
 }
 
-static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
-                     unsigned SLocBufferBlobCompressedAbbrv,
-                     unsigned SLocBufferBlobAbbrv) {
+static void
+emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
+         unsigned SLocBufferBlobCompressedDynamicAbbrv,
+         unsigned SLocBufferBlobAbbrv,
+         llvm::compression::OptionalCompressionKind OptionalCompressionScheme) {
   using RecordDataType = ASTWriter::RecordData::value_type;
 
   // Compress the buffer if possible. We expect that almost all PCM
   // consumers will not want its contents.
-  llvm::compression::OptionalCompressionKind OptionalCompressionScheme =
-      llvm::compression::CompressionKind::Zlib;
 
   OptionalCompressionScheme =
       compression::noneIfUnsupported(OptionalCompressionScheme);
   if (OptionalCompressionScheme) {
     llvm::compression::CompressionKind CompressionScheme =
         *OptionalCompressionScheme;
     SmallVector<uint8_t, 0> CompressedBuffer;
 
     CompressionScheme->compress(llvm::arrayRefFromStringRef(Blob.drop_back(1)),
                                 CompressedBuffer);
-    RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1};
+    // if our chosen CompressionAlgorithm happens to be zlib output old format
+    // for extra back compat
+    if (CompressionScheme == llvm::compression::CompressionKind::Zlib) {
+
+      RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED,
+                                 Blob.size() - 1};
       Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record,
                                 llvm::toStringRef(CompressedBuffer));
       return;
     }
+    RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED_DYNAMIC,
+                               Blob.size() - 1, uint8_t(CompressionScheme)};
+    Stream.EmitRecordWithBlob(SLocBufferBlobCompressedDynamicAbbrv, Record,
+                              llvm::toStringRef(CompressedBuffer));
+    return;
+  }
 
   RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB};
   Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob);
 }
 
 /// Writes the block containing the serialized form of the
 /// source manager.
 ///
 /// TODO: We should probably use an on-disk hash table (stored in a
 /// blob), indexed based on the file name, so that we only create
 /// entries for files that we actually need. In the common case (no
 /// errors), we probably won't have to create file entries for any of
 /// the files in the AST.
 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
                                         const Preprocessor &PP) {
   RecordData Record;
 
   // Enter the source manager block.
   Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4);
   const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
 
   // Abbreviations for the various kinds of source-location entries.
   unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
   unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
-  unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false);
+  unsigned SLocBufferBlobAbbrv =
+      CreateSLocBufferBlobAbbrev(Stream, false, false);
   unsigned SLocBufferBlobCompressedAbbrv =
-      CreateSLocBufferBlobAbbrev(Stream, true);
+      CreateSLocBufferBlobAbbrev(Stream, true, false);
+  unsigned SLocBufferBlobCompressedDynamicAbbrv =
+      CreateSLocBufferBlobAbbrev(Stream, true, true);
   unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
 
   // Write out the source location entry table. We skip the first
   // entry, which is always the same dummy entry.
   std::vector<uint32_t> SLocEntryOffsets;
   uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
   RecordData PreloadSLocs;
   SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
if (SLoc->isFile()) {
         // Include the implicit terminating null character in the on-disk buffer
         // if we're writing it uncompressed.
         llvm::Optional<llvm::MemoryBufferRef> Buffer =
             Content->getBufferOrNone(PP.getDiagnostics(), PP.getFileManager());
         if (!Buffer)
           Buffer = llvm::MemoryBufferRef("<<<INVALID BUFFER>>>", "");
         StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
         emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
-                 SLocBufferBlobAbbrv);
+                 SLocBufferBlobCompressedDynamicAbbrv, SLocBufferBlobAbbrv,
+                 CompressionScheme);
       }
     } else {
       // The source location entry is a macro expansion.
       const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
       LocSeq::State Seq;
       AddSourceLocation(Expansion.getSpellingLoc(), Record, Seq);
       AddSourceLocation(Expansion.getExpansionLocStart(), Record, Seq);
       AddSourceLocation(Expansion.isMacroArgExpansion()
void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
   assert(ID && "Unknown selector");
   // Don't record offsets for selectors that are also available in a different
   // file.
   if (ID < FirstSelectorID)
     return;
   SelectorOffsets[ID - FirstSelectorID] = Offset;
 }
 
-ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream,
-                     SmallVectorImpl<char> &Buffer,
-                     InMemoryModuleCache &ModuleCache,
-                     ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
-                     bool IncludeTimestamps)
+ASTWriter::ASTWriter(
+    llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
+    llvm::compression::OptionalCompressionKind OptionalCompressionScheme,
     : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
+      CompressionScheme(CompressionScheme),
       IncludeTimestamps(IncludeTimestamps) {
   for (const auto &Ext : Extensions) {
     if (auto Writer = Ext->createExtensionWriter(*this))
       ModuleFileExtensionWriters.push_back(std::move(Writer));
   }
 }
 
 ASTWriter::~ASTWriter() = default;

clang/lib/Serialization/GeneratePCH.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Serialization/ASTWriter.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
+#include "llvm/Support/Compression.h"
 
 using namespace clang;
 
 PCHGenerator::PCHGenerator(
     const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
     StringRef OutputFile, StringRef isysroot, std::shared_ptr<PCHBuffer> Buffer,
     ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
     bool AllowASTWithErrors, bool IncludeTimestamps,
     bool ShouldCacheASTInMemory, bool OutputPathIndependent)
     : PP(PP), OutputFile(OutputFile), isysroot(isysroot.str()),
       SemaPtr(nullptr), Buffer(std::move(Buffer)), Stream(this->Buffer->Data),
       Writer(Stream, this->Buffer->Data, ModuleCache, Extensions,
-             IncludeTimestamps),
+             llvm::compression::ZlibCompression, IncludeTimestamps),
       AllowASTWithErrors(AllowASTWithErrors),
       ShouldCacheASTInMemory(ShouldCacheASTInMemory),
       OutputPathIndependent(OutputPathIndependent) {
   this->Buffer->IsComplete = false;
 }
 
 PCHGenerator::~PCHGenerator() {
 }

clang/test/CodeGen/coverage-compilation-dir.c

 // RUN: mkdir -p %t.dir && cd %t.dir
 // RUN: cp %s rel.c
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-compilation-dir=/nonsense -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false rel.c -o - | FileCheck -check-prefix=CHECK-NONSENSE %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-compilation-dir=/nonsense -fcoverage-mapping -emit-llvm -mllvm -name-compression=none rel.c -o - | FileCheck -check-prefix=CHECK-NONSENSE %s
 
 // CHECK-NONSENSE: nonsense
 
 void f(void) {}

clang/test/CoverageMapping/abspath.cpp

-// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false -emit-llvm -main-file-name abspath.cpp %S/Inputs/../abspath.cpp -o - | FileCheck -check-prefix=RMDOTS %s
+// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -mllvm -name-compression=none -emit-llvm -main-file-name abspath.cpp %S/Inputs/../abspath.cpp -o - | FileCheck -check-prefix=RMDOTS %s
 
 // RMDOTS: @__llvm_coverage_mapping = {{.*}}"\02
 // RMDOTS-NOT: Inputs
 // RMDOTS: "
 
 // RUN: mkdir -p %t/test && cd %t/test
 // RUN: echo "void f1(void) {}" > f1.c
-// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false -emit-llvm -main-file-name abspath.cpp %t/test/f1.c -o - | FileCheck -check-prefix=ABSPATH %s
+// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -mllvm -name-compression=none -emit-llvm -main-file-name abspath.cpp %t/test/f1.c -o - | FileCheck -check-prefix=ABSPATH %s
 
 // RELPATH: @__llvm_coverage_mapping = {{.*}}"\02
 // RELPATH: {{..(/|\\\\)test(/|\\\\)f1}}.c
 // RELPATH: "
 
 // ABSPATH: @__llvm_coverage_mapping = {{.*}}"\02
 // ABSPATH: {{[/\\].*(/|\\\\)test(/|\\\\)f1}}.c
 // ABSPATH: "
 
 void f1(void) {}

clang/test/CoverageMapping/ir.c

 // Check the data structures emitted by coverage mapping
-// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false -no-opaque-pointers | FileCheck %s -check-prefixes=COMMON,DARWIN
-// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false -opaque-pointers | FileCheck %s -check-prefixes=COMMON,DARWIN
-// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64--windows-msvc -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false | FileCheck %s -check-prefixes=COMMON,WINDOWS
+// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -name-compression=none -no-opaque-pointers | FileCheck %s -check-prefixes=COMMON,DARWIN
+// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -name-compression=none -opaque-pointers | FileCheck %s -check-prefixes=COMMON,DARWIN
+// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64--windows-msvc -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -name-compression=none | FileCheck %s -check-prefixes=COMMON,WINDOWS
 
 static inline void unused(void) {}
 
 void foo(void) {}
 
 int main(void) {
   foo();
   return 0;

clang/test/Profile/coverage-prefix-map.c

 // %s expands to an absolute path, so to test relative paths we need to create a
 // clean directory, put the source there, and cd into it.
 // RUN: rm -rf %t
 // RUN: mkdir -p %t/root/nested
 // RUN: echo "void f1(void) {}" > %t/root/nested/coverage-prefix-map.c
 // RUN: cd %t/root
 
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -o - | FileCheck --check-prefix=ABSOLUTE %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -name-compression=none -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -o - | FileCheck --check-prefix=ABSOLUTE %s
 //
 // ABSOLUTE: @__llvm_coverage_mapping = {{.*"\\02.*root.*nested.*coverage-prefix-map\.c}}
 
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false -main-file-name coverage-prefix-map.c ../root/nested/coverage-prefix-map.c -o - | FileCheck --check-prefix=RELATIVE %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -name-compression=none -main-file-name coverage-prefix-map.c ../root/nested/coverage-prefix-map.c -o - | FileCheck --check-prefix=RELATIVE %s
 //
 // RELATIVE: @__llvm_coverage_mapping = {{.*"\\02.*}}..{{/|\\+}}root{{/|\\+}}nested{{.*coverage-prefix-map\.c}}
 
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -fcoverage-prefix-map=%/t/root=. -o - | FileCheck --check-prefix=COVERAGE-PREFIX-MAP %s
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false -main-file-name coverage-prefix-map.c ../root/nested/coverage-prefix-map.c -fcoverage-prefix-map=../root=. -o - | FileCheck --check-prefix=COVERAGE-PREFIX-MAP %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -name-compression=none -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -fcoverage-prefix-map=%/t/root=. -o - | FileCheck --check-prefix=COVERAGE-PREFIX-MAP %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -name-compression=none -main-file-name coverage-prefix-map.c ../root/nested/coverage-prefix-map.c -fcoverage-prefix-map=../root=. -o - | FileCheck --check-prefix=COVERAGE-PREFIX-MAP %s
 // COVERAGE-PREFIX-MAP: @__llvm_coverage_mapping = {{.*"\\02.*}}.{{/|\\+}}nested{{.*coverage-prefix-map\.c}}
 
-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -enable-name-compression=false -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -fcoverage-compilation-dir=/custom -fcoverage-prefix-map=/custom=/nonsense -o - | FileCheck --check-prefix=COVERAGE-COMPILATION-DIR %s
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -mllvm -name-compression=none -main-file-name coverage-prefix-map.c %t/root/nested/coverage-prefix-map.c -fcoverage-compilation-dir=/custom -fcoverage-prefix-map=/custom=/nonsense -o - | FileCheck --check-prefix=COVERAGE-COMPILATION-DIR %s
 // COVERAGE-COMPILATION-DIR: @__llvm_coverage_mapping = {{.*"\\02.*}}nonsense

compiler-rt/include/profile/InstrProfData.inc

#define INSTR_PROF_RAW_MAGIC_64 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
        (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
         (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129
 #define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
        (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
         (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
 
 /* FIXME: Please remedy the fixme in the header before bumping the version. */
 /* Raw profile format version (start from 1). */
-#define INSTR_PROF_RAW_VERSION 8
+#define INSTR_PROF_RAW_VERSION 9
 /* Indexed profile format version (start from 1). */
-#define INSTR_PROF_INDEX_VERSION 8
+#define INSTR_PROF_INDEX_VERSION 9
 /* Coverage mapping format version (start from 0). */
-#define INSTR_PROF_COVMAP_VERSION 5
+#define INSTR_PROF_COVMAP_VERSION 6
 
 /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
  * version for other variants of profile. We set the lowest bit of the upper 8
  * bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation
  * generated profile, and 0 if this is a Clang FE generated profile.
  * 1 in bit 57 indicates there are context-sensitive records in the profile.
  * The 59th bit indicates whether to use debug info to correlate profiles.
  * The 60th bit indicates single byte coverage instrumentation.

compiler-rt/test/profile/instrprof-darwin-dead-strip.c

 // REQUIRES: osx-ld64-live_support
 // REQUIRES: lto
 
-// RUN: %clang_profgen=%t.profraw -fcoverage-mapping -mllvm -enable-name-compression=false -DCODE=1 -Wl,-dead_strip -o %t %s
+// RUN: %clang_profgen=%t.profraw -fcoverage-mapping -mllvm -name-compression=none -DCODE=1 -Wl,-dead_strip -o %t %s
 // RUN: %run %t
 // RUN: llvm-profdata merge -o %t.profdata %t.profraw
 // RUN: llvm-profdata show --all-functions %t.profdata | FileCheck %s -check-prefix=PROF
 // RUN: llvm-cov show %t -instr-profile %t.profdata | FileCheck %s -check-prefix=COV
 // RUN: nm %t | FileCheck %s -check-prefix=NM
 // RUN: otool -V -s __DATA __llvm_prf_names %t | FileCheck %s -check-prefix=PRF_NAMES
 // RUN: otool -V -s __DATA __llvm_prf_cnts %t | FileCheck %s -check-prefix=PRF_CNTS
 
-// RUN: %clang_lto_profgen=%t.lto.profraw -fcoverage-mapping -mllvm -enable-name-compression=false -DCODE=1 -Wl,-dead_strip -flto -o %t.lto %s
+// RUN: %clang_lto_profgen=%t.lto.profraw -fcoverage-mapping -mllvm -name-compression=none -DCODE=1 -Wl,-dead_strip -flto -o %t.lto %s
 // RUN: %run %t.lto
 // RUN: llvm-profdata merge -o %t.lto.profdata %t.lto.profraw
 // RUN: llvm-profdata show --all-functions %t.lto.profdata | FileCheck %s -check-prefix=PROF
 // RUN: llvm-cov show %t.lto -instr-profile %t.lto.profdata | FileCheck %s -check-prefix=COV
 // RUN: nm %t.lto | FileCheck %s -check-prefix=NM
 // RUN: otool -V -s __DATA __llvm_prf_names %t.lto | FileCheck %s -check-prefix=PRF_NAMES
 // RUN: otool -V -s __DATA __llvm_prf_cnts %t.lto | FileCheck %s -check-prefix=PRF_CNTS
 

compiler-rt/test/profile/instrprof-gc-sections.c

 // REQUIRES: linux, lld-available
 
 // RUN: rm -rf %t.profraw
-// RUN: %clang_profgen=%t.profraw -fuse-ld=lld -fcoverage-mapping -mllvm -enable-name-compression=false -DCODE=1 -ffunction-sections -fdata-sections -Wl,--gc-sections -o %t %s
+// RUN: %clang_profgen=%t.profraw -fuse-ld=lld -fcoverage-mapping -mllvm -name-compression=none -DCODE=1 -ffunction-sections -fdata-sections -Wl,--gc-sections -o %t %s
 // RUN: %run %t
 // RUN: llvm-profdata merge -o %t.profdata %t.profraw
 // RUN: llvm-profdata show --all-functions %t.profdata | FileCheck %s -check-prefix=PROF
 // RUN: llvm-cov show %t -instr-profile %t.profdata | FileCheck %s -check-prefix=COV
 // RUN: llvm-nm %t | FileCheck %s -check-prefix=NM
 // RUN: llvm-readelf -x __llvm_prf_names %t | FileCheck %s -check-prefix=PRF_NAMES
 // RUN: llvm-size -A %t | FileCheck %s -check-prefix=PRF_CNTS
 
 // RUN: rm -rf %t.lto.profraw
-// RUN: %clang_lto_profgen=%t.lto.profraw -fuse-ld=lld -fcoverage-mapping -mllvm -enable-name-compression=false -DCODE=1 -ffunction-sections -fdata-sections -Wl,--gc-sections -flto -o %t.lto %s
+// RUN: %clang_lto_profgen=%t.lto.profraw -fuse-ld=lld -fcoverage-mapping -mllvm -name-compression=none -DCODE=1 -ffunction-sections -fdata-sections -Wl,--gc-sections -flto -o %t.lto %s
 // RUN: %run %t.lto
 // RUN: llvm-profdata merge -o %t.lto.profdata %t.lto.profraw
 // RUN: llvm-profdata show --all-functions %t.lto.profdata | FileCheck %s -check-prefix=PROF
 // RUN: llvm-cov show %t.lto -instr-profile %t.lto.profdata | FileCheck %s -check-prefix=COV
 // RUN: llvm-nm %t.lto | FileCheck %s -check-prefix=NM
 // RUN: llvm-readelf -x __llvm_prf_names %t.lto | FileCheck %s -check-prefix=PRF_NAMES
 // RUN: llvm-size -A %t.lto | FileCheck %s -check-prefix=PRF_CNTS
 

lld/ELF/Driver.cpp

 
 static bool getCompressDebugSections(opt::InputArgList &args) {
   StringRef s = args.getLastArgValue(OPT_compress_debug_sections, "none");
   if (s == "none") {
     return false;
   } else if (s == "zlib") {
     if (!compression::CompressionKind::Zlib)
       error("--compress-debug-sections: zlib is not available");
+  } else if (s == "zstd") {
+    if (!compression::CompressionKind::ZStd->supported())
+      error("--compress-debug-sections: zstd is not available");
   } else {
     error("unknown --compress-debug-sections value: " + s);
   }
 
   return true;
 }
 
 static StringRef getAliasSpelling(opt::Arg *arg) {

lld/ELF/InputSection.cpp

 size_t InputSectionBase::getSize() const {
   if (auto *s = dyn_cast<SyntheticSection>(this))
     return s->getSize();
   if (uncompressedSize >= 0)
     return uncompressedSize;
   return rawData.size() - bytesDropped;
 }
 
+template <class ELFT>
+static void uncompressAux(const InputSectionBase *sec, uint8_t *out,
+                          size_t size) {
+  auto *hdr =
+      reinterpret_cast<const typename ELFT::Chdr *>(sec->rawData.data());
+  ArrayRef<uint8_t> compressed =
+      sec->rawData.slice(sizeof(typename ELFT::Chdr));
+  if (Error e = (hdr->ch_type == ELFCOMPRESS_ZLIB
+                     ? compression::CompressionKind::Zlib->decompress(
+                           compressed, out, size)
+                     : compression::CompressionKind::ZStd->decompress(
+                           compressed, out, size)))
+    fatal(toString(sec) +
+          ": uncompress failed: " + llvm::toString(std::move(e)));
+}
+
 void InputSectionBase::uncompress() const {
   size_t size = uncompressedSize;
   uint8_t *uncompressedBuf;
   {
     static std::mutex mu;
     std::lock_guard<std::mutex> lock(mu);
     uncompressedBuf = bAlloc().Allocate<uint8_t>(size);
   }
-
-  if (Error e = compression::CompressionKind::Zlib->decompress(
-          rawData, uncompressedBuf, size))
-    fatal(toString(this) +
-          ": uncompress failed: " + llvm::toString(std::move(e)));
+  invokeELFT(uncompressAux, this, uncompressedBuf, size);
   rawData = makeArrayRef(uncompressedBuf, size);
   uncompressedSize = -1;
 }
 
 template <class ELFT> RelsOrRelas<ELFT> InputSectionBase::relsOrRelas() const {
   if (relSecIdx == 0)
     return {};
   RelsOrRelas<ELFT> ret;
OutputSection *SectionBase::getOutputSection() {
   else if (auto *eh = dyn_cast<EhInputSection>(this))
     sec = eh->getParent();
   else
     return cast<OutputSection>(this);
   return sec ? sec->getParent() : nullptr;
 }
 
 // When a section is compressed, `rawData` consists with a header followed
-// by zlib-compressed data. This function parses a header to initialize
+// by zlib or zstd-compressed data. This function parses a header to initialize
 // `uncompressedSize` member and remove the header from `rawData`.
 template <typename ELFT> void InputSectionBase::parseCompressedHeader() {
   flags &= ~(uint64_t)SHF_COMPRESSED;
 
   // New-style header
   if (rawData.size() < sizeof(typename ELFT::Chdr)) {
     error(toString(this) + ": corrupted compressed section");
     return;
   }
 
   auto *hdr = reinterpret_cast<const typename ELFT::Chdr *>(rawData.data());
   if (hdr->ch_type == ELFCOMPRESS_ZLIB) {
     if (!compression::CompressionKind::Zlib)
       error(toString(this) + " is compressed with ELFCOMPRESS_ZLIB, but lld is "
                              "not built with zlib support");
+  } else if (hdr->ch_type == ELFCOMPRESS_ZSTD) {
+    if (!compression::CompressionKind::ZStd->supported())
+      error(toString(this) + " is compressed with ELFCOMPRESS_ZSTD, but lld is "
+                             "not built with zstd support");
   } else {
     error(toString(this) + ": unsupported compression type (" +
           Twine(hdr->ch_type) + ")");
     return;
   }
 
   uncompressedSize = hdr->ch_size;
   alignment = std::max<uint32_t>(hdr->ch_addralign, 1);
if (hdr->ch_type == ELFCOMPRESS_ZLIB) {
               " is compressed with ELFCOMPRESS_ZLIB, but lld is "
               "not built with zlib support");
       } else {
         if (Error e = compression::CompressionKind::Zlib->decompress(
                 rawData.slice(sizeof(typename ELFT::Chdr)), buf, size))
           fatal(toString(this) +
                 ": uncompress failed: " + llvm::toString(std::move(e)));
       }
+    } else if (hdr->ch_type == ELFCOMPRESS_ZSTD) {
+      if (!compression::CompressionKind::ZStd->supported()) {
+        error(toString(this) +
+              " is compressed with ELFCOMPRESS_ZSTD, but lld is "
+              "not built with zstd support");
+      } else {
+        if (Error e = compression::CompressionKind::ZStd->decompress(
+                rawData.slice(sizeof(typename ELFT::Chdr)), buf, size))
+          fatal(toString(this) +
+                ": uncompress failed: " + llvm::toString(std::move(e)));
+      }
     } else {
       error(toString(this) + ": unsupported compression type (" +
             Twine(hdr->ch_type) + ")");
       return;
     }
     uint8_t *bufEnd = buf + size;
     relocate<ELFT>(buf, bufEnd);
     return;

lld/test/CMakeLists.txt

 llvm_canonicalize_cmake_booleans(
   ENABLE_BACKTRACES
   LLVM_ENABLE_ZLIB
+  LLVM_ENABLE_ZSTD
   LLVM_ENABLE_LIBXML2
   LLD_DEFAULT_LD_LLD_IS_MINGW
   LLVM_HAVE_LIBXAR
   LLVM_BUILD_EXAMPLES
   LLVM_ENABLE_PLUGINS
   LLVM_BYE_LINK_INTO_TOOLS
   )
 

lld/test/ELF/compressed-debug-input-zstd.s

+# REQUIRES: x86, zstd
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 --compress-debug-sections=zstd %s -o %t.o
+
+# RUN: ld.lld %t.o -o %t.so -shared
+# RUN: llvm-readobj --sections --section-data %t.so | FileCheck -check-prefix=DATA %s
+
+# DATA:      Section {
+# DATA:        Index: 6
+# DATA:        Name: .debug_str
+# DATA-NEXT:   Type: SHT_PROGBITS
+# DATA-NEXT:   Flags [
+# DATA-NEXT:     SHF_MERGE (0x10)
+# DATA-NEXT:     SHF_STRINGS (0x20)
+# DATA-NEXT:   ]
+# DATA-NEXT:   Address: 0x0
+# DATA-NEXT:   Offset:
+# DATA-NEXT:   Size: 69
+# DATA-NEXT:   Link: 0
+# DATA-NEXT:   Info: 0
+# DATA-NEXT:   AddressAlignment: 1
+# DATA-NEXT:   EntrySize: 1
+# DATA-NEXT:   SectionData (
+# DATA-NEXT:     0000: 756E7369 676E6564 20696E74 00636861  |unsigned int.cha|
+# DATA-NEXT:     0010: 7200756E 7369676E 65642063 68617200  |r.unsigned char.|
+# DATA-NEXT:     0020: 73686F72 7420756E 7369676E 65642069  |short unsigned i|
+# DATA-NEXT:     0030: 6E74006C 6F6E6720 756E7369 676E6564  |nt.long unsigned|
+# DATA-NEXT:     0040: 20696E74 00                          | int.|
+# DATA-NEXT:   )
+# DATA-NEXT: }
+
+.section .debug_str,"MS",@progbits,1
+.LASF2:
+ .string "short unsigned int"
+.LASF3:
+ .string "unsigned int"
+.LASF0:
+ .string "long unsigned int"
+.LASF8:
+ .string "char"
+.LASF1:
+ .string "unsigned char"

lld/test/ELF/compressed-input-err-zstd.s

+# UNSUPPORTED: zstd
+# RUN: yaml2obj %s -o %t.o
+# RUN: not ld.lld %t.o -o /dev/null 2>&1 | FileCheck %s
+
+# CHECK: error: {{.*}}.o:(.debug_info) is compressed with ELFCOMPRESS_ZSTD, but lld is not built with zstd support
+
+--- !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:      "020000000000000000000000000000000100000000000000789c030000000001"

lld/test/lit.site.cfg.py.in

 config.enable_backtrace = @ENABLE_BACKTRACES@
 config.errc_messages = "@LLVM_LIT_ERRC_MESSAGES@"
 config.lld_obj_root = "@LLD_BINARY_DIR@"
 config.lld_libs_dir = lit_config.substitute("@CURRENT_LIBS_DIR@")
 config.lld_tools_dir = lit_config.substitute("@CURRENT_TOOLS_DIR@")
 config.target_triple = "@LLVM_TARGET_TRIPLE@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
+config.have_zstd = @LLVM_ENABLE_ZSTD@
 config.have_libxar = @LLVM_HAVE_LIBXAR@
 config.have_libxml2 = @LLVM_ENABLE_LIBXML2@
 config.sizeof_void_p = @CMAKE_SIZEOF_VOID_P@
 config.ld_lld_default_mingw = @LLD_DEFAULT_LD_LLD_IS_MINGW@
 config.build_examples = @LLVM_BUILD_EXAMPLES@
 config.has_plugins = @LLVM_ENABLE_PLUGINS@
 config.linked_bye_extension = @LLVM_BYE_LINK_INTO_TOOLS@
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLD_SOURCE_DIR@/test/lit.cfg.py")

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/include/llvm/MC/MCTargetOptions.h

enum class ExceptionHandling {
   WinEH,    ///< Windows Exception Handling
   Wasm,     ///< WebAssembly Exception Handling
   AIX,      ///< AIX Exception Handling
 };
 
 enum class DebugCompressionType {
   None, ///< No compression
   Z,    ///< zlib style complession
+  ZStd, ///< zstd style complession
 };
 
 enum class EmitDwarfUnwindType {
   Always,          // Always emit dwarf unwind
   NoCompactUnwind, // Only emit if compact unwind isn't available
   Default,         // Default behavior is based on the target
 };
 

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

enum CovMapVersion {
   Version3 = 2,
   // Function records are named, uniqued, and moved to a dedicated section.
   Version4 = 3,
   // Branch regions referring to two counters are added
   Version5 = 4,
   // Compilation directory is stored separately and combined with relative
   // filenames to produce an absolute file path.
   Version6 = 5,
-  // The current version is Version6.
+  // not just zlib compression
+  Version7 = 6,
+  // The current version is Version7.
   CurrentVersion = INSTR_PROF_COVMAP_VERSION
 };
 
 template <int CovMapVersion, class IntPtrT> struct CovMapTraits {
   using CovMapFuncRecordType = CovMapFunctionRecordV3;
   using NameRefType = uint64_t;
 };
 

llvm/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGWRITER_H
 #define LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGWRITER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
+#include "llvm/Support/Compression.h"
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace coverage {
 
 /// Writer of the filenames section for the instrumentation
 /// based code coverage.
 class CoverageFilenamesSectionWriter {
   ArrayRef<std::string> Filenames;
 
 public:
   CoverageFilenamesSectionWriter(ArrayRef<std::string> Filenames);
 
-  /// Write encoded filenames to the given output stream. If \p Compress is
-  /// true, attempt to compress the filenames.
-  void write(raw_ostream &OS, bool Compress = true);
+  /// Write encoded filenames to the given output stream. If \p
+  /// CompressionScheme is not an instance of
+  /// llvm::compression::NoneCompressionAlgorithm, attempt to compress the
+  /// filenames.
+  void write(raw_ostream &OS,
+             compression::OptionalCompressionKind OptionalCompressionScheme);
 };
 
 /// Writer for instrumentation based coverage mapping data.
 class CoverageMappingWriter {
   ArrayRef<unsigned> VirtualFileMapping;
   ArrayRef<CounterExpression> Expressions;
   MutableArrayRef<CounterMappingRegion> MappingRegions;
 

llvm/include/llvm/ProfileData/InstrProf.h

 /// second field will have value zero.
 Error collectPGOFuncNameStrings(
     ArrayRef<std::string> NameStrs,
     compression::OptionalCompressionKind OptionalCompressionScheme,
     std::string &Result);
 
 /// Produce \c Result string with the same format described above. The input
 /// is vector of PGO function name variables that are referenced.
-Error collectPGOFuncNameStrings(ArrayRef<GlobalVariable *> NameVars,
-                                std::string &Result, bool doCompression = true);
+Error collectPGOFuncNameStrings(
+    ArrayRef<GlobalVariable *> NameVars, std::string &Result,
+    compression::OptionalCompressionKind OptionalCompressionScheme);
 
 /// \c NameStrings is a string composed of one of more sub-strings encoded in
 /// the format described above. The substrings are separated by 0 or more zero
 /// bytes. This method decodes the string and populates the \c Symtab.
 Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab);
 
 /// Check if INSTR_PROF_RAW_VERSION_VAR is defined. This global is only being
 /// set in IR PGO compilation.
enum ProfVersion {
   Version5 = 5,
   // In this version, the frontend PGO stable hash algorithm got fixed and
   // may produce hashes different from Version5.
   Version6 = 6,
   // An additional counter is added around logical operators.
   Version7 = 7,
   // An additional (optional) memory profile type is added.
   Version8 = 8,
-  // The current version is 8.
+  // more compression types
+  Version9 = 9,
+  // The current version is 9.
   CurrentVersion = INSTR_PROF_INDEX_VERSION
 };
 const uint64_t Version = ProfVersion::CurrentVersion;
 
 const HashT HashType = HashT::MD5;
 
 inline uint64_t ComputeHash(StringRef K) { return ComputeHash(HashType, K); }
 

 void getMemOPSizeRangeFromOption(StringRef Str, int64_t &RangeStart,
                                  int64_t &RangeLast);
 
 // Create the variable for the profile file name.
 void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput);
 
 // Whether to compress function names in profile records, and filenames in
 // code coverage mappings. Used by the Instrumentation library and unit tests.
-extern cl::opt<bool> DoInstrProfNameCompression;
+extern cl::opt<compression::OptionalCompressionKind>
+    InstrProfNameCompressionScheme;
 
 } // end namespace llvm
 #endif // LLVM_PROFILEDATA_INSTRPROF_H

llvm/include/llvm/ProfileData/InstrProfData.inc

#define INSTR_PROF_RAW_MAGIC_64 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
        (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
         (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129
 #define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
        (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
         (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
 
 /* FIXME: Please remedy the fixme in the header before bumping the version. */
 /* Raw profile format version (start from 1). */
-#define INSTR_PROF_RAW_VERSION 8
+#define INSTR_PROF_RAW_VERSION 9
 /* Indexed profile format version (start from 1). */
-#define INSTR_PROF_INDEX_VERSION 8
+#define INSTR_PROF_INDEX_VERSION 9
 /* Coverage mapping format version (start from 0). */
-#define INSTR_PROF_COVMAP_VERSION 5
+#define INSTR_PROF_COVMAP_VERSION 6
 
 /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
  * version for other variants of profile. We set the lowest bit of the upper 8
  * bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation
  * generated profile, and 0 if this is a Clang FE generated profile.
  * 1 in bit 57 indicates there are context-sensitive records in the profile.
  * The 59th bit indicates whether to use debug info to correlate profiles.
  * The 60th bit indicates single byte coverage instrumentation.

llvm/include/llvm/ProfileData/SampleProfWriter.h

 //===----------------------------------------------------------------------===//
 #ifndef LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
 #define LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/SampleProf.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <memory>
 #include <set>
 #include <system_error>
 
 namespace llvm {
public:
   virtual std::error_code write(const SampleProfileMap &ProfileMap);
 
   raw_ostream &getOutputStream() { return *OutputStream; }
 
   /// Profile writer factory.
   ///
   /// Create a new file writer based on the value of \p Format.
   static ErrorOr<std::unique_ptr<SampleProfileWriter>>
-  create(StringRef Filename, SampleProfileFormat Format);
+  create(StringRef Filename, SampleProfileFormat Format,
+         compression::OptionalCompressionKind OptionalCompressionScheme);
 
   /// Create a new stream writer based on the value of \p Format.
   /// For testing.
   static ErrorOr<std::unique_ptr<SampleProfileWriter>>
-  create(std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format);
+  create(std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format,
+         compression::OptionalCompressionKind OptionalCompressionScheme);
 
   virtual void setProfileSymbolList(ProfileSymbolList *PSL) {}
   virtual void setToCompressAllSections() {}
   virtual void setUseMD5() {}
   virtual void setPartialProfile() {}
   virtual void resetSecLayout(SectionLayout SL) {}
 
 protected:
-  SampleProfileWriter(std::unique_ptr<raw_ostream> &OS)
-      : OutputStream(std::move(OS)) {}
+  SampleProfileWriter(
+      std::unique_ptr<raw_ostream> &OS,
+      compression::OptionalCompressionKind OptionalCompressionScheme)
+      : OutputStream(std::move(OS)),
+        OptionalCompressionScheme(OptionalCompressionScheme) {}
 
   /// Write a file header for the profile file.
   virtual std::error_code writeHeader(const SampleProfileMap &ProfileMap) = 0;
 
   // Write function profiles to the profile file.
   virtual std::error_code writeFuncProfiles(const SampleProfileMap &ProfileMap);
 
   /// Output stream where to emit the profile to.
   std::unique_ptr<raw_ostream> OutputStream;
 
   /// Profile summary.
   std::unique_ptr<ProfileSummary> Summary;
 
   /// Compute summary for this profile.
   void computeSummary(const SampleProfileMap &ProfileMap);
 
   /// Profile format.
   SampleProfileFormat Format = SPF_None;
+
+  /// Compression scheme;
+  compression::OptionalCompressionKind OptionalCompressionScheme;
 };
 
 /// Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:
   std::error_code writeSample(const FunctionSamples &S) override;
 
 protected:
-  SampleProfileWriterText(std::unique_ptr<raw_ostream> &OS)
-      : SampleProfileWriter(OS), Indent(0) {}
+  SampleProfileWriterText(
+      std::unique_ptr<raw_ostream> &OS,
+      compression::OptionalCompressionKind OptionalCompressionScheme)
+      : SampleProfileWriter(OS, OptionalCompressionScheme), Indent(0) {}
 
   std::error_code writeHeader(const SampleProfileMap &ProfileMap) override {
     return sampleprof_error::success;
   }
 
 private:
   /// Indent level to use when writing.
   ///
   /// This is used when printing inlined callees.
   unsigned Indent;
 
   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
-  SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
-                              SampleProfileFormat Format);
+  SampleProfileWriter::create(
+      std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format,
+      compression::OptionalCompressionKind OptionalCompressionScheme);
 };
 
 /// Sample-based profile writer (binary format).
 class SampleProfileWriterBinary : public SampleProfileWriter {
 public:
-  SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
-      : SampleProfileWriter(OS) {}
+  SampleProfileWriterBinary(
+      std::unique_ptr<raw_ostream> &OS,
+      compression::OptionalCompressionKind OptionalCompressionScheme)
+      : SampleProfileWriter(OS, OptionalCompressionScheme) {}
 
   std::error_code writeSample(const FunctionSamples &S) override;
 
 protected:
   virtual MapVector<StringRef, uint32_t> &getNameTable() { return NameTable; }
   virtual std::error_code writeMagicIdent(SampleProfileFormat Format);
   virtual std::error_code writeNameTable();
   std::error_code writeHeader(const SampleProfileMap &ProfileMap) override;
   std::error_code writeSummary();
   virtual std::error_code writeContextIdx(const SampleContext &Context);
   std::error_code writeNameIdx(StringRef FName);
   std::error_code writeBody(const FunctionSamples &S);
   inline void stablizeNameTable(MapVector<StringRef, uint32_t> &NameTable,
                                 std::set<StringRef> &V);
 
   MapVector<StringRef, uint32_t> NameTable;
 
   void addName(StringRef FName);
   virtual void addContext(const SampleContext &Context);
   void addNames(const FunctionSamples &S);
 
 private:
   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
-  SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
-                              SampleProfileFormat Format);
+  SampleProfileWriter::create(
+      std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format,
+      compression::OptionalCompressionKind OptionalCompressionScheme);
 };
 
 class SampleProfileWriterRawBinary : public SampleProfileWriterBinary {
   using SampleProfileWriterBinary::SampleProfileWriterBinary;
 };
 
 const std::array<SmallVector<SecHdrTableEntry, 8>, NumOfLayout>
     ExtBinaryHdrLayoutTable = {
private:
   /// The offset will be used everywhere where the context is referenced.
   MapVector<SampleContext, uint32_t> CSNameTable;
 
   ProfileSymbolList *ProfSymList = nullptr;
 };
 
 class SampleProfileWriterExtBinary : public SampleProfileWriterExtBinaryBase {
 public:
-  SampleProfileWriterExtBinary(std::unique_ptr<raw_ostream> &OS)
-      : SampleProfileWriterExtBinaryBase(OS) {}
+  SampleProfileWriterExtBinary(
+      std::unique_ptr<raw_ostream> &OS,
+      compression::OptionalCompressionKind OptionalCompressionScheme)
+      : SampleProfileWriterExtBinaryBase(OS, OptionalCompressionScheme) {}
 
 private:
   std::error_code writeDefaultLayout(const SampleProfileMap &ProfileMap);
   std::error_code writeCtxSplitLayout(const SampleProfileMap &ProfileMap);
 
   std::error_code writeSections(const SampleProfileMap &ProfileMap) override;
 
   std::error_code writeCustomSection(SecType Type) override {

llvm/include/llvm/Support/CommandLine.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
void printOptionDiff(const Option &O, StringRef V, const OptVal &Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
+extern template class basic_parser<compression::OptionalCompressionKind>;
+
+template <>
+class parser<compression::OptionalCompressionKind>
+    : public basic_parser<compression::OptionalCompressionKind> {
+public:
+  parser(Option &O) : basic_parser(O) {}
+
+  // Return true on error.
+  bool parse(Option &, StringRef, StringRef Arg,
+             compression::OptionalCompressionKind &Value);
+
+  // Overload in subclass to provide a better default value.
+  StringRef getValueName() const override { return "compression scheme"; }
+
+  void printOptionDiff(const Option &O, compression::OptionalCompressionKind V,
+                       OptVal Default, size_t GlobalWidth) const;
+
+  // An out-of-line virtual method to provide a 'home' for this class.
+  void anchor() override;
+};
+
+//--------------------------------------------------
+
 extern template class basic_parser<char>;
 
 template <> class parser<char> : public basic_parser<char> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &, StringRef, StringRef Arg, char &Value) {

llvm/include/llvm/Support/Compression.h

case uint8_t(CompressionKind::Zlib):
     return LLVM_ENABLE_ZLIB;
   case uint8_t(CompressionKind::ZStd):
     return LLVM_ENABLE_ZSTD;
   default:
     return false;
   }
 }
 
+// so that commanbd line option implementation works
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const CompressionKind &B) {
+  OS << (B->Name);
+  return OS;
+}
+
 constexpr bool operator==(CompressionKind left, CompressionKind right) {
   return uint8_t(left) == uint8_t(right);
 }
 
 OptionalCompressionKind noneIfUnsupported(CompressionKind left);
 
 OptionalCompressionKind noneIfUnsupported(OptionalCompressionKind left);
 

llvm/include/llvm/Transforms/Instrumentation.h

 #define LLVM_TRANSFORMS_INSTRUMENTATION_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
+#include "llvm/Support/Compression.h"
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
struct InstrProfOptions {
   bool Atomic = false;
 
   // Use BFI to guide register promotion
   bool UseBFIInPromotion = false;
 
   // Name of the profile file to use as output
   std::string InstrProfileOutput;
 
+  compression::OptionalCompressionKind OptionalCompressionScheme;
+
   InstrProfOptions() = default;
 };
 
 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
 ModulePass *createDataFlowSanitizerLegacyPassPass(
     const std::vector<std::string> &ABIListFiles = std::vector<std::string>());
 
 // Options for sanitizer coverage instrumentation.

llvm/include/llvm/Transforms/Instrumentation/InstrProfiling.h

 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_INSTRPROFILING_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_INSTRPROFILING_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/ProfileData/InstrProf.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include <cstdint>
 #include <cstring>
 #include <vector>
 
 namespace llvm {
 
 class TargetLibraryInfo;
private:
   bool emitRuntimeHook();
 
   /// Add uses of our data variables and runtime hook.
   void emitUses();
 
   /// Create a static initializer for our data, on platforms that need it,
   /// and for any profile output file that was specified.
   void emitInitialization();
+  compression::OptionalCompressionKind OptionalCompressionScheme;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_INSTRPROFILING_H

llvm/lib/MC/ELFObjectWriter.cpp

struct ELFWriter {
   unsigned addToSectionTable(const MCSectionELF *Sec);
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const;
   bool usesRela(const MCSectionELF &Sec) const;
 
   uint64_t align(unsigned Alignment);
 
-  bool maybeWriteCompression(uint32_t ChType, uint64_t Size,
+  bool maybeWriteCompression(DebugCompressionType CompressionType,
+                             uint64_t Size,
                              SmallVectorImpl<uint8_t> &CompressedContents,
                              unsigned Alignment);
 
 public:
   ELFWriter(ELFObjectWriter &OWriter, raw_pwrite_stream &OS,
             bool IsLittleEndian, DwoMode Mode)
       : OWriter(OWriter),
         W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
MCSectionELF *RelaSection = Ctx.createELFRelSection(
       RelaSectionName, Rela ? ELF::SHT_RELA : ELF::SHT_REL, Flags, EntrySize,
       Sec.getGroup(), &Sec);
   RelaSection->setAlignment(is64Bit() ? Align(8) : Align(4));
   return RelaSection;
 }
 
 // Include the debug info compression header.
 bool ELFWriter::maybeWriteCompression(
-    uint32_t ChType, uint64_t Size,
+    DebugCompressionType CompressionType, uint64_t Size,
     SmallVectorImpl<uint8_t> &CompressedContents, unsigned Alignment) {
   uint64_t HdrSize =
       is64Bit() ? sizeof(ELF::Elf32_Chdr) : sizeof(ELF::Elf64_Chdr);
   if (Size <= HdrSize + CompressedContents.size())
     return false;
+  uint64_t ChType;
+  switch (CompressionType) {
+  case DebugCompressionType::Z:
+    ChType = ELF::ELFCOMPRESS_ZLIB;
+    break;
+  case DebugCompressionType::ZStd:
+    ChType = ELF::ELFCOMPRESS_ZSTD;
+    break;
+  default:
+    return false;
+  }
+
   // Platform specific header is followed by compressed data.
   if (is64Bit()) {
     // Write Elf64_Chdr header.
     write(static_cast<ELF::Elf64_Word>(ChType));
     write(static_cast<ELF::Elf64_Word>(0)); // ch_reserved field.
     write(static_cast<ELF::Elf64_Xword>(Size));
     write(static_cast<ELF::Elf64_Xword>(Alignment));
   } else {
void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
   const auto &MAI = MC.getAsmInfo();
   const DebugCompressionType CompressionType = MAI->compressDebugSections();
   bool CompressionEnabled = CompressionType != DebugCompressionType::None;
   if (!CompressionEnabled || !SectionName.startswith(".debug_")) {
     Asm.writeSectionData(W.OS, &Section, Layout);
     return;
   }
 
-  assert(CompressionType == DebugCompressionType::Z &&
-         "expected zlib style compression");
+  assert((CompressionType == DebugCompressionType::Z ||
+          CompressionType == DebugCompressionType::ZStd) &&
+         "expected zlib or zstd style compression");
 
   SmallVector<char, 128> UncompressedData;
   raw_svector_ostream VecOS(UncompressedData);
   Asm.writeSectionData(VecOS, &Section, Layout);
 
   SmallVector<uint8_t, 128> Compressed;
-  const uint32_t ChType = ELF::ELFCOMPRESS_ZLIB;
+  switch (CompressionType) {
+  case DebugCompressionType::Z:
     compression::CompressionKind::Zlib->compress(
         makeArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()),
                      UncompressedData.size()),
         Compressed);
+    break;
+  case DebugCompressionType::ZStd:
+    compression::CompressionKind::ZStd->compress(
+        makeArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()),
+                     UncompressedData.size()),
+        Compressed);
+    break;
+  case DebugCompressionType::None:
+    break;
+  }
 
-  if (!maybeWriteCompression(ChType, UncompressedData.size(), Compressed,
-                             Sec.getAlignment())) {
+  if (!maybeWriteCompression(CompressionType, UncompressedData.size(),
+                             Compressed, Sec.getAlignment())) {
     W.OS << UncompressedData;
     return;
   }
 
   Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
   // Alignment field should reflect the requirements of
   // the compressed section header.
   Section.setAlignment(is64Bit() ? Align(8) : Align(4));

llvm/lib/ObjCopy/ELF/ELFObject.cpp

 
 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;
   DebugCompressionType CompressionType =
       reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Sec.OriginalData.data())
-                  ->ch_type == ELF::ELFCOMPRESS_ZLIB
-          ? DebugCompressionType::Z
-          : DebugCompressionType::None;
+                  ->ch_type == ELF::ELFCOMPRESS_ZSTD
+          ? DebugCompressionType::ZStd
+          : DebugCompressionType::Z;
 
   switch (CompressionType) {
   case DebugCompressionType::Z:
     if (Error Err1 = compression::CompressionKind::Zlib->decompress(
             Compressed, DecompressedContent, static_cast<size_t>(Sec.Size))) {
       return createStringError(errc::invalid_argument,
                                "'" + Sec.Name +
                                    "': " + toString(std::move(Err1)));
     }
     break;
+  case DebugCompressionType::ZStd:
+    if (Error Err = compression::CompressionKind::ZStd->decompress(
+            Compressed, DecompressedContent, static_cast<size_t>(Sec.Size))) {
+      return createStringError(errc::invalid_argument,
+                               "'" + Sec.Name +
+                                   "': " + toString(std::move(Err)));
+    }
+    break;
   case DebugCompressionType::None:
     llvm_unreachable("unexpected DebugCompressionType::None");
     break;
   }
 
   uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset;
   std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
 
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) {
   switch (CompressionType) {
   case DebugCompressionType::Z:
     compression::CompressionKind::Zlib->compress(OriginalData, CompressedData);
     break;
+  case DebugCompressionType::ZStd:
+    compression::CompressionKind::ZStd->compress(OriginalData, CompressedData);
+    break;
   case DebugCompressionType::None:
     break;
   }
 
   assert(CompressionType != DebugCompressionType::None);
   Flags |= ELF::SHF_COMPRESSED;
   size_t ChdrSize =
       std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),

llvm/lib/Object/Decompressor.cpp

if (SectionData.size() < HdrSize)
     return createError("corrupted compressed section header");
 
   DataExtractor Extractor(SectionData, IsLittleEndian, 0);
   uint64_t Offset = 0;
   uint64_t ELFCompressionSchemeId = Extractor.getUnsigned(
       &Offset, Is64Bit ? sizeof(Elf64_Word) : sizeof(Elf32_Word));
   if (ELFCompressionSchemeId == ELFCOMPRESS_ZLIB) {
     CompressionScheme = compression::CompressionKind::Zlib;
+  } else if (ELFCompressionSchemeId == ELFCOMPRESS_ZSTD) {
+    CompressionScheme = compression::CompressionKind::ZStd;
   } else {
     return createError("unsupported compression type");
   }
   if (!CompressionScheme)
     return createError(CompressionScheme->Name + " is not available");
 
   // Skip Elf64_Chdr::ch_reserved field.
   if (Is64Bit)

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Error RawCoverageFilenamesReader::read(CovMapVersion Version) {
   if (auto Err = readULEB128(UncompressedLen))
     return Err;
 
   uint64_t CompressedLen;
   if (auto Err = readSize(CompressedLen))
     return Err;
 
   if (CompressedLen > 0) {
-    if (!compression::CompressionKind::Zlib)
+    compression::OptionalCompressionKind OptionalCompressionScheme =
+        compression::CompressionKind::Zlib;
+    if (Version >= CovMapVersion::Version7) {
+      uint64_t CompressionSchemeId;
+      if (auto Err = readULEB128(CompressionSchemeId))
+        return Err;
+      OptionalCompressionScheme =
+          compression::getOptionalCompressionKind(CompressionSchemeId);
+    }
+    if (OptionalCompressionScheme) {
+      compression::CompressionKind CompressionScheme =
+          *OptionalCompressionScheme;
+      if (!CompressionScheme)
         return make_error<CoverageMapError>(
             coveragemap_error::decompression_failed);
 
       // Allocate memory for the decompressed filenames.
       SmallVector<uint8_t, 0> StorageBuf;
 
       // Read compressed filenames.
       StringRef CompressedFilenames = Data.substr(0, CompressedLen);
       Data = Data.substr(CompressedLen);
-    auto Err = compression::CompressionKind::Zlib->decompress(
+      auto Err = CompressionScheme->decompress(
           arrayRefFromStringRef(CompressedFilenames), StorageBuf,
           UncompressedLen);
       if (Err) {
         consumeError(std::move(Err));
         return make_error<CoverageMapError>(
             coveragemap_error::decompression_failed);
       }
 
       RawCoverageFilenamesReader Delegate(toStringRef(StorageBuf), Filenames,
                                           CompilationDir);
       return Delegate.readUncompressed(Version, NumFilenames);
+    } else {
+      StringRef CompressedFilenames = Data.substr(0, CompressedLen);
+      Data = Data.substr(CompressedLen);
+      RawCoverageFilenamesReader Delegate(CompressedFilenames, Filenames,
+                                          CompilationDir);
+      return Delegate.readUncompressed(Version, NumFilenames);
+    }
   }
 
   return readUncompressed(Version, NumFilenames);
 }
 
 Error RawCoverageFilenamesReader::readUncompressed(CovMapVersion Version,
                                                    uint64_t NumFilenames) {
   // Read uncompressed filenames.

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

CoverageFilenamesSectionWriter::CoverageFilenamesSectionWriter(
     : Filenames(Filenames) {
 #ifndef NDEBUG
   StringSet<> NameSet;
   for (StringRef Name : Filenames)
     assert(NameSet.insert(Name).second && "Duplicate filename");
 #endif
 }
 
-void CoverageFilenamesSectionWriter::write(raw_ostream &OS, bool Compress) {
+void CoverageFilenamesSectionWriter::write(
+    raw_ostream &OS,
+    compression::OptionalCompressionKind OptionalCompressionScheme) {
   std::string FilenamesStr;
   {
     raw_string_ostream FilenamesOS{FilenamesStr};
     for (const auto &Filename : Filenames) {
       encodeULEB128(Filename.size(), FilenamesOS);
       FilenamesOS << Filename;
     }
   }
 
   SmallVector<uint8_t, 128> CompressedStr;
-  compression::OptionalCompressionKind OptionalCompressionScheme =
-      compression::CompressionKind::Zlib;
-
-  OptionalCompressionScheme = compression::noneIfUnsupported(
-      (Compress && DoInstrProfNameCompression) ? OptionalCompressionScheme
-                                               : llvm::NoneType());
 
+  OptionalCompressionScheme =
+      compression::noneIfUnsupported(OptionalCompressionScheme);
+  compression::CompressionKind CompressionScheme =
+      compression::CompressionKind::Unknown;
   bool doCompression = bool(OptionalCompressionScheme);
 
   if (doCompression) {
-    compression::CompressionKind CompressionScheme = *OptionalCompressionScheme;
+    CompressionScheme = *OptionalCompressionScheme;
     CompressionScheme->compress(arrayRefFromStringRef(FilenamesStr),
                                 CompressedStr,
                                 CompressionScheme->BestSizeLevel);
   }
 
   // ::= <num-filenames>
   //     <uncompressed-len>
   //     <compressed-len-or-zero>
+  //     IF compressed:
+  //       <compressed-alg-id>
   //     (<compressed-filenames> | <uncompressed-filenames>)
   encodeULEB128(Filenames.size(), OS);
   encodeULEB128(FilenamesStr.size(), OS);
   encodeULEB128(doCompression ? CompressedStr.size() : 0U, OS);
+  if (doCompression)
+    encodeULEB128(uint8_t(CompressionScheme), OS);
   OS << (doCompression ? toStringRef(CompressedStr) : StringRef(FilenamesStr));
 }
 
 namespace {
 
 /// Gather only the expressions that are used by the mapping
 /// regions in this function.
 class CounterExpressionsMinimizer {

llvm/lib/ProfileData/InstrProf.cpp

#define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix)      \
   Prefix,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
 } // namespace
 
 namespace llvm {
 
-cl::opt<bool> DoInstrProfNameCompression(
-    "enable-name-compression",
-    cl::desc("Enable name/filename string compression"), cl::init(true));
+cl::opt<compression::OptionalCompressionKind> InstrProfNameCompressionScheme(
+    "name-compression",
+    cl::desc("Scheme for name/filename string compression (none/zlib/ztsd), "
+             "defaults to zstd"),
+    cl::init(compression::CompressionKind::ZStd));
 
 std::string getInstrProfSectionName(InstrProfSectKind IPSK,
                                     Triple::ObjectFormatType OF,
                                     bool AddSegmentInfo) {
   std::string SectName;
 
   if (OF == Triple::MachO && AddSegmentInfo)
     SectName = InstrProfSectNamePrefix[IPSK];
Error collectPGOFuncNameStrings(
 
   assert(StringRef(UncompressedNameStrings)
                  .count(getInstrProfNameSeparator()) == (NameStrs.size() - 1) &&
          "PGO name is invalid (contains separator token)");
 
   unsigned EncLen = encodeULEB128(UncompressedNameStrings.length(), P);
   P += EncLen;
 
-  auto WriteStringToResult = [&](size_t CompressedLen, StringRef InputStr) {
+  auto WriteStringToResult = [&](size_t CompressedLen,
+                                 uint8_t CompressionSchemeId,
+                                 StringRef InputStr) {
+    if (CompressedLen == 0) {
       EncLen = encodeULEB128(CompressedLen, P);
       P += EncLen;
       char *HeaderStr = reinterpret_cast<char *>(&Header[0]);
       unsigned HeaderLen = P - &Header[0];
       Result.append(HeaderStr, HeaderLen);
       Result += InputStr;
       return Error::success();
+    } else {
+      EncLen = encodeULEB128(CompressedLen, P);
+      P += EncLen;
+      EncLen = encodeULEB128(CompressionSchemeId, P);
+      P += EncLen;
+      char *HeaderStr = reinterpret_cast<char *>(&Header[0]);
+      unsigned HeaderLen = P - &Header[0];
+      Result.append(HeaderStr, HeaderLen);
+      Result += InputStr;
+      return Error::success();
+    }
   };
 
   if ((!OptionalCompressionScheme) || (!(*OptionalCompressionScheme)))
-    return WriteStringToResult(0, UncompressedNameStrings);
+    return WriteStringToResult(0, 0, UncompressedNameStrings);
   compression::CompressionKind CompressionScheme = *OptionalCompressionScheme;
   SmallVector<uint8_t, 128> CompressedNameStrings;
   CompressionScheme->compress(arrayRefFromStringRef(UncompressedNameStrings),
                               CompressedNameStrings,
                               CompressionScheme->BestSizeLevel);
 
-  return WriteStringToResult(CompressedNameStrings.size(),
+  return WriteStringToResult(CompressedNameStrings.size(), CompressionScheme,
                              toStringRef(CompressedNameStrings));
 }
 
 StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar) {
   auto *Arr = cast<ConstantDataArray>(NameVar->getInitializer());
   StringRef NameStr =
       Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
   return NameStr;
 }
 
-Error collectPGOFuncNameStrings(ArrayRef<GlobalVariable *> NameVars,
-                                std::string &Result, bool doCompression) {
+Error collectPGOFuncNameStrings(
+    ArrayRef<GlobalVariable *> NameVars, std::string &Result,
+    compression::OptionalCompressionKind OptionalCompressionScheme) {
   std::vector<std::string> NameStrs;
   for (auto *NameVar : NameVars) {
     NameStrs.push_back(std::string(getPGOFuncNameVarInitializer(NameVar)));
   }
-  compression::OptionalCompressionKind OptionalCompressionScheme =
-      compression::CompressionKind::Zlib;
+
   return collectPGOFuncNameStrings(
-      NameStrs,
-      compression::noneIfUnsupported(doCompression ? OptionalCompressionScheme
-                                                   : llvm::NoneType()),
+      NameStrs, compression::noneIfUnsupported(OptionalCompressionScheme),
       Result);
 }
 
 Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab) {
   const uint8_t *P = NameStrings.bytes_begin();
   const uint8_t *EndP = NameStrings.bytes_end();
   while (P < EndP) {
     uint32_t N;
     uint64_t UncompressedSize = decodeULEB128(P, &N);
     P += N;
     uint64_t CompressedSize = decodeULEB128(P, &N);
     P += N;
     bool isCompressed = (CompressedSize != 0);
+    compression::OptionalCompressionKind OptionalCompressionScheme =
+        llvm::NoneType();
+    if (isCompressed) {
+      uint64_t CompressionSchemeId = decodeULEB128(P, &N);
+      P += N;
+      OptionalCompressionScheme =
+          compression::getOptionalCompressionKind(CompressionSchemeId);
+    }
     SmallVector<uint8_t, 128> UncompressedNameStrings;
     StringRef NameStrings;
-    if (isCompressed) {
+    if (isCompressed && bool(OptionalCompressionScheme)) {
       compression::CompressionKind CompressionScheme =
-          compression::CompressionKind::Zlib;
+          *OptionalCompressionScheme;
       if (!CompressionScheme)
         return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
 
       if (Error E = CompressionScheme->decompress(
               makeArrayRef(P, CompressedSize), UncompressedNameStrings,
               UncompressedSize)) {
         consumeError(std::move(E));
         return make_error<InstrProfError>(instrprof_error::uncompress_failed);
       }
       P += CompressedSize;
       NameStrings = toStringRef(UncompressedNameStrings);
+
     } else {
       NameStrings =
           StringRef(reinterpret_cast<const char *>(P), UncompressedSize);
       P += UncompressedSize;
     }
     // Now parse the name strings.
     SmallVector<StringRef, 0> Names;
     NameStrings.split(Names, getInstrProfNameSeparator());
Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
   if (GET_VERSION(H.formatVersion()) >
       IndexedInstrProf::ProfVersion::CurrentVersion)
     return make_error<InstrProfError>(instrprof_error::unsupported_version);
 
   switch (GET_VERSION(H.formatVersion())) {
     // When a new field is added in the header add a case statement here to
     // populate it.
     static_assert(
-        IndexedInstrProf::ProfVersion::CurrentVersion == Version8,
+        IndexedInstrProf::ProfVersion::CurrentVersion == Version9,
         "Please update the reading code below if a new field has been added, "
         "if not add a case statement to fall through to the latest version.");
   case 8ull:
     H.MemProfOffset = read(Buffer, offsetOf(&Header::MemProfOffset));
     LLVM_FALLTHROUGH;
   default: // Version7 (when the backwards compatible header was introduced).
     H.HashType = read(Buffer, offsetOf(&Header::HashType));
     H.HashOffset = read(Buffer, offsetOf(&Header::HashOffset));
   }
 
   return H;
 }
 
 size_t Header::size() const {
   switch (GET_VERSION(formatVersion())) {
     // When a new field is added to the header add a case statement here to
     // compute the size as offset of the new field + size of the new field. This
     // relies on the field being added to the end of the list.
-    static_assert(IndexedInstrProf::ProfVersion::CurrentVersion == Version8,
+    static_assert(IndexedInstrProf::ProfVersion::CurrentVersion == Version9,
                   "Please update the size computation below if a new field has "
                   "been added to the header, if not add a case statement to "
                   "fall through to the latest version.");
   case 8ull:
     return offsetOf(&Header::MemProfOffset) + sizeof(Header::MemProfOffset);
   default: // Version7 (when the backwards compatible header was introduced).
     return offsetOf(&Header::HashOffset) + sizeof(Header::HashOffset);
   }
 }
 
 } // namespace IndexedInstrProf
 
 } // end namespace llvm

llvm/lib/ProfileData/SampleProfReader.cpp

std::error_code SampleProfileReaderExtBinaryBase::decompressSection(
   if (std::error_code EC = DecompressSize.getError())
     return EC;
   DecompressBufSize = *DecompressSize;
 
   auto CompressSize = readNumber<uint64_t>();
   if (std::error_code EC = CompressSize.getError())
     return EC;
 
-  if (!llvm::compression::CompressionKind::Zlib)
+  auto CompressionSchemeId = readNumber<uint64_t>();
+  if (std::error_code EC = CompressionSchemeId.getError())
+    return EC;
+  compression::OptionalCompressionKind OptionalCompressionScheme =
+      compression::getOptionalCompressionKind(*CompressionSchemeId);
+  if (OptionalCompressionScheme) {
+    compression::CompressionKind CompressionScheme = *OptionalCompressionScheme;
+    if (!CompressionScheme)
       return sampleprof_error::zlib_unavailable;
 
     uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize);
     size_t UCSize = DecompressBufSize;
-  llvm::Error E = compression::CompressionKind::Zlib->decompress(
+    llvm::Error E = CompressionScheme->decompress(
         makeArrayRef(Data, *CompressSize), Buffer, UCSize);
     if (E)
       return sampleprof_error::uncompress_failed;
     DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
     return sampleprof_error::success;
+  } else {
+
+    DecompressBufSize = *CompressSize;
+    uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize);
+    memcpy(Buffer, Data, DecompressBufSize);
+    DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
+    return sampleprof_error::success;
+  }
 }
 
 std::error_code SampleProfileReaderExtBinaryBase::readImpl() {
   const uint8_t *BufStart =
       reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 
   for (auto &Entry : SecHdrTable) {
     // Skip empty section.

llvm/lib/ProfileData/SampleProfWriter.cpp

SampleProfileWriterExtBinaryBase::markSectionStart(SecType Type,
   assert(Entry.Type == Type && "Unexpected section type");
   // Use LocalBuf as a temporary output for writting data.
   if (hasSecFlag(Entry, SecCommonFlags::SecFlagCompress))
     LocalBufStream.swap(OutputStream);
   return SectionStart;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::compressAndOutput() {
-  compression::CompressionKind CompressionScheme =
-      compression::CompressionKind::Zlib;
+  if (!OptionalCompressionScheme) {
+    std::string &UncompressedStrings =
+        static_cast<raw_string_ostream *>(LocalBufStream.get())->str();
+    if (UncompressedStrings.size() == 0)
+      return sampleprof_error::success;
+    auto &OS = *OutputStream;
+    encodeULEB128(UncompressedStrings.size(), OS);
+    encodeULEB128(UncompressedStrings.size(), OS);
+    encodeULEB128(uint8_t(0), OS);
+    OS << UncompressedStrings;
+    UncompressedStrings.clear();
+    return sampleprof_error::success;
+  } else {
+    compression::CompressionKind CompressionScheme = *OptionalCompressionScheme;
+
     if (!CompressionScheme)
       return sampleprof_error::zlib_unavailable;
     std::string &UncompressedStrings =
         static_cast<raw_string_ostream *>(LocalBufStream.get())->str();
     if (UncompressedStrings.size() == 0)
       return sampleprof_error::success;
     auto &OS = *OutputStream;
     SmallVector<uint8_t, 128> CompressedStrings;
     CompressionScheme->compress(arrayRefFromStringRef(UncompressedStrings),
                                 CompressedStrings,
                                 CompressionScheme->BestSizeLevel);
     encodeULEB128(UncompressedStrings.size(), OS);
     encodeULEB128(CompressedStrings.size(), OS);
+    encodeULEB128(uint8_t(CompressionScheme), OS);
     OS << toStringRef(CompressedStrings);
     UncompressedStrings.clear();
     return sampleprof_error::success;
   }
+}
 
 /// Add a new section into section header table given the section type
 /// \p Type, its position \p LayoutIdx in SectionHdrLayout and the
 /// location \p SectionStart where the section should be written to.
 std::error_code SampleProfileWriterExtBinaryBase::addNewSection(
     SecType Type, uint32_t LayoutIdx, uint64_t SectionStart) {
   assert(LayoutIdx < SectionHdrLayout.size() && "LayoutIdx out of range");
   const auto &Entry = SectionHdrLayout[LayoutIdx];

 
 /// Create a sample profile file writer based on the specified format.
 ///
 /// \param Filename The file to create.
 ///
 /// \param Format Encoding format for the profile file.
 ///
 /// \returns an error code indicating the status of the created writer.
-ErrorOr<std::unique_ptr<SampleProfileWriter>>
-SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) {
+ErrorOr<std::unique_ptr<SampleProfileWriter>> SampleProfileWriter::create(
+    StringRef Filename, SampleProfileFormat Format,
+    compression::OptionalCompressionKind OptionalCompressionScheme) {
   std::error_code EC;
   std::unique_ptr<raw_ostream> OS;
   if (Format == SPF_Binary || Format == SPF_Ext_Binary ||
       Format == SPF_Compact_Binary)
     OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_None));
   else
     OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_TextWithCRLF));
   if (EC)
     return EC;
 
-  return create(OS, Format);
+  return create(OS, Format, OptionalCompressionScheme);
 }
 
 /// Create a sample profile stream writer based on the specified format.
 ///
 /// \param OS The output stream to store the profile data to.
 ///
 /// \param Format Encoding format for the profile file.
 ///
 /// \returns an error code indicating the status of the created writer.
-ErrorOr<std::unique_ptr<SampleProfileWriter>>
-SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
-                            SampleProfileFormat Format) {
+ErrorOr<std::unique_ptr<SampleProfileWriter>> SampleProfileWriter::create(
+    std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format,
+    compression::OptionalCompressionKind OptionalCompressionScheme) {
   std::error_code EC;
   std::unique_ptr<SampleProfileWriter> Writer;
 
   // Currently only Text and Extended Binary format are supported for CSSPGO.
   if ((FunctionSamples::ProfileIsCS || FunctionSamples::ProfileIsProbeBased) &&
       (Format == SPF_Binary || Format == SPF_Compact_Binary))
     return sampleprof_error::unsupported_writing_format;
 
   if (Format == SPF_Binary)
-    Writer.reset(new SampleProfileWriterRawBinary(OS));
+    Writer.reset(
+        new SampleProfileWriterRawBinary(OS, OptionalCompressionScheme));
   else if (Format == SPF_Ext_Binary)
-    Writer.reset(new SampleProfileWriterExtBinary(OS));
+    Writer.reset(
+        new SampleProfileWriterExtBinary(OS, OptionalCompressionScheme));
   else if (Format == SPF_Compact_Binary)
-    Writer.reset(new SampleProfileWriterCompactBinary(OS));
+    Writer.reset(
+        new SampleProfileWriterCompactBinary(OS, OptionalCompressionScheme));
   else if (Format == SPF_Text)
-    Writer.reset(new SampleProfileWriterText(OS));
+    Writer.reset(new SampleProfileWriterText(OS, OptionalCompressionScheme));
   else if (Format == SPF_GCC)
     EC = sampleprof_error::unsupported_writing_format;
   else
     EC = sampleprof_error::unrecognized_format;
 
   if (EC)
     return EC;
 
   Writer->Format = Format;
   return std::move(Writer);
 }
 
 void SampleProfileWriter::computeSummary(const SampleProfileMap &ProfileMap) {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
   Summary = Builder.computeSummaryForProfiles(ProfileMap);
 }

llvm/lib/Support/CommandLine.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <string>
 using namespace llvm;
 using namespace cl;
 
 #define DEBUG_TYPE "commandline"
 
 //===----------------------------------------------------------------------===//
 // Template instantiations and anchors.
 //
 namespace llvm {
 namespace cl {
 template class basic_parser<bool>;
 template class basic_parser<boolOrDefault>;
 template class basic_parser<int>;
 template class basic_parser<long>;
 template class basic_parser<long long>;
 template class basic_parser<unsigned>;
 template class basic_parser<unsigned long>;
 template class basic_parser<unsigned long long>;
 template class basic_parser<double>;
 template class basic_parser<float>;
 template class basic_parser<std::string>;
+template class basic_parser<compression::OptionalCompressionKind>;
 template class basic_parser<char>;
 
 template class opt<unsigned>;
 template class opt<int>;
 template class opt<std::string>;
 template class opt<char>;
 template class opt<bool>;
+template class opt<compression::OptionalCompressionKind>;
 } // namespace cl
 } // namespace llvm
 
 // Pin the vtables to this file.
 void GenericOptionValue::anchor() {}
 void OptionValue<boolOrDefault>::anchor() {}
 void OptionValue<std::string>::anchor() {}
 void Option::anchor() {}
 void basic_parser_impl::anchor() {}
 void parser<bool>::anchor() {}
 void parser<boolOrDefault>::anchor() {}
 void parser<int>::anchor() {}
 void parser<long>::anchor() {}
 void parser<long long>::anchor() {}
 void parser<unsigned>::anchor() {}
 void parser<unsigned long>::anchor() {}
 void parser<unsigned long long>::anchor() {}
 void parser<double>::anchor() {}
 void parser<float>::anchor() {}
 void parser<std::string>::anchor() {}
 void parser<char>::anchor() {}
+void parser<compression::OptionalCompressionKind>::anchor() {}
 
 //===----------------------------------------------------------------------===//
 
 const static size_t DefaultPad = 2;
 
 static StringRef ArgPrefix = "-";
 static StringRef ArgPrefixLong = "--";
 static StringRef ArgHelpPrefix = " - ";

 bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) {
   if (!ArgName.data())
     ArgName = ArgStr;
   if (ArgName.empty())
     Errs << HelpStr; // Be nice for positional arguments
   else
     Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0);
 
-  Errs << " option: " << Message << "\n";
+  Errs << " option:\n";
+  Errs << "- ";
+  Errs.changeColor(raw_ostream::RED, true);
+  Errs << "error:";
+  Errs.resetColor();
+  Errs << " " << Message << "\n";
   return true;
 }
 
 bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
                            bool MultiArg) {
   if (!MultiArg)
     NumOccurrences++; // Increment the number of times we have been seen
 
if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
     Value = BOU_FALSE;
     return false;
   }
 
   return O.error("'" + Arg +
                  "' is invalid value for boolean argument! Try 0 or 1");
 }
 
+// parser<compression::OptionalCompressionKind> implementation
+//
+bool parser<compression::OptionalCompressionKind>::parse(
+    Option &O, StringRef, StringRef Arg,
+    compression::OptionalCompressionKind &Value) {
+  Value = llvm::StringSwitch<compression::OptionalCompressionKind>(Arg.str())
+              .Case("none", NoneType())
+              .Case("zlib", compression::CompressionKind::Zlib)
+              .Case("zstd", compression::CompressionKind::ZStd)
+              .Default(compression::CompressionKind::Unknown);
+  if (bool(Value) && ((*Value) == compression::CompressionKind::Unknown)) {
+
+    StringRef ArgName = O.ArgStr;
+    errs() << GlobalParser->ProgramName << ": ";
+    errs() << "for the " << PrintArg(ArgName, 0) << " option:\n";
+    errs() << "- ";
+    WithColor::error() << ("'" + Arg.str() +
+                           "' is not a recognized compression scheme!")
+                       << "\n";
+    outs() << "- ";
+    WithColor::note() << "Try one of none, zstd, or zlib"
+                      << "\n";
+    return true;
+  }
+  return false;
+}
+
 // parser<int> implementation
 //
 bool parser<int>::parse(Option &O, StringRef ArgName, StringRef Arg,
                         int &Value) {
   if (Arg.getAsInteger(0, Value))
     return O.error("'" + Arg + "' value invalid for integer argument!");
   return false;
 }

 PRINT_OPT_DIFF(int)
 PRINT_OPT_DIFF(long)
 PRINT_OPT_DIFF(long long)
 PRINT_OPT_DIFF(unsigned)
 PRINT_OPT_DIFF(unsigned long)
 PRINT_OPT_DIFF(unsigned long long)
 PRINT_OPT_DIFF(double)
 PRINT_OPT_DIFF(float)
+PRINT_OPT_DIFF(compression::OptionalCompressionKind)
 PRINT_OPT_DIFF(char)
 
 void parser<std::string>::printOptionDiff(const Option &O, StringRef V,
                                           const OptionValue<std::string> &D,
                                           size_t GlobalWidth) const {
   printOptionName(O, GlobalWidth);
   outs() << "= " << V;
   size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

 void InstrProfiling::emitNameData() {
   std::string UncompressedData;
 
   if (ReferencedNames.empty())
     return;
 
   std::string CompressedNameStr;
   if (Error E = collectPGOFuncNameStrings(ReferencedNames, CompressedNameStr,
-                                          DoInstrProfNameCompression)) {
+                                          InstrProfNameCompressionScheme)) {
     report_fatal_error(Twine(toString(std::move(E))), false);
   }
 
   auto &Ctx = M->getContext();
   auto *NamesVal =
       ConstantDataArray::getString(Ctx, StringRef(CompressedNameStr), false);
   NamesVar = new GlobalVariable(*M, NamesVal->getType(), true,
                                 GlobalValue::PrivateLinkage, NamesVal,

llvm/test/tools/llvm-cov/coverage-prefix-map.test

 
 # LCOV: SF:bar.h
 # LCOV-NOT: SF
 
 Instructions for regenerating the test:
 # cd %S/Inputs/coverage_prefix_map
 cp -r . /tmp/coverage_prefix_map
 
-clang -fprofile-instr-generate -mllvm -enable-name-compression=false -fcoverage-mapping -fcoverage-prefix-map=$PWD=. main.cc -o main
+clang -fprofile-instr-generate -mllvm -name-compression=none -fcoverage-mapping -fcoverage-prefix-map=$PWD=. main.cc -o main
 LLVM_PROFILE_FILE="main.raw" ./main
 llvm-profdata merge main.raw -o main.profdata
 llvm-cov convert-for-testing ./main -o ./main.covmapping
 rm main main.raw

llvm/test/tools/llvm-cov/multiple-objects-not-all-instrumented.test

 RUN: llvm-cov export --format=lcov --instr-profile=%S/Inputs/multiple_objects_not_all_instrumented/instrumented.profdata \
 RUN:   -object %S/Inputs/multiple_objects_not_all_instrumented/not_instrumented \
 RUN:   -object %S/Inputs/multiple_objects_not_all_instrumented/instrumented | FileCheck -check-prefix=FN %s
 
 FN:1,_Z2f1v
 
 Instructions for regenerating the test:
 
 clang -std=c++11 not_instrumented.cc -o not_instrumented
-clang -std=c++11 -mllvm -enable-name-compression=false -fprofile-instr-generate -fcoverage-mapping instrumented.cc -o instrumented
+clang -std=c++11 -mllvm -name-compression=none -fprofile-instr-generate -fcoverage-mapping instrumented.cc -o instrumented
 LLVM_PROFILE_FILE="instrumented.raw" ./instrumented
 llvm-profdata merge instrumented.raw -o instrumented.profdata

llvm/test/tools/llvm-cov/multiple-objects.test

 RUN: llvm-cov report -instr-profile %S/Inputs/multiple_objects/merged.profdata \
 RUN:   %S/Inputs/multiple_objects/use_2.covmapping \
 RUN:   -object %S/Inputs/multiple_objects/use_1.covmapping | FileCheck -check-prefix=REPORT %s
 
 REPORT: Filename{{ +}}Regions{{ +}}Missed Regions{{ +}}Cover
 REPORT-NEXT: ---
 REPORT-NEXT: header.h{{ +}}25{{ +}}14{{ +}}44.00%
 
 # Make sure that both use_1.cc and use_2.cc have coverage reported.
 # Before https://reviews.llvm.org/D46478, only one of them used to be reported.
 REPORT-NEXT: use_1.cc{{ +}}1{{ +}}0{{ +}}100.00%
 REPORT-NEXT: use_2.cc{{ +}}2{{ +}}0{{ +}}100.00%
 
 Instructions for regenerating the test:
 
-clang -std=c++11 -mllvm -enable-name-compression=false -fprofile-instr-generate -fcoverage-mapping use_1.cc -o use_1
-clang -std=c++11 -mllvm -enable-name-compression=false -fprofile-instr-generate -fcoverage-mapping use_2.cc -o use_2
+clang -std=c++11 -mllvm -name-compression=none -fprofile-instr-generate -fcoverage-mapping use_1.cc -o use_1
+clang -std=c++11 -mllvm -name-compression=none -fprofile-instr-generate -fcoverage-mapping use_2.cc -o use_2
 LLVM_PROFILE_FILE="use_1.raw" ./use_1
 LLVM_PROFILE_FILE="use_2.raw" ./use_2
 llvm-profdata merge use_{1,2}.raw -o merged.profdata
 llvm-cov convert-for-testing ./use_1 -o ./use_1.covmapping
 llvm-cov convert-for-testing ./use_2 -o ./use_2.covmapping

llvm/test/tools/llvm-cov/multithreaded-report.test

 
 
 Instructions for regenerating the test:
 
 # cd %S/Inputs/multithreaded_report
 
 cp -r . /tmp/multithreaded_report
 
-clang++ -std=c++11 -mllvm -enable-name-compression=false \
+clang++ -std=c++11 -mllvm -name-compression=none \
     -fprofile-instr-generate -fcoverage-mapping \
     /tmp/multithreaded_report/*.cc -o main
 
 LLVM_PROFILE_FILE="main.profraw" ./main
 llvm-profdata merge main.profraw -o main.profdata
 llvm-cov convert-for-testing ./main -o ./main.covmapping
 rm main main.profraw

llvm/test/tools/llvm-cov/sources-specified.test

 EXPORT-DAG: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)extra(/|\\\\)dec.h"}}
 EXPORT-DAG: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)extra(/|\\\\)inc.h"}}
 
 Instructions for regenerating the test:
 
 # cd %S/Inputs/sources_specified
 cp -r . /tmp/sources_specified
 
-clang -mllvm -enable-name-compression=false -fprofile-instr-generate \
+clang -mllvm -name-compression=none -fprofile-instr-generate \
     -fcoverage-mapping /tmp/sources_specified/main.cc -o main
 
 LLVM_PROFILE_FILE="main.raw" ./main
 llvm-profdata merge main.raw -o main.profdata
 llvm-cov convert-for-testing ./main -o ./main.covmapping
 rm main main.raw

llvm/test/tools/llvm-profdata/c-general.test

 You need a checkout of clang with compiler-rt to generate the
 binary file here.  These shell commands can be used to regenerate
 it.
 $ SRC=path/to/llvm
 $ CFE=$SRC/tools/clang
 $ TESTDIR=$SRC/test/tools/llvm-profdata
 $ CFE_TESTDIR=$CFE/test/Profile
-$ clang -o a.out -fprofile-instr-generate $CFE_TESTDIR/c-general.c -mllvm -enable-name-compression=false
+$ clang -o a.out -fprofile-instr-generate $CFE_TESTDIR/c-general.c -mllvm -name-compression=none
 $ LLVM_PROFILE_FILE=$TESTDIR/Inputs/c-general.profraw ./a.out
 
 RUN: llvm-profdata show %p/Inputs/c-general.profraw -o - | FileCheck %s
 RUN: llvm-profdata show %p/Inputs/c-general.profraw --topn=3 -o - | FileCheck %s --check-prefix=TOPN
 RUN: llvm-profdata show %p/Inputs/c-general.profraw -o - --function=switches | FileCheck %s -check-prefixes=SWITCHES,CHECK
 
 SWITCHES-LABEL: Counters:
 SWITCHES-NEXT:   switches:

llvm/test/tools/llvm-profdata/memprof-merge.test

 }
 ```
 
 Steps to collect the memprof raw profile and the instrprof raw profile:
 
 ```
 # Collect instrprof profile with name compression disabled since some buildbots
 # do not have zlib.
-clang -mllvm -enable-name-compression=false -fprofile-generate source.c -o instr.out
+clang -mllvm -name-compression=none -fprofile-generate source.c -o instr.out
 ./instr.out
 mv *.profraw basic.profraw
 
 # Collect memprof profile.
 clang -fuse-ld=lld -Wl,--no-rosegment -gmlt -fdebug-info-for-profiling \
       -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer \
       -fno-optimize-sibling-calls -m64 -Wl,-build-id -no-pie \
       source.c -o basic.memprofexe

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
 
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
   MAI->setRelaxELFRelocations(RelaxELFRel);
 
   if (CompressDebugSections != DebugCompressionType::None) {
+    if (CompressDebugSections == DebugCompressionType::Z) {
       if (!compression::CompressionKind::Zlib) {
         WithColor::error(errs(), ProgName)
-          << "build tools with zlib to enable -compress-debug-sections";
+            << "build tools with zlib to enable -compress-debug-sections=zlib";
         return 1;
       }
+    } else if (CompressDebugSections == DebugCompressionType::ZStd) {
+      if (!compression::CompressionKind::ZStd) {
+        WithColor::error(errs(), ProgName)
+            << "build tools with zstd to enable -compress-debug-sections=zstd";
+        return 1;
+      }
+    }
     MAI->setCompressDebugSections(CompressDebugSections);
   }
   MAI->setPreserveAsmComments(PreserveComments);
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
   if (MAttrs.size()) {
     SubtargetFeatures Features;

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

if (OutputFormat.empty()) {
       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)
       return createStringError(
           errc::invalid_argument,
           "invalid or unsupported --compress-debug-sections format: %s",
           A->getValue());
     switch (Config.CompressionType) {
     case DebugCompressionType::None:
       break;
     case DebugCompressionType::Z:
       if (!compression::CompressionKind::Zlib)
         return createStringError(
             errc::invalid_argument,
             "LLVM was not compiled with LLVM_ENABLE_ZLIB: can not compress");
       break;
+    case DebugCompressionType::ZStd:
+      if (!compression::CompressionKind::ZStd)
+        return createStringError(
+            errc::invalid_argument,
+            "LLVM was not compiled with LLVM_ENABLE_ZSTD: can not compress");
+      break;
     }
   }
 
   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.
objcopy::parseObjcopyOptions(ArrayRef<const char *> RawArgsArr,
   if (Config.DecompressDebugSections &&
       Config.CompressionType != DebugCompressionType::None) {
     return createStringError(
         errc::invalid_argument,
         "cannot specify both --compress-debug-sections and "
         "--decompress-debug-sections");
   }
 
-  if (Config.DecompressDebugSections && !compression::CompressionKind::Zlib)
-    return createStringError(
-        errc::invalid_argument,
-        "LLVM was not compiled with LLVM_ENABLE_ZLIB: cannot decompress");
-
   if (Config.ExtractPartition && Config.ExtractMainPartition)
     return createStringError(errc::invalid_argument,
                              "cannot specify --extract-partition together with "
                              "--extract-main-partition");
 
   DC.CopyConfigs.push_back(std::move(ConfigMgr));
   return std::move(DC);
 }

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">;
 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/tools/llvm-profdata/llvm-profdata.cpp

 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/ProfileData/MemProf.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/RawMemProfReader.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Discriminator.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
mergeSampleProfile(const WeightedFileVector &Inputs, SymbolRemapper *Remapper,
 
   if (ProfileIsCS && GenCSNestedProfile) {
     CSProfileConverter CSConverter(ProfileMap);
     CSConverter.convertProfiles();
     ProfileIsCS = FunctionSamples::ProfileIsCS = false;
   }
 
   auto WriterOrErr =
-      SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
+      SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat],
+                                  compression::CompressionKind::Zlib);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithErrorCode(EC, OutputFilename);
 
   auto Writer = std::move(WriterOrErr.get());
   // WriterList will have StringRef refering to string in Buffer.
   // Make sure Buffer lives as long as WriterList.
   auto Buffer = getInputFileBuf(ProfileSymbolListFile);
   handleExtBinaryWriter(*Writer, OutputFormat, Buffer.get(), WriterList,

llvm/tools/llvm-profgen/ProfileGenerator.cpp

if (PopulateProfileSymbolList && OutputFormat == SPF_Ext_Binary) {
     Writer->setProfileSymbolList(&SymbolList);
   }
 
   if (std::error_code EC = Writer->write(ProfileMap))
     exitWithError(std::move(EC));
 }
 
 void ProfileGeneratorBase::write() {
-  auto WriterOrErr = SampleProfileWriter::create(OutputFilename, OutputFormat);
+  auto WriterOrErr = SampleProfileWriter::create(
+      OutputFilename, OutputFormat, compression::CompressionKind::Zlib);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithError(EC, OutputFilename);
 
   if (UseMD5) {
     if (OutputFormat != SPF_Ext_Binary)
       WithColor::warning() << "-use-md5 is ignored. Specify "
                               "--format=extbinary to enable it\n";
     else

llvm/unittests/ProfileData/CoverageMappingTest.cpp

 TEST(CoverageMappingTest, filename_roundtrip) {
   std::vector<std::string> Paths({"dir", "a", "b", "c", "d", "e"});
 
   for (bool Compress : {false, true}) {
     std::string EncodedFilenames;
     {
       raw_string_ostream OS(EncodedFilenames);
       CoverageFilenamesSectionWriter Writer(Paths);
-      Writer.write(OS, Compress);
+      Writer.write(OS, Compress ? (compression::OptionalCompressionKind)
+                                      compression::CompressionKind::Zlib
+                                : NoneType());
     }
 
     std::vector<std::string> ReadFilenames;
     RawCoverageFilenamesReader Reader(EncodedFilenames, ReadFilenames);
     EXPECT_THAT_ERROR(Reader.read(CovMapVersion::CurrentVersion), Succeeded());
 
     ASSERT_EQ(ReadFilenames.size(), Paths.size());
     for (unsigned I = 1; I < Paths.size(); ++I) {
       SmallString<256> P(Paths[0]);
       llvm::sys::path::append(P, Paths[I]);
       ASSERT_EQ(ReadFilenames[I], P);
     }
   }
 }
 
 TEST(CoverageMappingTest, filename_compilation_dir) {
   std::vector<std::string> Paths({"dir", "a", "b", "c", "d", "e"});
 
   for (bool Compress : {false, true}) {
     std::string EncodedFilenames;
     {
       raw_string_ostream OS(EncodedFilenames);
       CoverageFilenamesSectionWriter Writer(Paths);
-      Writer.write(OS, Compress);
+      Writer.write(OS, Compress ? (compression::OptionalCompressionKind)
+                                      compression::CompressionKind::Zlib
+                                : NoneType());
     }
 
     StringRef CompilationDir = "out";
     std::vector<std::string> ReadFilenames;
     RawCoverageFilenamesReader Reader(EncodedFilenames, ReadFilenames,
                                       CompilationDir);
     EXPECT_THAT_ERROR(Reader.read(CovMapVersion::CurrentVersion), Succeeded());
 

llvm/unittests/ProfileData/SampleProfTest.cpp

struct SampleProfTest : ::testing::Test {
   std::unique_ptr<SampleProfileReader> Reader;
 
   SampleProfTest() : Writer(), Reader() {}
 
   void createWriter(SampleProfileFormat Format, StringRef Profile) {
     std::error_code EC;
     std::unique_ptr<raw_ostream> OS(
         new raw_fd_ostream(Profile, EC, sys::fs::OF_None));
-    auto WriterOrErr = SampleProfileWriter::create(OS, Format);
+    auto WriterOrErr = SampleProfileWriter::create(
+        OS, Format, compression::CompressionKind::Zlib);
     ASSERT_TRUE(NoError(WriterOrErr.getError()));
     Writer = std::move(WriterOrErr.get());
   }
 
   void readProfile(const Module &M, StringRef Profile,
                    StringRef RemapFile = "") {
     auto ReaderOrErr = SampleProfileReader::create(
         std::string(Profile), Context, FSDiscriminatorPass::Base,