[Support] compression proposal for a enum->spec->impl approach

[ckissane]

Summary

[compression] move to a enum->spec->impl approach
+ None compression is signified by a nullptr for a CompressionSpecRef
+ Lack of support (lack of impl) is signified by a nullptr for a CompressionImplRef
+ move away from fancy fake enum approach
An alternative/hybrid between D130516 and D130506 and D131638

[dblaikie]

Probably easier to review if it's framed somewhat more like @MaskRay and my examples - backwards compatible, without fixing all the API users as we can discuss those separately.

Though it is useful to have one or two example uses - but having all the API uses being updated in one patch could lead us to discussing the same issues repeatedly if we try to review it all in one go.

llvm/include/llvm/Object/Decompressor.h

52–53

I think the member should be the CompressionImpl, rather than the specref - null if no decompression is requested/needed, and non-null if it's required/provided by the consumeCompressedSectionHeader.

llvm/include/llvm/Support/Compression.h

34–35

Ref when it's actually a pointer might be confusing - not sure if these add more value over using the raw pointers themselves?

37–38

Probably don't need both of these, just the one that takes the enum type?

39

I don't think we need this function?

43

This should probably be a const member & the CompressionImpl's probably immutable, but could be const too, just to be explicit

45

Probably don't need this member - it should be communicated by the non-null-ness of Implementation?

47–49

These could/should probably go in the Implementation since they're not useful when the algorithm isn't available anyway?

86

the imple could have a pointer back to the spec, rather than having to do another lookup/need another function? (though, if the levels are moved to the impl, maybe this API is not needed?)

94–97

