[llvm] Remove unused and redundant crc32 funcction from llvm::compression::zlib namespace

[ckissane]

Summary

• Remove crc32 from zlib compression namespace, people should use the llvm::crc32 instead.

[ckissane]

up release notes

[leonardchan]

Feedback needed on:
this namespace approach will result in tooling compression methods being set at compile time, however we may want to aim for a runtime configurable approach in the future, likely a new revision of the compressed data formats that llvm interfaces with with outside tools IE:

• clang ast serialization code could be changed so compressed data could have a flag indicating a compression type.
• profile data code could be changed so compressed data could have a flag indicating a compression type as well.

Using the compile time approach for now with the runtime approach in the future SGTM. I think some flag that could specify the decompression type is what we want in the long term, but the compile time approach I think is ok for now to not block you.

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

242

nit: Could we add some function that returns a string of whatever compression is used? This way we have a more descriptive error message showing what specifically is unavailable. Same comment elsewhere there's logging/error reporting but the string is "compression::serialize".

llvm/unittests/Support/CompressionTest.cpp

68

Should this be replaced with llvm::crc32 rather than deleting this?

[ckissane]

llvm/unittests/Support/CompressionTest.cpp

68

No Because llvm::crc32 has it's own tests already

[ckissane]

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

242

sure, I can add a AlgorithmName property to the zlib namespace and future compression namespaces, then we can print out compression::serialize::AlgorithmName to see what is being used

[ckissane]

add AlgorithmName to compression namespaces

[ckissane]

Marked name of algorithm comments as done

[ckissane]

• feat: refactor llvm compression namespaces
• chore: update rel notes to note zlib::crc32 remove
• feat: add AlgorithmName to compression namespaces

[ckissane]

• Merge remote-tracking branch 'origin/main' into ckissane.refactor-compression-namespace

[leonardchan]

llvm/docs/ReleaseNotes.rst

183–191

I think maybe even more of these could be split into further patches. I would expect that this patch contain just the namespace refactoring but not necessarily any code deletion or cmake changes. I think this could be:

• One patch that's just the namespace changes; anything else like variable name changes or string changes would be in separate patches, then this patch would be pure RFC and can get a quick LGTM
  • One followup patch to this that adds AlgorithmName to the nested zlib namespace.
• One patch that removes crc32 (and its test)
• One patch for cmake changes
• One patch for the zlib_unavailable -> compression_unavailable change and logging string changes in profdata

And if necessary, each of them would have an appropriate ReleaseNodes.rst update.

llvm/lib/Support/Compression.cpp

32

Should createError still be wrapped with #if LLVM_ENABLE_ZLIB?

[MaskRay]

llvm/docs/ReleaseNotes.rst

183–191

I agree with this plan. Changes like zlib_unavailable need to bring attention to the usual contributors/reviewers in the area.

llvm/lib/Support/Compression.cpp

26–27

llvm/unittests/Support/CompressionTest.cpp

22

[ckissane]

make part 1 after part 0 of refactor

[ckissane]

• Merge branch 'ckissane.refactor-compression.part-0' into ckissane.refactor-compression.part-1

[leonardchan]

LGTM. Should probably add [llvm] to the subject also. Generally it's helpful for immediately knowing which subrepo you're touching.

[ckissane]

addressed comments marked done

[ckissane]

updated diff

[MaskRay]

Thanks!

llvm/lib/Support/Compression.cpp

25

if a previous patch introduces a blank line between two using. please drop it from the previous patch.

llvm/unittests/Support/CompressionTest.cpp

21–23

if a previous patch introduces a blank line between two using. please drop it from the previous patch.

[ckissane]

• remove crc32 from zlib compression namespace
• Merge branch 'ckissane.refactor-compression.part-0' into ckissane.refactor-compression.part-1
• Merge branch 'ckissane.refactor-compression.part-0.no-string-sub' into ckissane.refactor-compression.part-1
• Merge remote-tracking branch 'origin/ckissane.refactor-compression.part-0.no-string-sub' into ckissane.refactor-compression.part-1

[ckissane]

mark handled comments as done

[MaskRay]

