LLVM 19.0.0git
Compression.cpp
Go to the documentation of this file.
1//===--- Compression.cpp - Compression implementation ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements compression functions.
10//
11//===----------------------------------------------------------------------===//
12
15#include "llvm/ADT/StringRef.h"
16#include "llvm/Config/config.h"
18#include "llvm/Support/Error.h"
20#if LLVM_ENABLE_ZLIB
21#include <zlib.h>
22#endif
23#if LLVM_ENABLE_ZSTD
24#include <zstd.h>
25#endif
26
27using namespace llvm;
28using namespace llvm::compression;
29
31 switch (F) {
32 case compression::Format::Zlib:
34 return nullptr;
35 return "LLVM was not built with LLVM_ENABLE_ZLIB or did not find zlib at "
36 "build time";
37 case compression::Format::Zstd:
39 return nullptr;
40 return "LLVM was not built with LLVM_ENABLE_ZSTD or did not find zstd at "
41 "build time";
42 }
44}
45
48 switch (P.format) {
49 case compression::Format::Zlib:
50 zlib::compress(Input, Output, P.level);
51 break;
52 case compression::Format::Zstd:
53 zstd::compress(Input, Output, P.level);
54 break;
55 }
56}
57
59 uint8_t *Output, size_t UncompressedSize) {
60 switch (formatFor(T)) {
61 case compression::Format::Zlib:
62 return zlib::decompress(Input, Output, UncompressedSize);
63 case compression::Format::Zstd:
64 return zstd::decompress(Input, Output, UncompressedSize);
65 }
67}
68
71 size_t UncompressedSize) {
72 switch (F) {
73 case compression::Format::Zlib:
74 return zlib::decompress(Input, Output, UncompressedSize);
75 case compression::Format::Zstd:
76 return zstd::decompress(Input, Output, UncompressedSize);
77 }
79}
80
83 size_t UncompressedSize) {
84 return decompress(formatFor(T), Input, Output, UncompressedSize);
85}
86
87#if LLVM_ENABLE_ZLIB
88
89static StringRef convertZlibCodeToString(int Code) {
90 switch (Code) {
91 case Z_MEM_ERROR:
92 return "zlib error: Z_MEM_ERROR";
93 case Z_BUF_ERROR:
94 return "zlib error: Z_BUF_ERROR";
95 case Z_STREAM_ERROR:
96 return "zlib error: Z_STREAM_ERROR";
97 case Z_DATA_ERROR:
98 return "zlib error: Z_DATA_ERROR";
99 case Z_OK:
100 default:
101 llvm_unreachable("unknown or unexpected zlib status code");
102 }
103}
104
105bool zlib::isAvailable() { return true; }
106
108 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
109 unsigned long CompressedSize = ::compressBound(Input.size());
110 CompressedBuffer.resize_for_overwrite(CompressedSize);
111 int Res = ::compress2((Bytef *)CompressedBuffer.data(), &CompressedSize,
112 (const Bytef *)Input.data(), Input.size(), Level);
113 if (Res == Z_MEM_ERROR)
114 report_bad_alloc_error("Allocation failed");
115 assert(Res == Z_OK);
116 // Tell MemorySanitizer that zlib output buffer is fully initialized.
117 // This avoids a false report when running LLVM with uninstrumented ZLib.
118 __msan_unpoison(CompressedBuffer.data(), CompressedSize);
119 if (CompressedSize < CompressedBuffer.size())
120 CompressedBuffer.truncate(CompressedSize);
121}
122
123Error zlib::decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
124 size_t &UncompressedSize) {
125 int Res = ::uncompress((Bytef *)Output, (uLongf *)&UncompressedSize,
126 (const Bytef *)Input.data(), Input.size());
127 // Tell MemorySanitizer that zlib output buffer is fully initialized.
128 // This avoids a false report when running LLVM with uninstrumented ZLib.
129 __msan_unpoison(Output, UncompressedSize);
130 return Res ? make_error<StringError>(convertZlibCodeToString(Res),
132 : Error::success();
133}
134
137 size_t UncompressedSize) {
138 Output.resize_for_overwrite(UncompressedSize);
139 Error E = zlib::decompress(Input, Output.data(), UncompressedSize);
140 if (UncompressedSize < Output.size())
141 Output.truncate(UncompressedSize);
142 return E;
143}
144
145#else
146bool zlib::isAvailable() { return false; }
148 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
149 llvm_unreachable("zlib::compress is unavailable");
150}
151Error zlib::decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
152 size_t &UncompressedSize) {
153 llvm_unreachable("zlib::decompress is unavailable");
154}
156 SmallVectorImpl<uint8_t> &UncompressedBuffer,
157 size_t UncompressedSize) {
158 llvm_unreachable("zlib::decompress is unavailable");
159}
160#endif
161
162#if LLVM_ENABLE_ZSTD
163
164bool zstd::isAvailable() { return true; }
165
167 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
168 unsigned long CompressedBufferSize = ::ZSTD_compressBound(Input.size());
169 CompressedBuffer.resize_for_overwrite(CompressedBufferSize);
170 unsigned long CompressedSize =
171 ::ZSTD_compress((char *)CompressedBuffer.data(), CompressedBufferSize,
172 (const char *)Input.data(), Input.size(), Level);
173 if (ZSTD_isError(CompressedSize))
174 report_bad_alloc_error("Allocation failed");
175 // Tell MemorySanitizer that zstd output buffer is fully initialized.
176 // This avoids a false report when running LLVM with uninstrumented ZLib.
177 __msan_unpoison(CompressedBuffer.data(), CompressedSize);
178 if (CompressedSize < CompressedBuffer.size())
179 CompressedBuffer.truncate(CompressedSize);
180}
181
182Error zstd::decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
183 size_t &UncompressedSize) {
184 const size_t Res = ::ZSTD_decompress(
185 Output, UncompressedSize, (const uint8_t *)Input.data(), Input.size());
186 UncompressedSize = Res;
187 // Tell MemorySanitizer that zstd output buffer is fully initialized.
188 // This avoids a false report when running LLVM with uninstrumented ZLib.
189 __msan_unpoison(Output, UncompressedSize);
190 return ZSTD_isError(Res) ? make_error<StringError>(ZSTD_getErrorName(Res),
192 : Error::success();
193}
194
197 size_t UncompressedSize) {
198 Output.resize_for_overwrite(UncompressedSize);
199 Error E = zstd::decompress(Input, Output.data(), UncompressedSize);
200 if (UncompressedSize < Output.size())
201 Output.truncate(UncompressedSize);
202 return E;
203}
204
205#else
206bool zstd::isAvailable() { return false; }
208 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
209 llvm_unreachable("zstd::compress is unavailable");
210}
212 size_t &UncompressedSize) {
213 llvm_unreachable("zstd::decompress is unavailable");
214}
217 size_t UncompressedSize) {
218 llvm_unreachable("zstd::decompress is unavailable");
219}
220#endif
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define __msan_unpoison(p, size)
Definition: Compiler.h:435
#define F(x, y, z)
Definition: MD5.cpp:55
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void resize_for_overwrite(size_type N)
Like resize, but T is POD, the new values won't be initialized.
Definition: SmallVector.h:654
void truncate(size_type N)
Like resize, but requires that N is less than size().
Definition: SmallVector.h:657
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:299
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void compress(ArrayRef< uint8_t > Input, SmallVectorImpl< uint8_t > &CompressedBuffer, int Level=DefaultCompression)
Error decompress(ArrayRef< uint8_t > Input, uint8_t *Output, size_t &UncompressedSize)
void compress(ArrayRef< uint8_t > Input, SmallVectorImpl< uint8_t > &CompressedBuffer, int Level=DefaultCompression)
Error decompress(ArrayRef< uint8_t > Input, uint8_t *Output, size_t &UncompressedSize)
const char * getReasonIfUnsupported(Format F)
Definition: Compression.cpp:30
Error decompress(DebugCompressionType T, ArrayRef< uint8_t > Input, uint8_t *Output, size_t UncompressedSize)
Definition: Compression.cpp:58
Format formatFor(DebugCompressionType Type)
Definition: Compression.h:81
void compress(Params P, ArrayRef< uint8_t > Input, SmallVectorImpl< uint8_t > &Output)
Definition: Compression.cpp:46
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
DebugCompressionType
Definition: Compression.h:27
void report_bad_alloc_error(const char *Reason, bool GenCrashDiag=true)
Reports a bad alloc error, calling any user defined bad alloc error handler.