Author: Fangrui Song Date: 2022-07-13T16:26:54-07:00 New Revision: e690137dde1c9b037e0c987d393da054d86eeeab
URL: https://github.com/llvm/llvm-project/commit/e690137dde1c9b037e0c987d393da054d86eeeab DIFF: https://github.com/llvm/llvm-project/commit/e690137dde1c9b037e0c987d393da054d86eeeab.diff LOG: [Support] Change compression::zlib::{compress,uncompress} to use uint8_t * It's more natural to use uint8_t * (std::byte needs C++17 and llvm has too much uint8_t *) and most callers use uint8_t * instead of char *. The functions are recently moved into `llvm::compression::zlib::`, so downstream projects need to make adaption anyway. Added: Modified: clang-tools-extra/clangd/index/Serialization.cpp clang/lib/Serialization/ASTReader.cpp clang/lib/Serialization/ASTWriter.cpp lld/ELF/InputSection.cpp lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp llvm/include/llvm/Object/Decompressor.h llvm/include/llvm/Support/Compression.h llvm/lib/MC/ELFObjectWriter.cpp llvm/lib/ObjCopy/ELF/ELFObject.cpp llvm/lib/ObjCopy/ELF/ELFObject.h llvm/lib/Object/Decompressor.cpp llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp llvm/lib/ProfileData/InstrProf.cpp llvm/lib/ProfileData/SampleProfReader.cpp llvm/lib/ProfileData/SampleProfWriter.cpp llvm/lib/Support/Compression.cpp llvm/unittests/Support/CompressionTest.cpp Removed: ################################################################################ diff --git a/clang-tools-extra/clangd/index/Serialization.cpp b/clang-tools-extra/clangd/index/Serialization.cpp index ee86ed5714ec..9fc1567ad919 100644 --- a/clang-tools-extra/clangd/index/Serialization.cpp +++ b/clang-tools-extra/clangd/index/Serialization.cpp @@ -191,10 +191,11 @@ class StringTableOut { RawTable.push_back(0); } if (llvm::compression::zlib::isAvailable()) { - llvm::SmallString<1> Compressed; - llvm::compression::zlib::compress(RawTable, Compressed); + llvm::SmallVector<uint8_t, 0> Compressed; + llvm::compression::zlib::compress(llvm::arrayRefFromStringRef(RawTable), + Compressed); write32(RawTable.size(), OS); - OS << Compressed; + OS << llvm::toStringRef(Compressed); } else { write32(0, OS); // No compression. OS << RawTable; @@ -220,7 +221,7 @@ llvm::Expected<StringTableIn> readStringTable(llvm::StringRef Data) { return error("Truncated string table"); llvm::StringRef Uncompressed; - llvm::SmallString<1> UncompressedStorage; + llvm::SmallVector<uint8_t, 0> UncompressedStorage; if (UncompressedSize == 0) // No compression Uncompressed = R.rest(); else if (llvm::compression::zlib::isAvailable()) { @@ -234,9 +235,10 @@ llvm::Expected<StringTableIn> readStringTable(llvm::StringRef Data) { R.rest().size(), UncompressedSize); if (llvm::Error E = llvm::compression::zlib::uncompress( - R.rest(), UncompressedStorage, UncompressedSize)) + llvm::arrayRefFromStringRef(R.rest()), UncompressedStorage, + UncompressedSize)) return std::move(E); - Uncompressed = UncompressedStorage; + Uncompressed = toStringRef(UncompressedStorage); } else return error("Compressed string table, but zlib is unavailable"); diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index bb98660717e7..04ade0a3b9d0 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -1466,14 +1466,15 @@ bool ASTReader::ReadSLocEntry(int ID) { Error("zlib is not available"); return nullptr; } - SmallString<0> Uncompressed; + SmallVector<uint8_t, 0> Uncompressed; if (llvm::Error E = llvm::compression::zlib::uncompress( - Blob, Uncompressed, Record[0])) { + llvm::arrayRefFromStringRef(Blob), Uncompressed, Record[0])) { Error("could not decompress embedded file contents: " + llvm::toString(std::move(E))); return nullptr; } - return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name); + return llvm::MemoryBuffer::getMemBufferCopy( + llvm::toStringRef(Uncompressed), Name); } else if (RecCode == SM_SLOC_BUFFER_BLOB) { return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true); } else { diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 678105360431..fac8fc141d2c 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -2000,12 +2000,13 @@ static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, // Compress the buffer if possible. We expect that almost all PCM // consumers will not want its contents. - SmallString<0> CompressedBuffer; + SmallVector<uint8_t, 0> CompressedBuffer; if (llvm::compression::zlib::isAvailable()) { - llvm::compression::zlib::compress(Blob.drop_back(1), CompressedBuffer); + llvm::compression::zlib::compress( + llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer); RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1}; Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, - CompressedBuffer); + llvm::toStringRef(CompressedBuffer)); return; } diff --git a/lld/ELF/InputSection.cpp b/lld/ELF/InputSection.cpp index 4ed87d8bdf18..8fe36eca6a4b 100644 --- a/lld/ELF/InputSection.cpp +++ b/lld/ELF/InputSection.cpp @@ -111,18 +111,17 @@ size_t InputSectionBase::getSize() const { void InputSectionBase::uncompress() const { size_t size = uncompressedSize; - char *uncompressedBuf; + uint8_t *uncompressedBuf; { static std::mutex mu; std::lock_guard<std::mutex> lock(mu); - uncompressedBuf = bAlloc().Allocate<char>(size); + uncompressedBuf = bAlloc().Allocate<uint8_t>(size); } - if (Error e = compression::zlib::uncompress(toStringRef(rawData), - uncompressedBuf, size)) + if (Error e = compression::zlib::uncompress(rawData, uncompressedBuf, size)) fatal(toString(this) + ": uncompress failed: " + llvm::toString(std::move(e))); - rawData = makeArrayRef((uint8_t *)uncompressedBuf, size); + rawData = makeArrayRef(uncompressedBuf, size); uncompressedSize = -1; } @@ -1219,8 +1218,7 @@ template <class ELFT> void InputSection::writeTo(uint8_t *buf) { // to the buffer. if (uncompressedSize >= 0) { size_t size = uncompressedSize; - if (Error e = compression::zlib::uncompress(toStringRef(rawData), - (char *)buf, size)) + if (Error e = compression::zlib::uncompress(rawData, buf, size)) fatal(toString(this) + ": uncompress failed: " + llvm::toString(std::move(e))); uint8_t *bufEnd = buf + size; diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index 28ccfbe3d6e6..f9fb36890d5a 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -3386,8 +3386,7 @@ size_t ObjectFileELF::ReadSectionData(Section *section, auto buffer_sp = std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0); if (auto error = Decompressor->decompress( - {reinterpret_cast<char *>(buffer_sp->GetBytes()), - size_t(buffer_sp->GetByteSize())})) { + {buffer_sp->GetBytes(), size_t(buffer_sp->GetByteSize())})) { GetModule()->ReportWarning( "Decompression of section '%s' failed: %s", section->GetName().GetCString(), diff --git a/llvm/include/llvm/Object/Decompressor.h b/llvm/include/llvm/Object/Decompressor.h index e04ee3c3e4c0..00b6c2016742 100644 --- a/llvm/include/llvm/Object/Decompressor.h +++ b/llvm/include/llvm/Object/Decompressor.h @@ -33,12 +33,12 @@ class Decompressor { /// @param Out Destination buffer. template <class T> Error resizeAndDecompress(T &Out) { Out.resize(DecompressedSize); - return decompress({Out.data(), (size_t)DecompressedSize}); + return decompress({(uint8_t *)Out.data(), (size_t)DecompressedSize}); } /// Uncompress section data to raw buffer provided. /// @param Buffer Destination buffer. - Error decompress(MutableArrayRef<char> Buffer); + Error decompress(MutableArrayRef<uint8_t> Buffer); /// Return memory buffer size required for decompression. uint64_t getDecompressedSize() { return DecompressedSize; } diff --git a/llvm/include/llvm/Support/Compression.h b/llvm/include/llvm/Support/Compression.h index fe7a0ed66cfa..c99f811459ab 100644 --- a/llvm/include/llvm/Support/Compression.h +++ b/llvm/include/llvm/Support/Compression.h @@ -13,6 +13,7 @@ #ifndef LLVM_SUPPORT_COMPRESSION_H #define LLVM_SUPPORT_COMPRESSION_H +#include "llvm/ADT/ArrayRef.h" #include "llvm/Support/DataTypes.h" namespace llvm { @@ -30,14 +31,15 @@ constexpr int BestSizeCompression = 9; bool isAvailable(); -void compress(StringRef InputBuffer, SmallVectorImpl<char> &CompressedBuffer, +void compress(ArrayRef<uint8_t> Input, + SmallVectorImpl<uint8_t> &CompressedBuffer, int Level = DefaultCompression); -Error uncompress(StringRef InputBuffer, char *UncompressedBuffer, +Error uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer, size_t &UncompressedSize); -Error uncompress(StringRef InputBuffer, - SmallVectorImpl<char> &UncompressedBuffer, +Error uncompress(ArrayRef<uint8_t> Input, + SmallVectorImpl<uint8_t> &UncompressedBuffer, size_t UncompressedSize); } // End of namespace zlib diff --git a/llvm/lib/MC/ELFObjectWriter.cpp b/llvm/lib/MC/ELFObjectWriter.cpp index 14ea5dc2fddd..78204ffe4c3b 100644 --- a/llvm/lib/MC/ELFObjectWriter.cpp +++ b/llvm/lib/MC/ELFObjectWriter.cpp @@ -145,7 +145,7 @@ struct ELFWriter { uint64_t align(unsigned Alignment); bool maybeWriteCompression(uint64_t Size, - SmallVectorImpl<char> &CompressedContents, + SmallVectorImpl<uint8_t> &CompressedContents, bool ZLibStyle, unsigned Alignment); public: @@ -819,7 +819,7 @@ MCSectionELF *ELFWriter::createRelocationSection(MCContext &Ctx, // Include the debug info compression header. bool ELFWriter::maybeWriteCompression( - uint64_t Size, SmallVectorImpl<char> &CompressedContents, bool ZLibStyle, + uint64_t Size, SmallVectorImpl<uint8_t> &CompressedContents, bool ZLibStyle, unsigned Alignment) { if (ZLibStyle) { uint64_t HdrSize = @@ -875,9 +875,10 @@ void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec, raw_svector_ostream VecOS(UncompressedData); Asm.writeSectionData(VecOS, &Section, Layout); - SmallVector<char, 128> CompressedContents; + SmallVector<uint8_t, 128> CompressedContents; compression::zlib::compress( - StringRef(UncompressedData.data(), UncompressedData.size()), + makeArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()), + UncompressedData.size()), CompressedContents); bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z; @@ -897,7 +898,7 @@ void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec, // Add "z" prefix to section name. This is zlib-gnu style. MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str()); } - W.OS << CompressedContents; + W.OS << toStringRef(CompressedContents); } void ELFWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags, diff --git a/llvm/lib/ObjCopy/ELF/ELFObject.cpp b/llvm/lib/ObjCopy/ELF/ELFObject.cpp index 9f4101b135af..f0e4f91cd347 100644 --- a/llvm/lib/ObjCopy/ELF/ELFObject.cpp +++ b/llvm/lib/ObjCopy/ELF/ELFObject.cpp @@ -463,11 +463,9 @@ Error ELFSectionWriter<ELFT>::visit(const DecompressedSection &Sec) { ? (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; + ArrayRef<uint8_t> CompressedContent(Sec.OriginalData.data() + DataOffset, + Sec.OriginalData.size() - DataOffset); + SmallVector<uint8_t, 128> DecompressedContent; if (Error Err = compression::zlib::uncompress(CompressedContent, DecompressedContent, static_cast<size_t>(Sec.Size))) @@ -545,10 +543,7 @@ CompressedSection::CompressedSection(const SectionBase &Sec, DebugCompressionType CompressionType) : SectionBase(Sec), CompressionType(CompressionType), DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) { - compression::zlib::compress( - StringRef(reinterpret_cast<const char *>(OriginalData.data()), - OriginalData.size()), - CompressedData); + compression::zlib::compress(OriginalData, CompressedData); assert(CompressionType != DebugCompressionType::None); Flags |= ELF::SHF_COMPRESSED; diff --git a/llvm/lib/ObjCopy/ELF/ELFObject.h b/llvm/lib/ObjCopy/ELF/ELFObject.h index f33bbb029c9b..799db5034532 100644 --- a/llvm/lib/ObjCopy/ELF/ELFObject.h +++ b/llvm/lib/ObjCopy/ELF/ELFObject.h @@ -539,7 +539,7 @@ class CompressedSection : public SectionBase { DebugCompressionType CompressionType; uint64_t DecompressedSize; uint64_t DecompressedAlign; - SmallVector<char, 128> CompressedData; + SmallVector<uint8_t, 128> CompressedData; public: CompressedSection(const SectionBase &Sec, diff --git a/llvm/lib/Object/Decompressor.cpp b/llvm/lib/Object/Decompressor.cpp index 787ca7a30321..a6a28a0589ac 100644 --- a/llvm/lib/Object/Decompressor.cpp +++ b/llvm/lib/Object/Decompressor.cpp @@ -92,7 +92,8 @@ bool Decompressor::isCompressedELFSection(uint64_t Flags, StringRef Name) { return (Flags & ELF::SHF_COMPRESSED) || isGnuStyle(Name); } -Error Decompressor::decompress(MutableArrayRef<char> Buffer) { +Error Decompressor::decompress(MutableArrayRef<uint8_t> Buffer) { size_t Size = Buffer.size(); - return compression::zlib::uncompress(SectionData, Buffer.data(), Size); + return compression::zlib::uncompress(arrayRefFromStringRef(SectionData), + Buffer.data(), Size); } diff --git a/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp b/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp index d34f25703ec5..552140a52ad4 100644 --- a/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp +++ b/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp @@ -124,21 +124,21 @@ Error RawCoverageFilenamesReader::read(CovMapVersion Version) { coveragemap_error::decompression_failed); // Allocate memory for the decompressed filenames. - SmallVector<char, 0> StorageBuf; + SmallVector<uint8_t, 0> StorageBuf; // Read compressed filenames. StringRef CompressedFilenames = Data.substr(0, CompressedLen); Data = Data.substr(CompressedLen); - auto Err = compression::zlib::uncompress(CompressedFilenames, StorageBuf, - UncompressedLen); + auto Err = compression::zlib::uncompress( + arrayRefFromStringRef(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, + RawCoverageFilenamesReader Delegate(toStringRef(StorageBuf), Filenames, CompilationDir); return Delegate.readUncompressed(Version, NumFilenames); } diff --git a/llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp b/llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp index 19b5bce785a4..db9be34d5248 100644 --- a/llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp +++ b/llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp @@ -46,11 +46,12 @@ void CoverageFilenamesSectionWriter::write(raw_ostream &OS, bool Compress) { } } - SmallString<128> CompressedStr; + SmallVector<uint8_t, 128> CompressedStr; bool doCompression = Compress && compression::zlib::isAvailable() && DoInstrProfNameCompression; if (doCompression) - compression::zlib::compress(FilenamesStr, CompressedStr, + compression::zlib::compress(arrayRefFromStringRef(FilenamesStr), + CompressedStr, compression::zlib::BestSizeCompression); // ::= <num-filenames> @@ -60,7 +61,7 @@ void CoverageFilenamesSectionWriter::write(raw_ostream &OS, bool Compress) { encodeULEB128(Filenames.size(), OS); encodeULEB128(FilenamesStr.size(), OS); encodeULEB128(doCompression ? CompressedStr.size() : 0U, OS); - OS << (doCompression ? CompressedStr.str() : StringRef(FilenamesStr)); + OS << (doCompression ? toStringRef(CompressedStr) : StringRef(FilenamesStr)); } namespace { diff --git a/llvm/lib/ProfileData/InstrProf.cpp b/llvm/lib/ProfileData/InstrProf.cpp index 370da8a0f5b1..f8d7c4d36481 100644 --- a/llvm/lib/ProfileData/InstrProf.cpp +++ b/llvm/lib/ProfileData/InstrProf.cpp @@ -464,13 +464,13 @@ Error collectPGOFuncNameStrings(ArrayRef<std::string> NameStrs, return WriteStringToResult(0, UncompressedNameStrings); } - SmallString<128> CompressedNameStrings; - compression::zlib::compress(StringRef(UncompressedNameStrings), + SmallVector<uint8_t, 128> CompressedNameStrings; + compression::zlib::compress(arrayRefFromStringRef(UncompressedNameStrings), CompressedNameStrings, compression::zlib::BestSizeCompression); return WriteStringToResult(CompressedNameStrings.size(), - CompressedNameStrings); + toStringRef(CompressedNameStrings)); } StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar) { @@ -500,23 +500,20 @@ Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab) { uint64_t CompressedSize = decodeULEB128(P, &N); P += N; bool isCompressed = (CompressedSize != 0); - SmallString<128> UncompressedNameStrings; + SmallVector<uint8_t, 128> UncompressedNameStrings; StringRef NameStrings; if (isCompressed) { if (!llvm::compression::zlib::isAvailable()) return make_error<InstrProfError>(instrprof_error::zlib_unavailable); - StringRef CompressedNameStrings(reinterpret_cast<const char *>(P), - CompressedSize); - if (Error E = compression::zlib::uncompress(CompressedNameStrings, - UncompressedNameStrings, - UncompressedSize)) { + if (Error E = compression::zlib::uncompress( + makeArrayRef(P, CompressedSize), UncompressedNameStrings, + UncompressedSize)) { consumeError(std::move(E)); return make_error<InstrProfError>(instrprof_error::uncompress_failed); } P += CompressedSize; - NameStrings = StringRef(UncompressedNameStrings.data(), - UncompressedNameStrings.size()); + NameStrings = toStringRef(UncompressedNameStrings); } else { NameStrings = StringRef(reinterpret_cast<const char *>(P), UncompressedSize); diff --git a/llvm/lib/ProfileData/SampleProfReader.cpp b/llvm/lib/ProfileData/SampleProfReader.cpp index 628d5e45f2d2..204e34bff879 100644 --- a/llvm/lib/ProfileData/SampleProfReader.cpp +++ b/llvm/lib/ProfileData/SampleProfReader.cpp @@ -880,12 +880,10 @@ std::error_code SampleProfileReaderExtBinaryBase::decompressSection( if (!llvm::compression::zlib::isAvailable()) return sampleprof_error::zlib_unavailable; - StringRef CompressedStrings(reinterpret_cast<const char *>(Data), - *CompressSize); - char *Buffer = Allocator.Allocate<char>(DecompressBufSize); + uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize); size_t UCSize = DecompressBufSize; - llvm::Error E = - compression::zlib::uncompress(CompressedStrings, Buffer, UCSize); + llvm::Error E = compression::zlib::uncompress( + makeArrayRef(Data, *CompressSize), Buffer, UCSize); if (E) return sampleprof_error::uncompress_failed; DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer); diff --git a/llvm/lib/ProfileData/SampleProfWriter.cpp b/llvm/lib/ProfileData/SampleProfWriter.cpp index 6db874f803be..093790afe2d6 100644 --- a/llvm/lib/ProfileData/SampleProfWriter.cpp +++ b/llvm/lib/ProfileData/SampleProfWriter.cpp @@ -85,12 +85,13 @@ std::error_code SampleProfileWriterExtBinaryBase::compressAndOutput() { if (UncompressedStrings.size() == 0) return sampleprof_error::success; auto &OS = *OutputStream; - SmallString<128> CompressedStrings; - compression::zlib::compress(UncompressedStrings, CompressedStrings, + SmallVector<uint8_t, 128> CompressedStrings; + compression::zlib::compress(arrayRefFromStringRef(UncompressedStrings), + CompressedStrings, compression::zlib::BestSizeCompression); encodeULEB128(UncompressedStrings.size(), OS); encodeULEB128(CompressedStrings.size(), OS); - OS << CompressedStrings.str(); + OS << toStringRef(CompressedStrings); UncompressedStrings.clear(); return sampleprof_error::success; } diff --git a/llvm/lib/Support/Compression.cpp b/llvm/lib/Support/Compression.cpp index eda67c54d35d..83e310c6710c 100644 --- a/llvm/lib/Support/Compression.cpp +++ b/llvm/lib/Support/Compression.cpp @@ -44,13 +44,12 @@ static StringRef convertZlibCodeToString(int Code) { bool zlib::isAvailable() { return true; } -void zlib::compress(StringRef InputBuffer, - SmallVectorImpl<char> &CompressedBuffer, int Level) { - unsigned long CompressedSize = ::compressBound(InputBuffer.size()); +void zlib::compress(ArrayRef<uint8_t> Input, + SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) { + unsigned long CompressedSize = ::compressBound(Input.size()); CompressedBuffer.resize_for_overwrite(CompressedSize); - int Res = - ::compress2((Bytef *)CompressedBuffer.data(), &CompressedSize, - (const Bytef *)InputBuffer.data(), InputBuffer.size(), Level); + 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); @@ -61,11 +60,11 @@ void zlib::compress(StringRef InputBuffer, CompressedBuffer.truncate(CompressedSize); } -Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer, +Error zlib::uncompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer, size_t &UncompressedSize) { int Res = ::uncompress((Bytef *)UncompressedBuffer, (uLongf *)&UncompressedSize, - (const Bytef *)InputBuffer.data(), InputBuffer.size()); + (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); @@ -74,12 +73,12 @@ Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer, : Error::success(); } -Error zlib::uncompress(StringRef InputBuffer, - SmallVectorImpl<char> &UncompressedBuffer, +Error zlib::uncompress(ArrayRef<uint8_t> Input, + SmallVectorImpl<uint8_t> &UncompressedBuffer, size_t UncompressedSize) { UncompressedBuffer.resize_for_overwrite(UncompressedSize); - Error E = zlib::uncompress(InputBuffer, UncompressedBuffer.data(), - UncompressedSize); + Error E = + zlib::uncompress(Input, UncompressedBuffer.data(), UncompressedSize); if (UncompressedSize < UncompressedBuffer.size()) UncompressedBuffer.truncate(UncompressedSize); return E; diff --git a/llvm/unittests/Support/CompressionTest.cpp b/llvm/unittests/Support/CompressionTest.cpp index ee0f58b0f492..8e6189ebe224 100644 --- a/llvm/unittests/Support/CompressionTest.cpp +++ b/llvm/unittests/Support/CompressionTest.cpp @@ -24,15 +24,15 @@ namespace { #if LLVM_ENABLE_ZLIB static void testZlibCompression(StringRef Input, int Level) { - SmallString<32> Compressed; - SmallString<32> Uncompressed; - zlib::compress(Input, Compressed, Level); + SmallVector<uint8_t, 0> Compressed; + SmallVector<uint8_t, 0> Uncompressed; + zlib::compress(arrayRefFromStringRef(Input), Compressed, Level); // Check that uncompressed buffer is the same as original. Error E = zlib::uncompress(Compressed, Uncompressed, Input.size()); consumeError(std::move(E)); - EXPECT_EQ(Input, Uncompressed); + 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); _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits