[NFC] Refactor llvm::zlib namespace

[ckissane]

Summary

• Refactor compression namespaces across the project, making way for a possible introduction of alternatives to zlib compression. Changes are as follows:
  • Relocate the llvm::zlib namespace to llvm::compression::zlib.

[leonardchan]

LGTM. Should also probably add [NFC] to the start of the subject

lld/ELF/InputSection.cpp

79

": contains a compressed section, " + "but " -> ": contains a compressed section, but "

llvm/lib/ProfileData/InstrProf.cpp

155

" compression but the profile reader was built " + "without " -> " compression but the profile reader was built without "

[ckissane]

• Merge branch 'ckissane.refactor-compression.part-0' of github.com:ckissane/llvm-project into ckissane.refactor-compression.part-0
• Merge branch 'main' into ckissane.refactor-compression.part-0

[phosek]

llvm/include/llvm/Support/Compression.h

49–51

I think we will need to support dynamically selecting (de)compression algorithm for both profile and serialization. For example, we should be able to use read profiles generated by an older version of LLVM that only supported zlib, even if the new one also supports zstd. Given that, I'd omit these and instead use compression::zlib everywhere.

[MaskRay]

[NFC] refactor compression namespaces making way for a possible introduction of alternatives to zlib compression in the llvm toolchain.

I'd use [NFC] Refactor llvm::zlib namespace and place supplementary wording to the body.

in the llvm toolchain is redundant in the sentence.

[MaskRay]

llvm/lib/ProfileData/InstrProf.cpp

155

Keep the diagnostic unchanged in this patch.

[ckissane]

llvm/include/llvm/Support/Compression.h

49–51

Correct, however I think that doing this in the meantime helps make it clear semantically for what purpose each compression call is for. It will make finding all instances of each time of use much easier in the future, and promotes semantically thought out usage.

Therefore I see no reason to not make these explicit aliases as it will only ease transition in the future.

[ckissane]

llvm/lib/ProfileData/InstrProf.cpp

155

And the other similar changes?
I will note these are NFC because if zlib is being used (as it currently always is), it has the exact same output.

[MaskRay]

LGTM. Happy when @phosek is happy

[ckissane]

discard debug string changes

[ckissane]

remove compression namespace alias work

[ckissane]

comments addressed

[phosek]

LGTM

[MaskRay]

llvm/include/llvm/Support/Compression.h

27

Is it still used?

Prefer StringRef if the string is backed from some storage.

llvm/unittests/Support/CompressionTest.cpp

21–23

Delete blank line between two using

[ckissane]

llvm/include/llvm/Support/Compression.h

27

No it is not, I will remove it and reintroduce it in the first patch that adds zstd

llvm/unittests/Support/CompressionTest.cpp

21–23

will do

[MaskRay]

I think this can be pushed now. You need to remove the variable

In file included from /var/lib/buildkite-agent/builds/llvm-project/llvm/lib/MC/ELFObjectWriter.cpp:41:
/var/lib/buildkite-agent/builds/llvm-project/llvm/include/llvm/Support/Compression.h:27:30: error: constexpr variable cannot have non-literal type 'const std::string' (aka 'const basic_string<char>')
static constexpr std::string AlgorithmName = "zlib";

You likely need to run ninja check-llvm check-clang check-clang-tools check-lld check-lldb to ensure all relevant targets still build.
(You can use check-all if your lists of LLVM_ENABLED_PROJECTS/LLVM_ENABLE_RUNTIMES are appropriate.)

llvm/include/llvm/Support/Compression.h

48

No need to add blank line between two namespace }.

llvm/lib/Support/Compression.cpp

25–27

delete the excess blank line

[ckissane]

• Merge branch 'ckissane.refactor-compression.part-0' of github.com:ckissane/llvm-project into ckissane.refactor-compression.part-0
• Merge branch 'main' into ckissane.refactor-compression.part-0
• compression refactor: undo string subs
• Merge branch 'ckissane.refactor-compression.part-0' into ckissane.refactor-compression.part-0.no-string-sub
• remove compression namespaace aliases
• update release notes to reflect no compression aliases
• chore: fmt and remove AlgorithmName from zlib namespace
• Merge remote-tracking branch 'origin/main' into ckissane.refactor-compression.part-0.no-string-sub

[ckissane]

• chore: delete an excess blank line

[ckissane]

mark some handled comments done

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");
 
   StringTableIn Table;
   llvm::StringSaver Saver(Table.Arena);
   R = Reader(Uncompressed);

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

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()) {
+      if (!llvm::compression::serialize::isAvailable()) {
         Error("zlib 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/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.
 // That flag doesn't make sense in an executable.
 static uint64_t getFlags(uint64_t flags) {
   flags &= ~(uint64_t)SHF_INFO_LINK;
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:
+  * 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``.
+
 Changes to the Go bindings
 --------------------------
 
 
 Changes to the FastISel infrastructure
 --------------------------------------
 
 * ...

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 std::string AlgorithmName = "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 profile = llvm::compression::zlib;
+
+namespace serialize = llvm::compression::zlib;
+
+} // 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()),
 
   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

 #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::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";
     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())
+      if (!llvm::compression::profile::isAvailable())
         return make_error<InstrProfError>(instrprof_error::zlib_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/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())
+  if (!llvm::compression::profile::isAvailable())
     return sampleprof_error::zlib_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())
+  if (!llvm::compression::profile::isAvailable())
     return sampleprof_error::zlib_unavailable;
   std::string &UncompressedStrings =
       static_cast<raw_string_ostream *>(LocalBufStream.get())->str();
   if (UncompressedStrings.size() == 0)
     return sampleprof_error::success;
   auto &OS = *OutputStream;
   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/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;
 
+using namespace llvm::compression;
+
 #if LLVM_ENABLE_ZLIB
-static Error createError(StringRef Err) {
-  return make_error<StringError>(Err, inconvertibleErrorCode());
-}
 
 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:

 Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
                        size_t &UncompressedSize) {
   int Res =
       ::uncompress((Bytef *)UncompressedBuffer, (uLongf *)&UncompressedSize,
                    (const Bytef *)InputBuffer.data(), InputBuffer.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 ? createError(convertZlibCodeToString(Res)) : Error::success();
+  return Res ? make_error<StringError>(convertZlibCodeToString(Res),
+                                       inconvertibleErrorCode())
+             : 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());
 }
 

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 llvm::compression;
+
 namespace {
 
 #if LLVM_ENABLE_ZLIB
 
 void TestZlibCompression(StringRef Input, int Level) {
   SmallString<32> Compressed;
   SmallString<32> Uncompressed;