Generally we don't want more variables that need global constructors in LLVM - so these should probably be function-local statics in functions instead.
(I don't think we need a CompressionSpecRef for Unknown or None, though)

llvm/lib/Object/Decompressor.cpp

52

This probably isn't a useful error message for a user. And this code is unreachable/untestable, right? The above code would've already errored out on "unsupported compression type"?

[ckissane]

llvm/lib/Object/Decompressor.cpp

52

true, it is essentially a repeat of the above

[ckissane]

• remove Supported member of CompressionSpec

[ckissane]

• move compression level members from spec to impl

[ckissane]

llvm/include/llvm/Support/Compression.h

47–49

done

[ckissane]

• compression: remove some usage sugar from

[ckissane]

llvm/include/llvm/Support/Compression.h

94–97

these are just shortcuts to the function local statics of CompressionSpecRef getCompressionSpec(uint8_t Kind)

[ckissane]

• remove extra includes of ADT/Optional

[dblaikie]

(still a fair few unhandled comments from the last round - guess work to address those is still ongoing)

llvm/include/llvm/Support/Compression.h

94–97

Yeah, though they're still globals with non-trivial construction, which is to be avoided in LLVM ( https://llvm.org/docs/CodingStandards.html#do-not-use-static-constructors )

So they should either be removed (I think that's probably the right tradeoff, and the one I showed in my proposal - callers that want only one specific compression algorithm can pay the small runtime overhead of going through the switch unnecessarily) or replaced with global functions that use function local statics so the initialization is only paid when the functions are called, and not by every program that links in LLVM for any reason.

[ckissane]

llvm/include/llvm/Support/Compression.h

94–97

I concur with removal

[ckissane]

• remove CompressionSpecRefs::{Zlib,ZStd}

[ckissane]

llvm/include/llvm/Support/Compression.h

39

removed

45

removed Supported bool

86

levels are moved to the impl, [thus] this API is not needed

llvm/lib/Object/Decompressor.cpp

52

redundancy removed

[ckissane]

• remove Compression{Spec,Impl}Ref typedef

[ckissane]

• small compression test cleanup

[ckissane]

• fix static initialization skip errors in getCompressionSpec

[ckissane]

llvm/include/llvm/Object/Decompressor.h

52–53

note that null if no decompression is requested/needed falls under the pattern for a CompressionSpec* however as a decompressor *assumes* that it is not none, it could still make sense to make it a CompressionImpl* as you request, which is null if unsupported (and error) and non-null if it's provided by the consumeCompressedSectionHeader.

llvm/include/llvm/Support/Compression.h

34–35

removed typdefs

[ckissane]

• CompressionImplementation member on Decompressor instead of Spec

[ckissane]

@dblaikie I've handled most of your comments, can you take another look?

[dblaikie]

llvm/include/llvm/Object/Decompressor.h

52–53

I don't follow, sorry. All the error handling is done in consumeCompressedSectionHeader - the only thing done after/outside that is one unconditional CompressionScheme->Implementation->decompress - so it doesn't need the CompressionScheme only the impl, which it's going to use unconditionally anyway. The Decompressor::decompress will never be called if the header failed to parse/if there isn't a decompressor ready to handle it.

At least so far as I can see from the code?

llvm/lib/ProfileData/InstrProf.cpp

495

looks like this could be changed to pass the implementation, without the spec? (the caller doesn't need/use the spec)

llvm/lib/Support/Compression.cpp

187

Looks like this comment ( https://reviews.llvm.org/D131992#inline-1270577 ) got lost, as there's still two getCompressionSpec functions - please remove the one taking a raw uint8_t, leaving only the enum version. Callers should deal with validating that they're passing a valid enum to that function, and then getCompressionSpec can return a reference, instead of a pointer - since it'd only be passed a valid compression kind?

I think UnknownD (also, what's the D suffix meant to mean? I can't figure it out from context) can probably be removed, and callers can deal with that case themselves?

llvm/unittests/Support/CompressionTest.cpp

88–89

Probably don't need a named variable for this, since it's only used once on the next line? Roll the getCompressionSpec call into the line below?

90

Across this whole patch I think long variable names are probably making things harder to read/glance at than helpful - especially for shorter lived variables (or ones where the scope cares mostly about the variable anyway, so it's not getting lost amongst other variables/intentions in the code) could you use shorter variable names? (even single letter names or acronyms would probably suffice here - but Spec and Impl might be good for the unit test?)

But also, like I said previously - it'd be good to pull out all the use case changes maybe into another patch - so they can be reviewed separately & this review can focus on the API design (though I realize they're connected - it's helpful to se the use case to understand the design impact, but maybe with one or two small examples, rather than having to change every usage in one go)

[ckissane]

• shorten compression related variable names

[ckissane]

llvm/include/llvm/Support/Compression.h

37–38

removed one

llvm/lib/ProfileData/InstrProf.cpp

495

(the caller doesn't need/use the spec)...
It definitely might in the future because it writes a header, that (in the conceivably near future) (like one of my follow up patches) could contain the uint 8 value of the compression type from the Spec, and 0 if uncompressed.

[MaskRay]

Both D131638 and this patch want to use classes with inheritance to support different compression algorithms.
There have been many versions but I think I have never received a convincing argument how such an inheritance based design looks better / is less error-prone than free functions (D130506).

[dblaikie]

@MaskRay I think this change is probably the best point of comparison/demonstration of this patch direction (taking some minor liberties with this patch to simplify things somewhat in ways that have already been discussed/seem quite reasonable - specifically having getCompresisonSpec return a reference and the enum having either no "unknown" value, or getCompressionSpec asserting on the unknown value):

// removing the hardcoded zlib compression kind parameter in favor of what the code would look like in the near future once it's parameterized on a compression kind
CompressionImplementation *Compressor = getCompressionSpec(CompressionAlgorithmKind)->Implementation;
bool DoCompression = Compress && DoInstrProfNameCompression && Compressor;
if (DoCompression) {
  Compressor->compress(arrayRefFromStringRef(FilenamesStr),
                                  CompressedStr,
                                  Compressor->BestSizeLevel);
}

I think a reasonable speculation about what the alternative would look like in the a non-OO design would be something like:

bool DoCompression = Compress && DoInstrProfNameCompression && isAvailable(CompressionAlgorithmKind);
if (DoCompression) {
  compress(CompressionAlgorithmKind, arrayRefFromStringRef(FilenamesStr), CompressedStr, getBestSizeLevel(CompressionAlgorithmKind));

And having these three correlated calls (isAvailable, compress, and getBestSizeLevel) all made independently/have to have the same compression algorithm kind passed to them independently seems more error prone & redundant (not in an actual execution/runtime efficiency perspective - I don't think any of these different designs would have materially different runtime performance - but in terms of "duplicate work, and work that could diverge/become inconsistent" - essentially the duplicate work/repeated switch statements, one in each compression::* generic entry point seems like a code smell to me that points towards a design that doesn't have that duplication) rather than tying these calls together and making the lookup happen once and then using the features after that. Also exposing the compression algorithm along with the availability in one operation (not exposing compress/decompress/size APIs when the algorithm isn't available) seems to have similar benefits.

I agree it's somewhat overkill for two types of compression, but I don't think it's so burdensome as to be avoided either. I probably wouldn't've put quite this much consideration into the design if I were doing it myself amongst other things, but I appreciate that @ckissane has & I'm pretty happy with where this is now.

A few things still leftover that I think I've mentioned to @ckissane offline:

• getCompressionSpec returning by reference
• more incremental patches - implementing the generic API in terms of the old one (or keeping the old one as a wrapper around the generic one) with at most one or two uses of the API (if any) in the first commit - then subsequent API migrations in future commits, eventually removing the old API once the migration is complete
• having only the getCompressionSpec(CompressionKind) and dropping the version that takes uint8_t - callers should handle mapping from whatever domain-specific format/representation they have into the CompressionKind enum, there's no need for the raw version here
• Probably removing the 'unknown' CompressionKind - if a caller needs to handle having "maybe a compression kind, or none" they can wrap CompressionKind in Optional themselves and handle not looking up the algorithm if no compression kind is desired/requested

llvm/lib/ProfileData/InstrProf.cpp

495

That should/can wait for the future change.

& I think at that point we could get into what the right design might be - and I was thinking maybe the right design might be for the CompressionImplementation to have a pointer back to its spec. But in general, lets defer that design decision for later - it's not too expensive to change what the parameter types are once the data is needed later.

(again, this might be even simpler addressed by not including this change at all up-front - keeping the old API and leaving these callers until you're patching the callers to add the new functionality of being able to choose between Zlib and Zstd - rather than, for now, plumbing in the new API without any change in functionality - the plumbing + functionality together might be easire to understand the motivation for and review, and doing it separately from most of the generic design work will isolate the usage design discussion so each piece can move forward separately, for the most part)

[MaskRay]

(I was out of town last week so I did not respond then.)

In D131992#3748306, @dblaikie wrote:

@MaskRay I think this change is probably the best point of comparison/demonstration of this patch direction (taking some minor liberties with this patch to simplify things somewhat in ways that have already been discussed/seem quite reasonable - specifically having getCompresisonSpec return a reference and the enum having either no "unknown" value, or getCompressionSpec asserting on the unknown value):

I am sorry to disagree... As previously mentioned this is an expression problem.
When we maintain no state in the compression algorithms, the OO style has more boilerplate in llvm/lib/Support and in call sites, so I prefer the FP style (free function style) instead.

(Adding a compression algorithm has a significant barrier. I think we tend to add functions more than adding types. The FP style optimizes for adding new functions (while the OO style optimizes for adding new classes), so the FP style wins here.)

// removing the hardcoded zlib compression kind parameter in favor of what the code would look like in the near future once it's parameterized on a compression kind
CompressionImplementation *Compressor = getCompressionSpec(CompressionAlgorithmKind)->Implementation;
bool DoCompression = Compress && DoInstrProfNameCompression && Compressor;
if (DoCompression) {
  Compressor->compress(arrayRefFromStringRef(FilenamesStr),
                                  CompressedStr,
                                  Compressor->BestSizeLevel);
}

I think a reasonable speculation about what the alternative would look like in the a non-OO design would be something like:

bool DoCompression = Compress && DoInstrProfNameCompression && isAvailable(CompressionAlgorithmKind);
if (DoCompression) {
  compress(CompressionAlgorithmKind, arrayRefFromStringRef(FilenamesStr), CompressedStr, getBestSizeLevel(CompressionAlgorithmKind));

Most call sites do not specify the compression level, so getBestSizeLevel(CompressionAlgorithmKind) is omitted.

And having these three correlated calls (isAvailable, compress, and getBestSizeLevel) all made independently/have to have the same compression algorithm kind passed to them independently seems more error prone & redundant (not in an actual execution/runtime efficiency perspective - I don't think any of these different designs would have materially different runtime performance - but in terms of "duplicate work, and work that could diverge/become inconsistent" - essentially the duplicate work/repeated switch statements, one in each compression::* generic entry point seems like a code smell to me that points towards a design that doesn't have that duplication) rather than tying these calls together and making the lookup happen once and then using the features after that. Also exposing the compression algorithm along with the availability in one operation (not exposing compress/decompress/size APIs when the algorithm isn't available) seems to have similar benefits.

In the FP style (free function style), CompressionAlgorithmKind is passed in multiple places. It is as if, in the OO style, the Compressor object is passed in multiple places.

CompressionAlgorithmKind is an scoped enum and there is hardly another variable of the same type in the scope of CompressionAlgorithmKind. So I do not see how the FP style is more error-prone.
To me, not checking isAvailable(CompressionAlgorithmKind) is similar to not checking the nullness of Compressor.

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

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <vector>
 
+using namespace llvm::compression;
+
 namespace clang {
 namespace clangd {
 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
void finalize(llvm::raw_ostream &OS) {
     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);
     }
-    if (llvm::compression::zlib::isAvailable()) {
+    if (CompressionImpl *CompressionImplementation =
+            getCompressionSpec(CompressionKind::Zlib)->Implementation) {
       llvm::SmallVector<uint8_t, 0> Compressed;
-      llvm::compression::zlib::compress(llvm::arrayRefFromStringRef(RawTable),
+      CompressionImplementation->compress(llvm::arrayRefFromStringRef(RawTable),
                                           Compressed);
       write32(RawTable.size(), OS);
       OS << llvm::toStringRef(Compressed);
     } else {
       write32(0, OS); // No compression.
       OS << RawTable;
     }
   }
   // Get the ID of an string, which must be interned. Table must be finalized.
llvm::Expected<StringTableIn> readStringTable(llvm::StringRef Data) {
   size_t UncompressedSize = R.consume32();
   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 if (llvm::compression::zlib::isAvailable()) {
+  else {
+    // Don't extratc to a CompressionKind CompressionScheme variable
+    // as ratio check is zlib specific
+    if (CompressionImpl *CompressionImplementation =
+            getCompressionSpec(CompressionKind::Zlib)->Implementation) {
       // 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 (UncompressedSize / MaxCompressionRatio > R.rest().size())
-      return error("Bad stri table: uncompress {0} -> {1} bytes is implausible",
-                   R.rest().size(), UncompressedSize);
+        return error(
+            "Bad stri table: uncompress {0} -> {1} bytes is implausible",
 
-    if (llvm::Error E = llvm::compression::zlib::uncompress(
+      if (llvm::Error E = CompressionImplementation->decompress(
               llvm::arrayRefFromStringRef(R.rest()), UncompressedStorage,
               UncompressedSize))
         return std::move(E);
       Uncompressed = toStringRef(UncompressedStorage);
     } else
-    return error("Compressed string table, but zlib is unavailable");
+      return error("Compressed string table, but {0} is unavailable",
+                   getCompressionSpec(CompressionKind::Zlib)->Name);
+  }
 
   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)
       return error("Bad string table: not null terminated");

clang-tools-extra/clangd/unittests/SerializationTests.cpp

 #ifdef LLVM_ON_UNIX
 #include <sys/resource.h>
 #endif
 
 using ::testing::ElementsAre;
 using ::testing::Pair;
 using ::testing::UnorderedElementsAre;
 using ::testing::UnorderedElementsAreArray;
+using namespace llvm::compression;
 
 namespace clang {
 namespace clangd {
 namespace {
 
 const char *YAML = R"(
 ---
 !Symbol
TEST(SerializationTest, NoCrashOnBadArraySize) {
   ASSERT_TRUE(!CorruptParsed);
   EXPECT_EQ(llvm::toString(CorruptParsed.takeError()),
             "malformed or truncated include uri");
 }
 
 // Check we detect invalid string table size size without allocating it first.
 // If this detection fails, the test should allocate a huge array and crash.
 TEST(SerializationTest, NoCrashOnBadStringTableSize) {
-  if (!llvm::compression::zlib::isAvailable()) {
+  if (!getCompressionSpec(CompressionKind::Zlib)->Implementation) {
     log("skipping test, no zlib");
     return;
   }
 
   // First, create a valid serialized file.
   auto In = readIndexFile(YAML);
   ASSERT_FALSE(!In) << In.takeError();
   IndexFileOut Out(*In);

clang/lib/Driver/ToolChains/Clang.cpp

 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/YAMLParser.h"
 #include <cctype>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
+using namespace llvm::compression;
 
 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
   if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
                                options::OPT_fminimize_whitespace,
                                options::OPT_fno_minimize_whitespace)) {
     if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
         !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
       D.Diag(clang::diag::err_drv_argument_only_allowed_with)
static void RenderDebugInfoCompressionArgs(const ArgList &Args,
   const Arg *A = Args.getLastArg(options::OPT_gz_EQ);
   if (!A)
     return;
   if (checkDebugInfoOption(A, Args, D, TC)) {
     StringRef Value = A->getValue();
     if (Value == "none") {
       CmdArgs.push_back("--compress-debug-sections=none");
     } else if (Value == "zlib") {
-      if (llvm::compression::zlib::isAvailable()) {
+      if (getCompressionSpec(CompressionKind::Zlib)->Implementation) {
         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;

clang/lib/Serialization/ASTReader.cpp

 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace clang::serialization;
 using namespace clang::serialization::reader;
 using llvm::BitstreamCursor;
+using namespace llvm::compression;
 
 //===----------------------------------------------------------------------===//
 // ChainedASTReaderListener implementation
 //===----------------------------------------------------------------------===//
 
 bool
 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
   return First->ReadFullVersionInformation(FullVersion) ||
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) {
-      if (!llvm::compression::zlib::isAvailable()) {
-        Error("zlib is not available");
-        return nullptr;
-      }
+      CompressionSpec *CompressionScheme =
+          getCompressionSpec(CompressionKind::Zlib);
+
+      if (CompressionImpl *CompressionImplementation =
+              CompressionScheme->Implementation) {
         SmallVector<uint8_t, 0> Uncompressed;
-      if (llvm::Error E = llvm::compression::zlib::uncompress(
+        if (llvm::Error E = CompressionImplementation->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 {
+        Error("compression class " +
+              (CompressionScheme->Name + " is not available").str());
+        return nullptr;
+      }
     } 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

 #include <memory>
 #include <queue>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace clang::serialization;
+using namespace llvm::compression;
 
 template <typename T, typename Allocator>
 static StringRef bytes(const std::vector<T, Allocator> &v) {
   if (v.empty()) return StringRef();
   return StringRef(reinterpret_cast<const char*>(&v[0]),
                          sizeof(T) * v.size());
 }
 

 
 static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
                      unsigned SLocBufferBlobCompressedAbbrv,
                      unsigned SLocBufferBlobAbbrv) {
   using RecordDataType = ASTWriter::RecordData::value_type;
 
   // Compress the buffer if possible. We expect that almost all PCM
   // consumers will not want its contents.
+  if (CompressionImpl *CompressionImplementation =
+          getCompressionSpec(CompressionKind::Zlib)->Implementation) {
     SmallVector<uint8_t, 0> CompressedBuffer;
-  if (llvm::compression::zlib::isAvailable()) {
-    llvm::compression::zlib::compress(
+
+    CompressionImplementation->compress(
         llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);
     RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1};
     Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record,
                               llvm::toStringRef(CompressedBuffer));
     return;
   }
 
   RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB};

lld/ELF/Driver.cpp

 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::support;
+using namespace llvm::compression;
 using namespace lld;
 using namespace lld::elf;
 
 std::unique_ptr<Configuration> elf::config;
 std::unique_ptr<Ctx> elf::ctx;
 std::unique_ptr<LinkerDriver> elf::driver;
 
 static void setConfigs(opt::InputArgList &args);
for (uint32_t i = 0, size = cgProfile.size(); i < size; ++i) {
       if (from && to)
         config->callGraphProfile[{from, to}] += cgpe.cgp_weight;
     }
   }
 }
 
 static bool getCompressDebugSections(opt::InputArgList &args) {
   StringRef s = args.getLastArgValue(OPT_compress_debug_sections, "none");
-  if (s == "none")
+  if (s == "none") {
     return false;
-  if (s != "zlib")
-    error("unknown --compress-debug-sections value: " + s);
-  if (!compression::zlib::isAvailable())
+  } else if (s == "zlib") {
+    if (!getCompressionSpec(CompressionKind::Zlib)->Implementation)
       error("--compress-debug-sections: zlib is not available");
+  } else {
+    error("unknown --compress-debug-sections value: " + s);
+  }
+
   return true;
 }
 
 static StringRef getAliasSpelling(opt::Arg *arg) {
   if (const opt::Arg *alias = arg->getAlias())
     return alias->getSpelling();
   return arg->getSpelling();
 }

lld/ELF/InputSection.cpp

 #include <algorithm>
 #include <mutex>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
+using namespace llvm::compression;
 using namespace llvm::support::endian;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::elf;
 
 SmallVector<InputSectionBase *, 0> elf::inputSections;
 SmallVector<EhInputSection *, 0> elf::ehInputSections;
 DenseSet<std::pair<const Symbol *, uint64_t>> elf::ppc64noTocRelax;
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::zlib::uncompress(rawData, uncompressedBuf, size))
+  if (Error e =
+          getCompressionSpec(CompressionKind::Zlib)
+              ->Implementation->decompress(rawData, uncompressedBuf, size))
     fatal(toString(this) +
           ": uncompress failed: " + llvm::toString(std::move(e)));
   rawData = makeArrayRef(uncompressedBuf, size);
   uncompressedSize = -1;
 }
 
 template <class ELFT> RelsOrRelas<ELFT> InputSectionBase::relsOrRelas() const {
   if (relSecIdx == 0)
template <typename ELFT> void InputSectionBase::parseCompressedHeader() {
   // 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::zlib::isAvailable())
+    if (!getCompressionSpec(CompressionKind::Zlib)->Implementation)
       error(toString(this) + " is compressed with ELFCOMPRESS_ZLIB, but lld is "
                              "not built with zlib support");
   } else {
     error(toString(this) + ": unsupported compression type (" +
           Twine(hdr->ch_type) + ")");
     return;
   }
 
if (LLVM_UNLIKELY(type == SHT_GROUP)) {
     copyShtGroup<ELFT>(buf);
     return;
   }
 
   // If this is a compressed section, uncompress section contents directly
   // to the buffer.
   if (uncompressedSize >= 0) {
     size_t size = uncompressedSize;
-    if (Error e = compression::zlib::uncompress(rawData, buf, size))
+    if (Error e = getCompressionSpec(CompressionKind::Zlib)
+                      ->Implementation->decompress(rawData, buf, size))
       fatal(toString(this) +
             ": uncompress failed: " + llvm::toString(std::move(e)));
     uint8_t *bufEnd = buf + size;
     relocate<ELFT>(buf, bufEnd);
     return;
   }
 
   // Copy section contents from source object file to output file

llvm/include/llvm/Object/Decompressor.h

 //===-- Decompressor.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===/
 
 #ifndef LLVM_OBJECT_DECOMPRESSOR_H
 #define LLVM_OBJECT_DECOMPRESSOR_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace object {
 
 /// Decompressor helps to handle decompression of compressed sections.
 class Decompressor {
 public:
public:
   Error decompress(MutableArrayRef<uint8_t> Buffer);
 
   /// Return memory buffer size required for decompression.
   uint64_t getDecompressedSize() { return DecompressedSize; }
 
 private:
   Decompressor(StringRef Data);
 
-  Error consumeCompressedZLibHeader(bool Is64Bit, bool IsLittleEndian);
+  Error consumeCompressedSectionHeader(bool Is64Bit, bool IsLittleEndian);
 
   StringRef SectionData;
   uint64_t DecompressedSize;
+  compression::CompressionSpec *CompressionScheme = nullptr;
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_DECOMPRESSOR_H

llvm/include/llvm/ProfileData/InstrProf.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfData.inc"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>

 /// method generates a combined string \c Result that is ready to be
 /// serialized.  The \c Result string is comprised of three fields:
 /// The first field is the length of the uncompressed strings, and the
 /// the second field is the length of the zlib-compressed string.
 /// Both fields are encoded in ULEB128.  If \c doCompress is false, the
 ///  third field is the uncompressed strings; otherwise it is the
 /// compressed string. When the string compression is off, the
 /// second field will have value zero.
-Error collectPGOFuncNameStrings(ArrayRef<std::string> NameStrs,
-                                bool doCompression, std::string &Result);
+Error collectPGOFuncNameStrings(
+    ArrayRef<std::string> NameStrs,
+    compression::CompressionSpec *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);
 
 /// \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

llvm/include/llvm/Support/Compression.h

 //===-- llvm/Support/Compression.h ---Compression----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains basic functions for compression/uncompression.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_COMPRESSION_H
 #define LLVM_SUPPORT_COMPRESSION_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 template <typename T> class SmallVectorImpl;
 class Error;
 
 namespace compression {
-namespace zlib {
 
-constexpr int NoCompression = 0;
-constexpr int BestSpeedCompression = 1;
-constexpr int DefaultCompression = 6;
-constexpr int BestSizeCompression = 9;
+enum class CompressionKind : uint8_t { Zlib = 1, ZStd = 2, Unknown = 255 };
 
-bool isAvailable();
+struct CompressionSpec;
+struct CompressionImpl;
 
-void compress(ArrayRef<uint8_t> Input,
-              SmallVectorImpl<uint8_t> &CompressedBuffer,
-              int Level = DefaultCompression);
-
-Error uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                 size_t &UncompressedSize);
-
-Error uncompress(ArrayRef<uint8_t> Input,
-                 SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                 size_t UncompressedSize);
-
-} // End of namespace zlib
-
-namespace zstd {
+CompressionSpec *getCompressionSpec(uint8_t Kind);
+CompressionSpec *getCompressionSpec(CompressionKind Kind);
 
-constexpr int NoCompression = -5;
-constexpr int BestSpeedCompression = 1;
-constexpr int DefaultCompression = 5;
-constexpr int BestSizeCompression = 12;
-
-bool isAvailable();
-
-void compress(ArrayRef<uint8_t> Input,
+struct CompressionSpec {
+  const CompressionKind Kind;
+  CompressionImpl *Implementation;
+  const StringRef Name;
+  const StringRef Status; // either "supported", or "unsupported: REASON"
+
+protected:
+  friend CompressionSpec *getCompressionSpec(uint8_t Kind);
+  CompressionSpec(CompressionKind Kind, CompressionImpl *Implementation,
+                  StringRef Name, bool Supported, StringRef Status)
+      : Kind(Kind), Implementation(Supported ? Implementation : nullptr),
+        Name(Name), Status(Supported ? "supported" : Status) {}
+};
+
+struct CompressionImpl {
+  const CompressionKind Kind;
+  const int BestSpeedLevel;
+  const int DefaultLevel;
+  const int BestSizeLevel;
+  virtual void compress(ArrayRef<uint8_t> Input,
                         SmallVectorImpl<uint8_t> &CompressedBuffer,
-              int Level = DefaultCompression);
-
-Error uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                 size_t &UncompressedSize);
+                        int Level) = 0;
+  virtual Error decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
+                           size_t &UncompressedSize) = 0;
+  void compress(ArrayRef<uint8_t> Input,
+                SmallVectorImpl<uint8_t> &CompressedBuffer) {
+    return compress(Input, CompressedBuffer, DefaultLevel);
+  }
 
-Error uncompress(ArrayRef<uint8_t> Input,
+  Error decompress(ArrayRef<uint8_t> Input,
                    SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                 size_t UncompressedSize);
-
-} // End of namespace zstd
+                   size_t UncompressedSize) {
+    UncompressedBuffer.resize_for_overwrite(UncompressedSize);
+    Error E = decompress(Input, UncompressedBuffer.data(), UncompressedSize);
+    if (UncompressedSize < UncompressedBuffer.size())
+      UncompressedBuffer.truncate(UncompressedSize);
+    return E;
+  }
+
+protected:
+  CompressionImpl(CompressionKind Kind, int BestSpeedLevel, int DefaultLevel,
+                  int BestSizeLevel)
+      : Kind(Kind), BestSpeedLevel(BestSpeedLevel), DefaultLevel(DefaultLevel),
+        BestSizeLevel(BestSizeLevel) {}
+};
 
 } // End of namespace compression
 
 } // End of namespace llvm
 
 #endif

llvm/lib/MC/ELFObjectWriter.cpp

 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 
 #undef  DEBUG_TYPE
 #define DEBUG_TYPE "reloc-info"
 
 namespace {
 
 using SectionIndexMapTy = DenseMap<const MCSectionELF *, uint32_t>;
 

 
 void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
                                  const MCAsmLayout &Layout) {
   MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
   StringRef SectionName = Section.getName();
 
   auto &MC = Asm.getContext();
   const auto &MAI = MC.getAsmInfo();
-
-  bool CompressionEnabled =
-      MAI->compressDebugSections() != DebugCompressionType::None;
+  const DebugCompressionType CompressionType = MAI->compressDebugSections();
+  bool CompressionEnabled = CompressionType != DebugCompressionType::None;
   if (!CompressionEnabled || !SectionName.startswith(".debug_")) {
     Asm.writeSectionData(W.OS, &Section, Layout);
     return;
   }
 
-  assert(MAI->compressDebugSections() == DebugCompressionType::Z &&
+  assert(CompressionType == DebugCompressionType::Z &&
          "expected zlib 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;
-  compression::zlib::compress(
+
+  if (CompressionImpl *CompressionImplementation =
+          getCompressionSpec(CompressionKind::Zlib)->Implementation) {
+    CompressionImplementation->compress(
         makeArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()),
                      UncompressedData.size()),
         Compressed);
 
     if (!maybeWriteCompression(ChType, UncompressedData.size(), Compressed,
                                Sec.getAlignment())) {
       W.OS << UncompressedData;
       return;
     }
+  } else {
+    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));
   W.OS << toStringRef(Compressed);
 }
 

llvm/lib/ObjCopy/ELF/ELFObject.cpp

 #include <cstdint>
 #include <iterator>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
+using namespace llvm::compression;
 using namespace llvm::objcopy::elf;
 using namespace llvm::object;
 
 template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
   uint8_t *B = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
                Obj.ProgramHdrSegment.Offset + Seg.Index * sizeof(Elf_Phdr);
   Elf_Phdr &Phdr = *reinterpret_cast<Elf_Phdr *>(B);
   Phdr.p_type = Seg.Type;
Error SectionWriter::visit(const OwnedDataSection &Sec) {
   return Error::success();
 }
 
 template <class ELFT>
 Error ELFSectionWriter<ELFT>::visit(const DecompressedSection &Sec) {
   ArrayRef<uint8_t> Compressed =
       Sec.OriginalData.slice(sizeof(Elf_Chdr_Impl<ELFT>));
   SmallVector<uint8_t, 128> DecompressedContent;
-  if (Error Err = compression::zlib::uncompress(Compressed, DecompressedContent,
-                                                static_cast<size_t>(Sec.Size)))
+  DebugCompressionType CompressionType =
+      reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Sec.OriginalData.data())
+                  ->ch_type == ELF::ELFCOMPRESS_ZLIB
+          ? DebugCompressionType::Z
+          : DebugCompressionType::None;
+
+  switch (CompressionType) {
+  case DebugCompressionType::Z:
+    if (Error Err1 =
+            getCompressionSpec(CompressionKind::Zlib)
+                ->Implementation->decompress(Compressed, DecompressedContent,
+                                             static_cast<size_t>(Sec.Size))) {
       return createStringError(errc::invalid_argument,
-                             "'" + Sec.Name + "': " + toString(std::move(Err)));
+                               "'" + Sec.Name +
+                                   "': " + toString(std::move(Err1)));
+    }
+    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);
 
   return Error::success();
 }
 
 Error BinarySectionWriter::visit(const DecompressedSection &Sec) {
Error ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
   std::copy(Sec.CompressedData.begin(), Sec.CompressedData.end(), Buf);
   return Error::success();
 }
 
 CompressedSection::CompressedSection(const SectionBase &Sec,
                                      DebugCompressionType CompressionType)
     : SectionBase(Sec), CompressionType(CompressionType),
       DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) {
-  compression::zlib::compress(OriginalData, CompressedData);
+  switch (CompressionType) {
+  case DebugCompressionType::Z:
+    getCompressionSpec(CompressionKind::Zlib)
+        ->Implementation->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>),
                         sizeof(object::Elf_Chdr_Impl<object::ELF64BE>)),
                std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
                         sizeof(object::Elf_Chdr_Impl<object::ELF32BE>)));

llvm/lib/Object/Decompressor.cpp

 //===-- Decompressor.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/Decompressor.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace llvm::support::endian;
 using namespace object;
 
 Expected<Decompressor> Decompressor::create(StringRef Name, StringRef Data,
                                             bool IsLE, bool Is64Bit) {
-  if (!compression::zlib::isAvailable())
-    return createError("zlib is not available");
 
   Decompressor D(Data);
-  if (Error Err = D.consumeCompressedZLibHeader(Is64Bit, IsLE))
+  if (Error Err = D.consumeCompressedSectionHeader(Is64Bit, IsLE))
     return std::move(Err);
   return D;
 }
 
 Decompressor::Decompressor(StringRef Data)
     : SectionData(Data), DecompressedSize(0) {}
 
-Error Decompressor::consumeCompressedZLibHeader(bool Is64Bit,
+Error Decompressor::consumeCompressedSectionHeader(bool Is64Bit,
                                                    bool IsLittleEndian) {
   using namespace ELF;
   uint64_t HdrSize = Is64Bit ? sizeof(Elf64_Chdr) : sizeof(Elf32_Chdr);
   if (SectionData.size() < HdrSize)
     return createError("corrupted compressed section header");
 
   DataExtractor Extractor(SectionData, IsLittleEndian, 0);
   uint64_t Offset = 0;
-  if (Extractor.getUnsigned(&Offset, Is64Bit ? sizeof(Elf64_Word)
-                                             : sizeof(Elf32_Word)) !=
-      ELFCOMPRESS_ZLIB)
+  uint64_t ELFCompressionSchemeId = Extractor.getUnsigned(
+      &Offset, Is64Bit ? sizeof(Elf64_Word) : sizeof(Elf32_Word));
+  if (ELFCompressionSchemeId == ELFCOMPRESS_ZLIB)
+    CompressionScheme = getCompressionSpec(CompressionKind::Zlib);
+
+  if (!CompressionScheme)
     return createError("unsupported compression type");
+  if (!CompressionScheme->Implementation)
+    return createError(CompressionScheme->Name + " is not available");
 
   // Skip Elf64_Chdr::ch_reserved field.
   if (Is64Bit)
     Offset += sizeof(Elf64_Word);
 
   DecompressedSize = Extractor.getUnsigned(
       &Offset, Is64Bit ? sizeof(Elf64_Xword) : sizeof(Elf32_Word));
   SectionData = SectionData.substr(HdrSize);
   return Error::success();
 }
 
 Error Decompressor::decompress(MutableArrayRef<uint8_t> Buffer) {
   size_t Size = Buffer.size();
-  return compression::zlib::uncompress(arrayRefFromStringRef(SectionData),
-                                       Buffer.data(), Size);
+  return CompressionScheme->Implementation->decompress(
+      arrayRefFromStringRef(SectionData), Buffer.data(), Size);
 }

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace coverage;
 using namespace object;
 
 #define DEBUG_TYPE "coverage-mapping"
 
 STATISTIC(CovMapNumRecords, "The # of coverage function records");
 STATISTIC(CovMapNumUsedRecords, "The # of used coverage function records");
 
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::zlib::isAvailable())
-      return make_error<CoverageMapError>(
-          coveragemap_error::decompression_failed);
+    if (CompressionImpl *CompressionImplementation =
+            getCompressionSpec(CompressionKind::Zlib)->Implementation) {
 
       // 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::zlib::uncompress(
+      auto Err = CompressionImplementation->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);
     }
+    return make_error<CoverageMapError>(
+        coveragemap_error::decompression_failed);
+  }
 
   return readUncompressed(Version, NumFilenames);
 }
 
 Error RawCoverageFilenamesReader::readUncompressed(CovMapVersion Version,
                                                    uint64_t NumFilenames) {
   // Read uncompressed filenames.
   if (Version < CovMapVersion::Version6) {

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

 //===- CoverageMappingWriter.cpp - Code coverage mapping writer -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing coverage mapping data for
 // instrumentation based coverage.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <limits>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace coverage;
 
 CoverageFilenamesSectionWriter::CoverageFilenamesSectionWriter(
     ArrayRef<std::string> Filenames)
     : 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) {
   std::string FilenamesStr;
   {
     raw_string_ostream FilenamesOS{FilenamesStr};
     for (const auto &Filename : Filenames) {
       encodeULEB128(Filename.size(), FilenamesOS);
       FilenamesOS << Filename;
     }
   }
 
   SmallVector<uint8_t, 128> CompressedStr;
-  bool doCompression = Compress && compression::zlib::isAvailable() &&
-                       DoInstrProfNameCompression;
-  if (doCompression)
-    compression::zlib::compress(arrayRefFromStringRef(FilenamesStr),
-                                CompressedStr,
-                                compression::zlib::BestSizeCompression);
+  CompressionSpec *CompressionScheme =
+      getCompressionSpec(CompressionKind::Zlib);
+  bool DoCompression = Compress && DoInstrProfNameCompression &&
+                       (CompressionScheme && CompressionScheme->Implementation);
+  if (DoCompression) {
+    CompressionScheme->Implementation->compress(
+        arrayRefFromStringRef(FilenamesStr), CompressedStr,
+        CompressionScheme->Implementation->BestSizeLevel);
+  }
 
   // ::= <num-filenames>
   //     <uncompressed-len>
   //     <compressed-len-or-zero>
   //     (<compressed-filenames> | <uncompressed-filenames>)
   encodeULEB128(Filenames.size(), OS);
   encodeULEB128(FilenamesStr.size(), OS);
-  encodeULEB128(doCompression ? CompressedStr.size() : 0U, OS);
-  OS << (doCompression ? toStringRef(CompressedStr) : StringRef(FilenamesStr));
+  encodeULEB128(DoCompression ? CompressedStr.size() : 0U, OS);
+  OS << (DoCompression ? toStringRef(CompressedStr) : StringRef(FilenamesStr));
 }
 
 namespace {
 
 /// Gather only the expressions that are used by the mapping
 /// regions in this function.
 class CounterExpressionsMinimizer {
   ArrayRef<CounterExpression> Expressions;

llvm/lib/ProfileData/InstrProf.cpp

 #include <memory>
 #include <string>
 #include <system_error>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 
 static cl::opt<bool> StaticFuncFullModulePrefix(
     "static-func-full-module-prefix", cl::init(true), cl::Hidden,
     cl::desc("Use full module build paths in the profile counter names for "
              "static functions."));
 
 // This option is tailored to users that have different top-level directory in
 // profile-gen and profile-use compilation. Users need to specific the number
uint64_t InstrProfSymtab::getFunctionHashFromAddress(uint64_t Address) {
   // mapping data to be used by the deserializer. Force the value to
   // be 0 in this case.
   if (It != AddrToMD5Map.end() && It->first == Address)
     return (uint64_t)It->second;
   return 0;
 }
 
 Error collectPGOFuncNameStrings(ArrayRef<std::string> NameStrs,
-                                bool doCompression, std::string &Result) {
+                                CompressionSpec *OptionalCompressionScheme,
+                                std::string &Result) {
   assert(!NameStrs.empty() && "No name data to emit");
 
   uint8_t Header[16], *P = Header;
   std::string UncompressedNameStrings =
       join(NameStrs.begin(), NameStrs.end(), getInstrProfNameSeparator());
 
   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) {
     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();
   };
 
-  if (!doCompression) {
+  if ((!OptionalCompressionScheme) ||
+      (!(OptionalCompressionScheme->Implementation)))
     return WriteStringToResult(0, UncompressedNameStrings);
-  }
-
+  CompressionImpl *CompressionImplementation =
+      OptionalCompressionScheme->Implementation;
   SmallVector<uint8_t, 128> CompressedNameStrings;
-  compression::zlib::compress(arrayRefFromStringRef(UncompressedNameStrings),
-                              CompressedNameStrings,
-                              compression::zlib::BestSizeCompression);
+  CompressionImplementation->compress(
+      arrayRefFromStringRef(UncompressedNameStrings), CompressedNameStrings,
+      CompressionImplementation->BestSizeLevel);
 
   return WriteStringToResult(CompressedNameStrings.size(),
                              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) {
   std::vector<std::string> NameStrs;
   for (auto *NameVar : NameVars) {
     NameStrs.push_back(std::string(getPGOFuncNameVarInitializer(NameVar)));
   }
+  CompressionSpec *OptionalCompressionScheme =
+      getCompressionSpec(CompressionKind::Zlib);
   return collectPGOFuncNameStrings(
-      NameStrs, compression::zlib::isAvailable() && doCompression, Result);
+      NameStrs, doCompression ? OptionalCompressionScheme : nullptr, 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);
     SmallVector<uint8_t, 128> UncompressedNameStrings;
     StringRef NameStrings;
     if (isCompressed) {
-      if (!llvm::compression::zlib::isAvailable())
-        return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
+      CompressionSpec *CompressionScheme =
+          getCompressionSpec(CompressionKind::Zlib);
+      if (CompressionImpl *CompressionImplementation =
+              CompressionScheme->Implementation) {
 
-      if (Error E = compression::zlib::uncompress(
+        if (Error E = CompressionImplementation->decompress(
                 makeArrayRef(P, CompressedSize), UncompressedNameStrings,
                 UncompressedSize)) {
           consumeError(std::move(E));
           return make_error<InstrProfError>(instrprof_error::uncompress_failed);
         }
         P += CompressedSize;
         NameStrings = toStringRef(UncompressedNameStrings);
+      } else
+        return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
     } else {
       NameStrings =
           StringRef(reinterpret_cast<const char *>(P), UncompressedSize);
       P += UncompressedSize;
     }
     // Now parse the name strings.
     SmallVector<StringRef, 0> Names;
     NameStrings.split(Names, getInstrProfNameSeparator());

llvm/lib/ProfileData/InstrProfCorrelator.cpp

 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/MachO.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "correlator"
 
 using namespace llvm;
 
 /// Get the __llvm_prf_cnts section.
 Expected<object::SectionRef> getCountersSection(const object::ObjectFile &Obj) {

 template <class IntPtrT>
 Error InstrProfCorrelatorImpl<IntPtrT>::correlateProfileData() {
   assert(Data.empty() && Names.empty() && NamesVec.empty());
   correlateProfileDataImpl();
   if (Data.empty() || NamesVec.empty())
     return make_error<InstrProfError>(
         instrprof_error::unable_to_correlate_profile,
         "could not find any profile metadata in debug info");
-  auto Result =
-      collectPGOFuncNameStrings(NamesVec, /*doCompression=*/false, Names);
+  auto Result = collectPGOFuncNameStrings(NamesVec,
+                                          /*CompressionScheme=*/nullptr, Names);
   CounterOffsets.clear();
   NamesVec.clear();
   return Result;
 }
 
 template <class IntPtrT>
 void InstrProfCorrelatorImpl<IntPtrT>::addProbe(StringRef FunctionName,
                                                 uint64_t CFGHash,

llvm/lib/ProfileData/SampleProfReader.cpp

 #include <cstddef>
 #include <cstdint>
 #include <limits>
 #include <memory>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace sampleprof;
 
 #define DEBUG_TYPE "samplepgo-reader"
 
 // This internal option specifies if the profile uses FS discriminators.
 // It only applies to text, binary and compact binary format profiles.
 // For ext-binary format profiles, the flag is set in the summary.
 static cl::opt<bool> ProfileIsFSDisciminator(
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::zlib::isAvailable())
-    return sampleprof_error::zlib_unavailable;
+  if (CompressionImpl *CompressionImplementation =
+          getCompressionSpec(CompressionKind::Zlib)->Implementation) {
 
     uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize);
     size_t UCSize = DecompressBufSize;
-  llvm::Error E = compression::zlib::uncompress(
+    llvm::Error E = CompressionImplementation->decompress(
         makeArrayRef(Data, *CompressSize), Buffer, UCSize);
     if (E)
       return sampleprof_error::uncompress_failed;
     DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
     return sampleprof_error::success;
   }
+  return sampleprof_error::zlib_unavailable;
+}
 
 std::error_code SampleProfileReaderExtBinaryBase::readImpl() {
   const uint8_t *BufStart =
       reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 
   for (auto &Entry : SecHdrTable) {
     // Skip empty section.
     if (!Entry.Size)

llvm/lib/ProfileData/SampleProfWriter.cpp

 #include <cstdint>
 #include <memory>
 #include <set>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace sampleprof;
 
 std::error_code
 SampleProfileWriter::writeFuncProfiles(const SampleProfileMap &ProfileMap) {
   std::vector<NameFunctionSamples> V;
   sortFuncProfiles(ProfileMap, V);
   for (const auto &I : V) {
     if (std::error_code EC = writeSample(*I.second))
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() {
-  if (!llvm::compression::zlib::isAvailable())
-    return sampleprof_error::zlib_unavailable;
+
+  if (CompressionSpec *CompressionScheme =
+          getCompressionSpec(CompressionKind::Zlib)) {
+    if (CompressionImpl *CompressionImplementation =
+            CompressionScheme->Implementation) {
       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;
-  compression::zlib::compress(arrayRefFromStringRef(UncompressedStrings),
-                              CompressedStrings,
-                              compression::zlib::BestSizeCompression);
+      CompressionImplementation->compress(
+          arrayRefFromStringRef(UncompressedStrings), CompressedStrings,
+          CompressionImplementation->BestSizeLevel);
       encodeULEB128(UncompressedStrings.size(), OS);
       encodeULEB128(CompressedStrings.size(), OS);
       OS << toStringRef(CompressedStrings);
       UncompressedStrings.clear();
       return sampleprof_error::success;
     }
+  }
+  return sampleprof_error::zlib_unavailable;
+}
 
 /// 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];

llvm/lib/Support/Compression.cpp

 #endif
 #if LLVM_ENABLE_ZSTD
 #include <zstd.h>
 #endif
 
 using namespace llvm;
 using namespace llvm::compression;
 
+namespace llvm {
+
+namespace compression {
+
 #if LLVM_ENABLE_ZLIB
 
 static StringRef convertZlibCodeToString(int Code) {
   switch (Code) {
   case Z_MEM_ERROR:
     return "zlib error: Z_MEM_ERROR";
   case Z_BUF_ERROR:
     return "zlib error: Z_BUF_ERROR";
   case Z_STREAM_ERROR:
     return "zlib error: Z_STREAM_ERROR";
   case Z_DATA_ERROR:
     return "zlib error: Z_DATA_ERROR";
   case Z_OK:
   default:
     llvm_unreachable("unknown or unexpected zlib status code");
   }
 }
+#endif
+struct ZlibCompressionAlgorithm : public CompressionImpl {
+#if LLVM_ENABLE_ZLIB
 
-bool zlib::isAvailable() { return true; }
-
-void zlib::compress(ArrayRef<uint8_t> Input,
-                    SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
+  void compress(ArrayRef<uint8_t> Input,
     unsigned long CompressedSize = ::compressBound(Input.size());
     CompressedBuffer.resize_for_overwrite(CompressedSize);
     int Res = ::compress2((Bytef *)CompressedBuffer.data(), &CompressedSize,
                           (const Bytef *)Input.data(), Input.size(), Level);
     if (Res == Z_MEM_ERROR)
       report_bad_alloc_error("Allocation failed");
     assert(Res == Z_OK);
     // Tell MemorySanitizer that zlib output buffer is fully initialized.
     // This avoids a false report when running LLVM with uninstrumented ZLib.
     __msan_unpoison(CompressedBuffer.data(), CompressedSize);
     if (CompressedSize < CompressedBuffer.size())
       CompressedBuffer.truncate(CompressedSize);
-}
-
-Error zlib::uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                       size_t &UncompressedSize) {
+  };
+  Error decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
     int Res =
         ::uncompress((Bytef *)UncompressedBuffer, (uLongf *)&UncompressedSize,
                      (const Bytef *)Input.data(), Input.size());
     // Tell MemorySanitizer that zlib output buffer is fully initialized.
     // This avoids a false report when running LLVM with uninstrumented ZLib.
     __msan_unpoison(UncompressedBuffer, UncompressedSize);
     return Res ? make_error<StringError>(convertZlibCodeToString(Res),
                                          inconvertibleErrorCode())
                : Error::success();
-}
-
-Error zlib::uncompress(ArrayRef<uint8_t> Input,
-                       SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                       size_t UncompressedSize) {
-  UncompressedBuffer.resize_for_overwrite(UncompressedSize);
-  Error E =
-      zlib::uncompress(Input, UncompressedBuffer.data(), UncompressedSize);
-  if (UncompressedSize < UncompressedBuffer.size())
-    UncompressedBuffer.truncate(UncompressedSize);
-  return E;
-}
+  };
 
 #else
-bool zlib::isAvailable() { return false; }
-void zlib::compress(ArrayRef<uint8_t> Input,
-                    SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
-  llvm_unreachable("zlib::compress is unavailable");
-}
-Error zlib::uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                       size_t &UncompressedSize) {
-  llvm_unreachable("zlib::uncompress is unavailable");
-}
-Error zlib::uncompress(ArrayRef<uint8_t> Input,
-                       SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                       size_t UncompressedSize) {
-  llvm_unreachable("zlib::uncompress is unavailable");
-}
+
+  void compress(ArrayRef<uint8_t> Input,
+    llvm_unreachable("method:\"compress\" is unsupported for compression "
+                     "algorithm:\"zlib\", "
+                     "reason:\"llvm not compiled with zlib support\"");
+  };
+  Error decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
+    llvm_unreachable(
+        "method:\"decompress\" is unsupported for compression "
+        "algorithm:\"zlib\", reason:\"llvm not compiled with zlib support\"");
+  };
+
 #endif
 
-#if LLVM_ENABLE_ZSTD
+protected:
+  friend CompressionSpec *getCompressionSpec(uint8_t Kind);
+  ZlibCompressionAlgorithm()
+      : CompressionImpl(CompressionKind::Zlib, 1, 6, 9) {}
+};
 
-bool zstd::isAvailable() { return true; }
+struct ZStdCompressionAlgorithm : public CompressionImpl {
+#if LLVM_ENABLE_ZSTD
 
-void zstd::compress(ArrayRef<uint8_t> Input,
-                    SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
+  void compress(ArrayRef<uint8_t> Input,
     unsigned long CompressedBufferSize = ::ZSTD_compressBound(Input.size());
     CompressedBuffer.resize_for_overwrite(CompressedBufferSize);
     unsigned long CompressedSize =
         ::ZSTD_compress((char *)CompressedBuffer.data(), CompressedBufferSize,
                         (const char *)Input.data(), Input.size(), Level);
     if (ZSTD_isError(CompressedSize))
       report_bad_alloc_error("Allocation failed");
     // Tell MemorySanitizer that zstd output buffer is fully initialized.
     // This avoids a false report when running LLVM with uninstrumented ZLib.
     __msan_unpoison(CompressedBuffer.data(), CompressedSize);
     if (CompressedSize < CompressedBuffer.size())
       CompressedBuffer.truncate(CompressedSize);
-}
-
-Error zstd::uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                       size_t &UncompressedSize) {
+  };
+  Error decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
     const size_t Res =
         ::ZSTD_decompress(UncompressedBuffer, UncompressedSize,
                           (const uint8_t *)Input.data(), Input.size());
     UncompressedSize = Res;
     // Tell MemorySanitizer that zstd output buffer is fully initialized.
     // This avoids a false report when running LLVM with uninstrumented ZLib.
     __msan_unpoison(UncompressedBuffer, UncompressedSize);
     return ZSTD_isError(Res) ? make_error<StringError>(ZSTD_getErrorName(Res),
                                                        inconvertibleErrorCode())
                              : Error::success();
-}
-
-Error zstd::uncompress(ArrayRef<uint8_t> Input,
-                       SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                       size_t UncompressedSize) {
-  UncompressedBuffer.resize_for_overwrite(UncompressedSize);
-  Error E =
-      zstd::uncompress(Input, UncompressedBuffer.data(), UncompressedSize);
-  if (UncompressedSize < UncompressedBuffer.size())
-    UncompressedBuffer.truncate(UncompressedSize);
-  return E;
-}
+  };
 
 #else
-bool zstd::isAvailable() { return false; }
-void zstd::compress(ArrayRef<uint8_t> Input,
-                    SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
-  llvm_unreachable("zstd::compress is unavailable");
-}
-Error zstd::uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
-                       size_t &UncompressedSize) {
-  llvm_unreachable("zstd::uncompress is unavailable");
+
+  void compress(ArrayRef<uint8_t> Input,
+    llvm_unreachable("method:\"compress\" is unsupported for compression "
+                     "algorithm:\"zstd\", "
+                     "reason:\"llvm not compiled with zstd support\"");
+  };
+  Error decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
+    llvm_unreachable(
+        "method:\"decompress\" is unsupported for compression "
+        "algorithm:\"zstd\", reason:\"llvm not compiled with zstd support\"");
+  };
+
+#endif
+
+protected:
+  friend CompressionSpec *getCompressionSpec(uint8_t Kind);
+  ZStdCompressionAlgorithm()
+      : CompressionImpl(CompressionKind::ZStd, 1, 5, 12) {}
+};
+
+CompressionSpec *getCompressionSpec(uint8_t Kind) {
+  switch (Kind) {
+  case uint8_t(0):
+    return nullptr;
+  case uint8_t(CompressionKind::Zlib):
+    static ZlibCompressionAlgorithm ZlibI;
+    static CompressionSpec ZlibD = CompressionSpec(
+        CompressionKind::Zlib, &ZlibI, "zlib", bool(LLVM_ENABLE_ZLIB),
+        "unsupported: either llvm was compiled without LLVM_ENABLE_ZLIB "
+        "enabled, or could not find zlib at compile time");
+    return &ZlibD;
+  case uint8_t(CompressionKind::ZStd):
+    static ZStdCompressionAlgorithm ZStdI;
+    static CompressionSpec ZStdD = CompressionSpec(
+        CompressionKind::ZStd, &ZStdI, "zstd", bool(LLVM_ENABLE_ZSTD),
+        "unsupported: either llvm was compiled without LLVM_ENABLE_ZSTD "
+        "enabled, or could not find zstd at compile time");
+    return &ZStdD;
+  default:
+    static CompressionSpec UnknownD =
+        CompressionSpec(CompressionKind::Unknown, nullptr, "unknown", false,
+                        "unsupported: scheme of unknown kind");
+    return &UnknownD;
   }
-Error zstd::uncompress(ArrayRef<uint8_t> Input,
-                       SmallVectorImpl<uint8_t> &UncompressedBuffer,
-                       size_t UncompressedSize) {
-  llvm_unreachable("zstd::uncompress is unavailable");
 }
-#endif
+
+CompressionSpec *getCompressionSpec(CompressionKind Kind) {
+  return getCompressionSpec(uint8_t(Kind));
+}
+
+} // namespace compression
+} // namespace llvm

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

 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
+using namespace llvm::compression;
 
 static mc::RegisterMCTargetOptionsFlags MOF;
 
 static cl::OptionCategory MCCategory("MC Options");
 
 static cl::opt<std::string> InputFilename(cl::Positional,
                                           cl::desc("<input file>"),
                                           cl::init("-"), cl::cat(MCCategory));
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 (!compression::zlib::isAvailable()) {
+    if (!getCompressionSpec(CompressionKind::Zlib)->Implementation) {
       WithColor::error(errs(), ProgName)
           << "build tools with zlib to enable -compress-debug-sections";
       return 1;
     }
     MAI->setCompressDebugSections(CompressDebugSections);
   }
   MAI->setPreserveAsmComments(PreserveComments);
 

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

 #include "llvm/Support/CRC.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
+using namespace llvm::compression;
 using namespace llvm::objcopy;
 
 namespace {
 enum ObjcopyID {
   OBJCOPY_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   OBJCOPY_##ID,
if (OutputFormat.empty()) {
       Config.OutputArch = Target->Machine;
     }
   }
 
   if (const auto *A = InputArgs.getLastArg(OBJCOPY_compress_debug_sections)) {
     Config.CompressionType = StringSwitch<DebugCompressionType>(A->getValue())
                                  .Case("zlib", DebugCompressionType::Z)
                                  .Default(DebugCompressionType::None);
-    if (Config.CompressionType == DebugCompressionType::None)
+    switch (Config.CompressionType) {
+    case DebugCompressionType::None:
       return createStringError(
           errc::invalid_argument,
           "invalid or unsupported --compress-debug-sections format: %s",
           A->getValue());
-    if (!compression::zlib::isAvailable())
+    case DebugCompressionType::Z:
+      if (!getCompressionSpec(CompressionKind::Zlib)->Implementation)
         return createStringError(
             errc::invalid_argument,
             "LLVM was not compiled with LLVM_ENABLE_ZLIB: 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.
   if (!Config.AddGnuDebugLink.empty()) {
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::zlib::isAvailable())
+  if (Config.DecompressDebugSections &&
+      !getCompressionSpec(CompressionKind::Zlib)->Implementation)
     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");

llvm/unittests/ProfileData/InstrProfTest.cpp

 #include "llvm/Support/Compression.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gtest/gtest.h"
 #include <cstdarg>
 
 using namespace llvm;
+using namespace llvm::compression;
 
 LLVM_NODISCARD static ::testing::AssertionResult
 ErrorEquals(instrprof_error Expected, Error E) {
   instrprof_error Found;
   std::string FoundMsg;
   handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
     Found = IPE.get();
     FoundMsg = IPE.message();
for (int I = 0; I < 3; I++) {
     str.clear();
     OS << "BlahblahBlahblahBar_" << I;
     FuncNames2.push_back(OS.str());
   }
 
   for (bool DoCompression : {false, true}) {
     // Compressing:
     std::string FuncNameStrings1;
-    EXPECT_THAT_ERROR(collectPGOFuncNameStrings(
-                          FuncNames1,
-                          (DoCompression && compression::zlib::isAvailable()),
-                          FuncNameStrings1),
-                      Succeeded());
+    EXPECT_THAT_ERROR(
+        collectPGOFuncNameStrings(
+            DoCompression &&
+                    (getCompressionSpec(CompressionKind::Zlib) &&
+                     getCompressionSpec(CompressionKind::Zlib)->Implementation)
+                ? getCompressionSpec(CompressionKind::Zlib)
+                : nullptr,
 
     // Compressing:
     std::string FuncNameStrings2;
-    EXPECT_THAT_ERROR(collectPGOFuncNameStrings(
-                          FuncNames2,
-                          (DoCompression && compression::zlib::isAvailable()),
-                          FuncNameStrings2),
-                      Succeeded());
+    EXPECT_THAT_ERROR(
+        collectPGOFuncNameStrings(
+            DoCompression &&
+                    (getCompressionSpec(CompressionKind::Zlib) &&
+                     getCompressionSpec(CompressionKind::Zlib)->Implementation)
+                ? getCompressionSpec(CompressionKind::Zlib)
+                : nullptr,
 
     for (int Padding = 0; Padding < 2; Padding++) {
       // Join with paddings :
       std::string FuncNameStrings = FuncNameStrings1;
       for (int P = 0; P < Padding; P++) {
         FuncNameStrings.push_back('\0');
       }
       FuncNameStrings += FuncNameStrings2;

llvm/unittests/Support/CompressionTest.cpp

 #include "llvm/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::compression;
 
 namespace {
 
-#if LLVM_ENABLE_ZLIB
-static void testZlibCompression(StringRef Input, int Level) {
+static void testCompressionAlgorithm(
+    StringRef Input, int Level, CompressionSpec *CompressionScheme,
+    std::string ExpectedDestinationBufferTooSmallErrorMessage) {
   SmallVector<uint8_t, 0> Compressed;
   SmallVector<uint8_t, 0> Uncompressed;
-  zlib::compress(arrayRefFromStringRef(Input), Compressed, Level);
+  CompressionScheme->Implementation->compress(arrayRefFromStringRef(Input),
+                                              Compressed, Level);
 
   // Check that uncompressed buffer is the same as original.
-  Error E = zlib::uncompress(Compressed, Uncompressed, Input.size());
+  Error E = CompressionScheme->Implementation->decompress(
+      Compressed, Uncompressed, Input.size());
   consumeError(std::move(E));
 
   EXPECT_EQ(Input, toStringRef(Uncompressed));
   if (Input.size() > 0) {
     // Uncompression fails if expected length is too short.
-    E = zlib::uncompress(Compressed, Uncompressed, Input.size() - 1);
-    EXPECT_EQ("zlib error: Z_BUF_ERROR", llvm::toString(std::move(E)));
+    E = CompressionScheme->Implementation->decompress(Compressed, Uncompressed,
+                                                      Input.size() - 1);
+    EXPECT_EQ(ExpectedDestinationBufferTooSmallErrorMessage,
+              llvm::toString(std::move(E)));
   }
 }
 
-TEST(CompressionTest, Zlib) {
-  testZlibCompression("", zlib::DefaultCompression);
+#if LLVM_ENABLE_ZLIB
+static void testZlibCompression(StringRef Input, int Level) {
+  testCompressionAlgorithm(Input, Level,
+                           getCompressionSpec(CompressionKind::Zlib),
+                           "zlib error: Z_BUF_ERROR");
+}
 
-  testZlibCompression("hello, world!", zlib::NoCompression);
-  testZlibCompression("hello, world!", zlib::BestSizeCompression);
-  testZlibCompression("hello, world!", zlib::BestSpeedCompression);
-  testZlibCompression("hello, world!", zlib::DefaultCompression);
+TEST(CompressionTest, Zlib) {
+  CompressionSpec *CompressionScheme =
+      getCompressionSpec(CompressionKind::Zlib);
+  CompressionImpl *CompressionImplementation =
+      CompressionScheme->Implementation;
+  testZlibCompression("", CompressionImplementation->DefaultLevel);
+
+  testZlibCompression("hello, world!",
+                      CompressionImplementation->BestSizeLevel);
+  testZlibCompression("hello, world!",
+                      CompressionImplementation->BestSpeedLevel);
+  testZlibCompression("hello, world!", CompressionImplementation->DefaultLevel);
 
   const size_t kSize = 1024;
   char BinaryData[kSize];
   for (size_t i = 0; i < kSize; ++i)
     BinaryData[i] = i & 255;
   StringRef BinaryDataStr(BinaryData, kSize);
 
-  testZlibCompression(BinaryDataStr, zlib::NoCompression);
-  testZlibCompression(BinaryDataStr, zlib::BestSizeCompression);
-  testZlibCompression(BinaryDataStr, zlib::BestSpeedCompression);
-  testZlibCompression(BinaryDataStr, zlib::DefaultCompression);
+  testZlibCompression(BinaryDataStr, CompressionImplementation->BestSizeLevel);
+  testZlibCompression(BinaryDataStr, CompressionImplementation->BestSpeedLevel);
+  testZlibCompression(BinaryDataStr, CompressionImplementation->DefaultLevel);
 }
 #endif
 
 #if LLVM_ENABLE_ZSTD
-static void testZstdCompression(StringRef Input, int Level) {
-  SmallVector<uint8_t, 0> Compressed;
-  SmallVector<uint8_t, 0> Uncompressed;
-  zstd::compress(arrayRefFromStringRef(Input), Compressed, Level);
-
-  // Check that uncompressed buffer is the same as original.
-  Error E = zstd::uncompress(Compressed, Uncompressed, Input.size());
-  consumeError(std::move(E));
-
-  EXPECT_EQ(Input, toStringRef(Uncompressed));
-  if (Input.size() > 0) {
-    // Uncompression fails if expected length is too short.
-    E = zstd::uncompress(Compressed, Uncompressed, Input.size() - 1);
-    EXPECT_EQ("Destination buffer is too small", llvm::toString(std::move(E)));
-  }
-}
-
-TEST(CompressionTest, Zstd) {
-  testZstdCompression("", zstd::DefaultCompression);
-
-  testZstdCompression("hello, world!", zstd::NoCompression);
-  testZstdCompression("hello, world!", zstd::BestSizeCompression);
-  testZstdCompression("hello, world!", zstd::BestSpeedCompression);
-  testZstdCompression("hello, world!", zstd::DefaultCompression);
+static void testZStdCompression(StringRef Input, int Level) {
+  testCompressionAlgorithm(Input, Level,
+                           getCompressionSpec(CompressionKind::ZStd),
+                           "Destination buffer is too small");
+}
+
+TEST(CompressionTest, ZStd) {
+  CompressionSpec *CompressionScheme =
+      getCompressionSpec(CompressionKind::ZStd);
+  CompressionImpl *CompressionImplementation =
+      CompressionScheme->Implementation;
+  testZStdCompression("", CompressionImplementation->DefaultLevel);
+
+  testZStdCompression("hello, world!",
+                      CompressionImplementation->BestSizeLevel);
+  testZStdCompression("hello, world!",
+                      CompressionImplementation->BestSpeedLevel);
+  testZStdCompression("hello, world!", CompressionImplementation->DefaultLevel);
 
   const size_t kSize = 1024;
   char BinaryData[kSize];
   for (size_t i = 0; i < kSize; ++i)
     BinaryData[i] = i & 255;
   StringRef BinaryDataStr(BinaryData, kSize);
 
-  testZstdCompression(BinaryDataStr, zstd::NoCompression);
-  testZstdCompression(BinaryDataStr, zstd::BestSizeCompression);
-  testZstdCompression(BinaryDataStr, zstd::BestSpeedCompression);
-  testZstdCompression(BinaryDataStr, zstd::DefaultCompression);
+  testZStdCompression(BinaryDataStr, CompressionImplementation->BestSizeLevel);
+  testZStdCompression(BinaryDataStr, CompressionImplementation->BestSpeedLevel);
+  testZStdCompression(BinaryDataStr, CompressionImplementation->DefaultLevel);
 }
 #endif
-}
+} // namespace