[clang-tools-extra] e690137 - [Support] Change compression::zlib::{compress,uncompress} to use uint8_t *
Fangrui Song via cfe-commits
cfe-commits at lists.llvm.org
Wed Jul 13 16:27:00 PDT 2022
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);
More information about the cfe-commits
mailing list