You may push this patch and its prerequisite while other patches are still to be reviewed.

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

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::zlib::isAvailable()) {
+    if (llvm::compression::serialize::isAvailable()) {
       llvm::SmallString<1> Compressed;
-      llvm::zlib::compress(RawTable, Compressed);
+      llvm::compression::serialize::compress(RawTable, Compressed);
       write32(RawTable.size(), OS);
       OS << 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::SmallString<1> UncompressedStorage;
   if (UncompressedSize == 0) // No compression
     Uncompressed = R.rest();
-  else if (llvm::zlib::isAvailable()) {
+  else if (llvm::compression::serialize::isAvailable()) {
     // 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);
 
-    if (llvm::Error E = llvm::zlib::uncompress(R.rest(), UncompressedStorage,
-                                               UncompressedSize))
+    if (llvm::Error E = llvm::compression::serialize::uncompress(
+            R.rest(), UncompressedStorage, UncompressedSize))
       return std::move(E);
     Uncompressed = UncompressedStorage;
   } else
-    return error("Compressed string table, but zlib is unavailable");
+    return error(
+        "Compressed string table, but compression::serialize is unavailable");
 
   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

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::zlib::isAvailable()) {
-    log("skipping test, no zlib");
+  if (!llvm::compression::serialize::isAvailable()) {
+    log("skipping test, no compression::serialize");
     return;
   }
 
   // First, create a valid serialized file.
   auto In = readIndexFile(YAML);
   ASSERT_FALSE(!In) << In.takeError();
   IndexFileOut Out(*In);
   Out.Format = IndexFileFormat::RIFF;

clang/lib/Driver/ToolChains/Clang.cpp

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::zlib::isAvailable()) {
+      if (llvm::compression::zlib::isAvailable()) {
         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

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::zlib::isAvailable()) {
-        Error("zlib is not available");
+      if (!llvm::compression::serialize::isAvailable()) {
+        Error("compression::serialize is not available");
         return nullptr;
       }
       SmallString<0> Uncompressed;
-      if (llvm::Error E =
-              llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
+      if (llvm::Error E = llvm::compression::serialize::uncompress(
+              Blob, Uncompressed, Record[0])) {
         Error("could not decompress embedded file contents: " +
               llvm::toString(std::move(E)));
         return nullptr;
       }
       return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
     } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
       return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
     } else {

clang/lib/Serialization/ASTWriter.cpp

 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.
   SmallString<0> CompressedBuffer;
-  if (llvm::zlib::isAvailable()) {
-    llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer);
+  if (llvm::compression::serialize::isAvailable()) {
+    llvm::compression::serialize::compress(Blob.drop_back(1), CompressedBuffer);
     RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1};
     Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record,
                               CompressedBuffer);
     return;
   }
 
   RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB};
   Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob);

lld/ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 if(LLVM_ENABLE_ZLIB)
-  set(imported_libs ZLIB::ZLIB)
+  list(APPEND imported_libs ZLIB::ZLIB)
 endif()
 
 add_lld_library(lldELF
   AArch64ErrataFix.cpp
   Arch/AArch64.cpp
   Arch/AMDGPU.cpp
   Arch/ARM.cpp
   Arch/AVR.cpp

lld/ELF/Driver.cpp

 }
 
 static bool getCompressDebugSections(opt::InputArgList &args) {
   StringRef s = args.getLastArgValue(OPT_compress_debug_sections, "none");
   if (s == "none")
     return false;
   if (s != "zlib")
     error("unknown --compress-debug-sections value: " + s);
-  if (!zlib::isAvailable())
+  if (!compression::zlib::isAvailable())
     error("--compress-debug-sections: zlib is not available");
   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

InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags,
   uint32_t v = std::max<uint32_t>(alignment, 1);
   if (!isPowerOf2_64(v))
     fatal(toString(this) + ": sh_addralign is not a power of 2");
   this->alignment = v;
 
   // If SHF_COMPRESSED is set, parse the header. The legacy .zdebug format is no
   // longer supported.
   if (flags & SHF_COMPRESSED) {
-    if (!zlib::isAvailable())
+    if (!compression::zlib::isAvailable())
       error(toString(file) + ": contains a compressed section, " +
             "but zlib is not available");
     invokeELFT(parseCompressedHeader);
   }
 }
 
 // Drop SHF_GROUP bit unless we are producing a re-linkable object file.
 // SHF_GROUP is a marker that a section belongs to some comdat group.
void InputSectionBase::uncompress() const {
   size_t size = uncompressedSize;
   char *uncompressedBuf;
   {
     static std::mutex mu;
     std::lock_guard<std::mutex> lock(mu);
     uncompressedBuf = bAlloc().Allocate<char>(size);
   }
 
-  if (Error e = zlib::uncompress(toStringRef(rawData), uncompressedBuf, size))
+  if (Error e = compression::zlib::uncompress(toStringRef(rawData),
+                                              uncompressedBuf, size))
     fatal(toString(this) +
           ": uncompress failed: " + llvm::toString(std::move(e)));
   rawData = makeArrayRef((uint8_t *)uncompressedBuf, size);
   uncompressedSize = -1;
 }
 
 template <class ELFT> RelsOrRelas<ELFT> InputSectionBase::relsOrRelas() const {
   if (relSecIdx == 0)
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 = zlib::uncompress(toStringRef(rawData), (char *)buf, size))
+    if (Error e = compression::zlib::uncompress(toStringRef(rawData),
+                                                (char *)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/docs/ReleaseNotes.rst

* Add ``LLVMGetAggregateElement`` function as a wrapper for
   only instances of ``ConstantDataSequential``.
 
 * The following functions for creating constant expressions have been removed,
   because the underlying constant expressions are no longer supported. Instead,
   an instruction should be created using the ``LLVMBuildXYZ`` APIs, which will
   constant fold the operands if possible and create an instruction otherwise:
   * ``LLVMConstExtractValue``
 
+* Refactor compression namespaces across the project, making way for a possible
+  introduction of alternatives to zlib compression in the llvm toolchain.
+  Changes are as follows:
+  * Remove crc32 from zlib compression namespace, people should use the ``llvm::crc32`` instead.
+  * Relocate the ``llvm::zlib`` namespace to ``llvm::compression::zlib``.
+  * Code that explictly needs ``zlib`` compression (IE zlib elf debug sections) should use ``llvm::compression::zlib``.
+  * Code interfacing with compressed profile data should use ``llvm::compression::profile``.
+  * Code interfacing with compressed serialized data should use ``llvm::compression::serialize``.
+  * Other code should use ``llvm::compression::tooling``.
+
 Changes to the Go bindings
 --------------------------
 
 
 Changes to the FastISel infrastructure
 --------------------------------------
 
 * ...

llvm/include/llvm/ProfileData/InstrProf.h

enum class instrprof_error {
   invalid_prof,
   hash_mismatch,
   count_mismatch,
   counter_overflow,
   value_site_count_mismatch,
   compress_failed,
   uncompress_failed,
   empty_raw_profile,
-  zlib_unavailable
+  compression_unavailable
 };
 
 inline std::error_code make_error_code(instrprof_error E) {
   return std::error_code(static_cast<int>(E), instrprof_category());
 }
 
 class InstrProfError : public ErrorInfo<InstrProfError> {
 public:

llvm/include/llvm/ProfileData/SampleProf.h

enum class sampleprof_error {
   malformed,
   unrecognized_format,
   unsupported_writing_format,
   truncated_name_table,
   not_implemented,
   counter_overflow,
   ostream_seek_unsupported,
   uncompress_failed,
-  zlib_unavailable,
+  compression_unavailable,
   hash_mismatch
 };
 
 inline std::error_code make_error_code(sampleprof_error E) {
   return std::error_code(static_cast<int>(E), sampleprof_category());
 }
 
 inline sampleprof_error MergeResult(sampleprof_error &Accumulator,

llvm/include/llvm/Support/Compression.h

 
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 template <typename T> class SmallVectorImpl;
 class Error;
 class StringRef;
 
+namespace compression {
+
 namespace zlib {
 
 static constexpr int NoCompression = 0;
 static constexpr int BestSpeedCompression = 1;
 static constexpr int DefaultCompression = 6;
 static constexpr int BestSizeCompression = 9;
 
 bool isAvailable();
 
 void compress(StringRef InputBuffer, SmallVectorImpl<char> &CompressedBuffer,
               int Level = DefaultCompression);
 
 Error uncompress(StringRef InputBuffer, char *UncompressedBuffer,
                  size_t &UncompressedSize);
 
 Error uncompress(StringRef InputBuffer,
                  SmallVectorImpl<char> &UncompressedBuffer,
                  size_t UncompressedSize);
 
-uint32_t crc32(StringRef Buffer);
-
-}  // End of namespace zlib
+} // End of namespace zlib
 
+namespace tooling = llvm::compression::zlib;
+
+namespace profile = llvm::compression::tooling;
+
+namespace serialize = llvm::compression::tooling;
+
+} // End of namespace compression
+
 } // End of namespace llvm
 
 #endif

llvm/lib/MC/ELFObjectWriter.cpp

assert((MAI->compressDebugSections() == DebugCompressionType::Z ||
           MAI->compressDebugSections() == DebugCompressionType::GNU) &&
          "expected zlib or zlib-gnu style compression");
 
   SmallVector<char, 128> UncompressedData;
   raw_svector_ostream VecOS(UncompressedData);
   Asm.writeSectionData(VecOS, &Section, Layout);
 
   SmallVector<char, 128> CompressedContents;
-  zlib::compress(StringRef(UncompressedData.data(), UncompressedData.size()),
-                 CompressedContents);
+  compression::zlib::compress(
+      StringRef(UncompressedData.data(), UncompressedData.size()),
 
   bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
   if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
                              ZlibStyle, Sec.getAlignment())) {
     W.OS << UncompressedData;
     return;
   }
 

llvm/lib/ObjCopy/ELF/ELFObject.cpp

const size_t DataOffset = isDataGnuCompressed(Sec.OriginalData)
                                 ? (ZlibGnuMagic.size() + sizeof(Sec.Size))
                                 : sizeof(Elf_Chdr_Impl<ELFT>);
 
   StringRef CompressedContent(
       reinterpret_cast<const char *>(Sec.OriginalData.data()) + DataOffset,
       Sec.OriginalData.size() - DataOffset);
 
   SmallVector<char, 128> DecompressedContent;
-  if (Error Err = zlib::uncompress(CompressedContent, DecompressedContent,
+  if (Error Err =
+          compression::zlib::uncompress(CompressedContent, DecompressedContent,
                                         static_cast<size_t>(Sec.Size)))
     return createStringError(errc::invalid_argument,
                              "'" + Sec.Name + "': " + toString(std::move(Err)));
 
   uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset;
   std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
 
   return Error::success();
 }
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) {
-  zlib::compress(StringRef(reinterpret_cast<const char *>(OriginalData.data()),
-                           OriginalData.size()),
-                 CompressedData);
+  compression::zlib::compress(
+      StringRef(reinterpret_cast<const char *>(OriginalData.data()),
 
   size_t ChdrSize;
   if (CompressionType == DebugCompressionType::GNU) {
     Name = ".z" + Sec.Name.substr(1);
     ChdrSize = sizeof("ZLIB") - 1 + sizeof(uint64_t);
   } else {
     Flags |= ELF::SHF_COMPRESSED;
     ChdrSize =

llvm/lib/Object/Decompressor.cpp

 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
 using namespace llvm::support::endian;
 using namespace object;
 
 Expected<Decompressor> Decompressor::create(StringRef Name, StringRef Data,
                                             bool IsLE, bool Is64Bit) {
-  if (!zlib::isAvailable())
+  if (!compression::zlib::isAvailable())
     return createError("zlib is not available");
 
   Decompressor D(Data);
   Error Err = isGnuStyle(Name) ? D.consumeCompressedGnuHeader()
                                : D.consumeCompressedZLibHeader(Is64Bit, IsLE);
   if (Err)
     return std::move(Err);
   return D;

 }
 
 bool Decompressor::isCompressedELFSection(uint64_t Flags, StringRef Name) {
   return (Flags & ELF::SHF_COMPRESSED) || isGnuStyle(Name);
 }
 
 Error Decompressor::decompress(MutableArrayRef<char> Buffer) {
   size_t Size = Buffer.size();
-  return zlib::uncompress(SectionData, Buffer.data(), Size);
+  return compression::zlib::uncompress(SectionData, Buffer.data(), Size);
 }

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 (!zlib::isAvailable())
+    if (!compression::profile::isAvailable())
       return make_error<CoverageMapError>(
           coveragemap_error::decompression_failed);
 
     // Allocate memory for the decompressed filenames.
     SmallVector<char, 0> StorageBuf;
 
     // Read compressed filenames.
     StringRef CompressedFilenames = Data.substr(0, CompressedLen);
     Data = Data.substr(CompressedLen);
-    auto Err =
-        zlib::uncompress(CompressedFilenames, StorageBuf, UncompressedLen);
+    auto Err = compression::profile::uncompress(CompressedFilenames, StorageBuf,
+                                                UncompressedLen);
     if (Err) {
       consumeError(std::move(Err));
       return make_error<CoverageMapError>(
           coveragemap_error::decompression_failed);
     }
 
     StringRef UncompressedFilenames(StorageBuf.data(), StorageBuf.size());
     RawCoverageFilenamesReader Delegate(UncompressedFilenames, Filenames,

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

std::string FilenamesStr;
     raw_string_ostream FilenamesOS{FilenamesStr};
     for (const auto &Filename : Filenames) {
       encodeULEB128(Filename.size(), FilenamesOS);
       FilenamesOS << Filename;
     }
   }
 
   SmallString<128> CompressedStr;
-  bool doCompression =
-      Compress && zlib::isAvailable() && DoInstrProfNameCompression;
+  bool doCompression = Compress && compression::profile::isAvailable() &&
+                       DoInstrProfNameCompression;
   if (doCompression)
-    zlib::compress(FilenamesStr, CompressedStr, zlib::BestSizeCompression);
+    compression::profile::compress(FilenamesStr, CompressedStr,
+                                   compression::profile::BestSizeCompression);
 
   // ::= <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);

llvm/lib/ProfileData/InstrProf.cpp

case instrprof_error::compress_failed:
     OS << "failed to compress data (zlib)";
     break;
   case instrprof_error::uncompress_failed:
     OS << "failed to uncompress data (zlib)";
     break;
   case instrprof_error::empty_raw_profile:
     OS << "empty raw profile file";
     break;
-  case instrprof_error::zlib_unavailable:
-    OS << "profile uses zlib compression but the profile reader was built "
-          "without zlib support";
+  case instrprof_error::compression_unavailable:
+    OS << "profile uses compression but the profile reader was built "
+          "without support for compression (likely no zlib)";
     break;
   }
 
   // If optional error message is not empty, append it to the message.
   if (!ErrMsg.empty())
     OS << ": " << ErrMsg;
 
   return OS.str();
auto WriteStringToResult = [&](size_t CompressedLen, StringRef InputStr) {
     return Error::success();
   };
 
   if (!doCompression) {
     return WriteStringToResult(0, UncompressedNameStrings);
   }
 
   SmallString<128> CompressedNameStrings;
-  zlib::compress(StringRef(UncompressedNameStrings), CompressedNameStrings,
-                 zlib::BestSizeCompression);
+  compression::profile::compress(StringRef(UncompressedNameStrings),
+                                 CompressedNameStrings,
+                                 compression::profile::BestSizeCompression);
 
   return WriteStringToResult(CompressedNameStrings.size(),
                              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)));
   }
   return collectPGOFuncNameStrings(
-      NameStrs, zlib::isAvailable() && doCompression, Result);
+      NameStrs, compression::profile::isAvailable() && doCompression, 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);
     SmallString<128> UncompressedNameStrings;
     StringRef NameStrings;
     if (isCompressed) {
-      if (!llvm::zlib::isAvailable())
-        return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
+      if (!llvm::compression::profile::isAvailable())
+        return make_error<InstrProfError>(
+            instrprof_error::compression_unavailable);
 
       StringRef CompressedNameStrings(reinterpret_cast<const char *>(P),
                                       CompressedSize);
-      if (Error E =
-              zlib::uncompress(CompressedNameStrings, UncompressedNameStrings,
+      if (Error E = compression::profile::uncompress(CompressedNameStrings,
+                                                     UncompressedNameStrings,
                                                      UncompressedSize)) {
         consumeError(std::move(E));
         return make_error<InstrProfError>(instrprof_error::uncompress_failed);
       }
       P += CompressedSize;
       NameStrings = StringRef(UncompressedNameStrings.data(),
                               UncompressedNameStrings.size());
     } else {
       NameStrings =

llvm/lib/ProfileData/SampleProf.cpp

std::string message(int IE) const override {
     case sampleprof_error::not_implemented:
       return "Unimplemented feature";
     case sampleprof_error::counter_overflow:
       return "Counter overflow";
     case sampleprof_error::ostream_seek_unsupported:
       return "Ostream does not support seek";
     case sampleprof_error::uncompress_failed:
       return "Uncompress failure";
-    case sampleprof_error::zlib_unavailable:
-      return "Zlib is unavailable";
+    case sampleprof_error::compression_unavailable:
+      return "Profile compression is unavailable";
     case sampleprof_error::hash_mismatch:
       return "Function hash mismatch";
     }
     llvm_unreachable("A value of sampleprof_error has no message.");
   }
 };
 
 } // end anonymous namespace

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::zlib::isAvailable())
-    return sampleprof_error::zlib_unavailable;
+  if (!llvm::compression::profile::isAvailable())
+    return sampleprof_error::compression_unavailable;
 
   StringRef CompressedStrings(reinterpret_cast<const char *>(Data),
                               *CompressSize);
   char *Buffer = Allocator.Allocate<char>(DecompressBufSize);
   size_t UCSize = DecompressBufSize;
   llvm::Error E =
-      zlib::uncompress(CompressedStrings, Buffer, UCSize);
+      compression::profile::uncompress(CompressedStrings, Buffer, UCSize);
   if (E)
     return sampleprof_error::uncompress_failed;
   DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileReaderExtBinaryBase::readImpl() {
   const uint8_t *BufStart =

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() {
-  if (!llvm::zlib::isAvailable())
-    return sampleprof_error::zlib_unavailable;
+  if (!llvm::compression::profile::isAvailable())
+    return sampleprof_error::compression_unavailable;
   std::string &UncompressedStrings =
       static_cast<raw_string_ostream *>(LocalBufStream.get())->str();
   if (UncompressedStrings.size() == 0)
     return sampleprof_error::success;
   auto &OS = *OutputStream;
   SmallString<128> CompressedStrings;
-  zlib::compress(UncompressedStrings, CompressedStrings,
-                 zlib::BestSizeCompression);
+  compression::profile::compress(UncompressedStrings, CompressedStrings,
+                                 compression::profile::BestSizeCompression);
   encodeULEB128(UncompressedStrings.size(), OS);
   encodeULEB128(CompressedStrings.size(), OS);
   OS << CompressedStrings.str();
   UncompressedStrings.clear();
   return sampleprof_error::success;
 }
 
 /// Add a new section into section header table given the section type

llvm/lib/Support/CMakeLists.txt

if (HAS_WERROR_GLOBAL_CTORS)
   int main() { (void)TestGlobalCtorDtor; (void)TestGlobalCtorDtor2; return 0;}
   " LLVM_HAS_NOGLOBAL_CTOR_MUTEX)
   if (NOT LLVM_HAS_NOGLOBAL_CTOR_MUTEX)
     string(REPLACE "-Werror=global-constructors" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
   endif()
 endif()
 
 if(LLVM_ENABLE_ZLIB)
-  set(imported_libs ZLIB::ZLIB)
+  list(APPEND imported_libs ZLIB::ZLIB)
 endif()
 
 if( MSVC OR MINGW )
   # libuuid required for FOLDERID_Profile usage in lib/Support/Windows/Path.inc.
   # advapi32 required for CryptAcquireContextW in lib/Support/Windows/Path.inc.
   set(system_libs ${system_libs} psapi shell32 ole32 uuid advapi32)
 elseif( CMAKE_HOST_UNIX )
   if( HAVE_LIBRT )

llvm/lib/Support/Compression.cpp

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #if LLVM_ENABLE_ZLIB
 #include <zlib.h>
 #endif
 
 using namespace llvm;
 
-#if LLVM_ENABLE_ZLIB
+using namespace compression;
+
 static Error createError(StringRef Err) {
   return make_error<StringError>(Err, inconvertibleErrorCode());
 }
 
+#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";
Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
   __msan_unpoison(UncompressedBuffer, UncompressedSize);
   return Res ? createError(convertZlibCodeToString(Res)) : Error::success();
 }
 
 Error zlib::uncompress(StringRef InputBuffer,
                        SmallVectorImpl<char> &UncompressedBuffer,
                        size_t UncompressedSize) {
   UncompressedBuffer.resize_for_overwrite(UncompressedSize);
-  Error E =
-      uncompress(InputBuffer, UncompressedBuffer.data(), UncompressedSize);
+  Error E = zlib::uncompress(InputBuffer, UncompressedBuffer.data(),
+                             UncompressedSize);
   UncompressedBuffer.truncate(UncompressedSize);
   return E;
 }
 
-uint32_t zlib::crc32(StringRef Buffer) {
-  return ::crc32(0, (const Bytef *)Buffer.data(), Buffer.size());
-}
-
 #else
 bool zlib::isAvailable() { return false; }
 void zlib::compress(StringRef InputBuffer,
                     SmallVectorImpl<char> &CompressedBuffer, int Level) {
   llvm_unreachable("zlib::compress is unavailable");
 }
 Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
                        size_t &UncompressedSize) {
   llvm_unreachable("zlib::uncompress is unavailable");
 }
 Error zlib::uncompress(StringRef InputBuffer,
                        SmallVectorImpl<char> &UncompressedBuffer,
                        size_t UncompressedSize) {
   llvm_unreachable("zlib::uncompress is unavailable");
 }
-uint32_t zlib::crc32(StringRef Buffer) {
-  llvm_unreachable("zlib::crc32 is unavailable");
-}
 #endif

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 (!zlib::isAvailable()) {
+    if (!compression::zlib::isAvailable()) {
       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

if (Arg->getOption().getID() == OBJCOPY_compress_debug_sections_eq) {
       if (Config.CompressionType == DebugCompressionType::None)
         return createStringError(
             errc::invalid_argument,
             "invalid or unsupported --compress-debug-sections format: %s",
             InputArgs.getLastArgValue(OBJCOPY_compress_debug_sections_eq)
                 .str()
                 .c_str());
     }
-    if (!zlib::isAvailable())
+    if (!compression::zlib::isAvailable())
       return createStringError(
           errc::invalid_argument,
           "LLVM was not compiled with LLVM_ENABLE_ZLIB: can not compress");
   }
 
   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
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 && !zlib::isAvailable())
+  if (Config.DecompressDebugSections && !compression::zlib::isAvailable())
     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

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 && zlib::isAvailable()),
-                          FuncNameStrings1),
-                      Succeeded());
+    EXPECT_THAT_ERROR(
+        collectPGOFuncNameStrings(
+            FuncNames1, (DoCompression && compression::profile::isAvailable()),
 
     // Compressing:
     std::string FuncNameStrings2;
-    EXPECT_THAT_ERROR(collectPGOFuncNameStrings(
-                          FuncNames2, (DoCompression && zlib::isAvailable()),
-                          FuncNameStrings2),
-                      Succeeded());
+    EXPECT_THAT_ERROR(
+        collectPGOFuncNameStrings(
+            FuncNames2, (DoCompression && compression::profile::isAvailable()),
 
     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/Compression.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
+using namespace compression;
+
 namespace {
 
 #if LLVM_ENABLE_ZLIB
 
 void TestZlibCompression(StringRef Input, int Level) {
   SmallString<32> Compressed;
   SmallString<32> Uncompressed;
 
TEST(CompressionTest, Zlib) {
   StringRef BinaryDataStr(BinaryData, kSize);
 
   TestZlibCompression(BinaryDataStr, zlib::NoCompression);
   TestZlibCompression(BinaryDataStr, zlib::BestSizeCompression);
   TestZlibCompression(BinaryDataStr, zlib::BestSpeedCompression);
   TestZlibCompression(BinaryDataStr, zlib::DefaultCompression);
 }
 
-TEST(CompressionTest, ZlibCRC32) {
-  EXPECT_EQ(
-      0x414FA339U,
-      zlib::crc32(StringRef("The quick brown fox jumps over the lazy dog")));
-}
-
 #endif
 
 }