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
13 #include "llvm/Support/Compression.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Config/config.h"
17 #include "llvm/Support/Compiler.h"
18 #include "llvm/Support/Error.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #if LLVM_ENABLE_ZLIB
21 #include <zlib.h>
22 #endif
23 #if LLVM_ENABLE_ZSTD
24 #include <zstd.h>
25 #endif
26
27 using namespace llvm;
28 using namespace llvm::compression;
29
getReasonIfUnsupported(compression::Format F)30 const char *compression::getReasonIfUnsupported(compression::Format F) {
31 switch (F) {
32 case compression::Format::Zlib:
33 if (zlib::isAvailable())
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:
38 if (zstd::isAvailable())
39 return nullptr;
40 return "LLVM was not built with LLVM_ENABLE_ZSTD or did not find zstd at "
41 "build time";
42 }
43 llvm_unreachable("");
44 }
45
compress(Params P,ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output)46 void compression::compress(Params P, ArrayRef<uint8_t> Input,
47 SmallVectorImpl<uint8_t> &Output) {
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, P.zstdEnableLdm);
54 break;
55 }
56 }
57
decompress(DebugCompressionType T,ArrayRef<uint8_t> Input,uint8_t * Output,size_t UncompressedSize)58 Error compression::decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
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 }
66 llvm_unreachable("");
67 }
68
decompress(compression::Format F,ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output,size_t UncompressedSize)69 Error compression::decompress(compression::Format F, ArrayRef<uint8_t> Input,
70 SmallVectorImpl<uint8_t> &Output,
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 }
78 llvm_unreachable("");
79 }
80
decompress(DebugCompressionType T,ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output,size_t UncompressedSize)81 Error compression::decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
82 SmallVectorImpl<uint8_t> &Output,
83 size_t UncompressedSize) {
84 return decompress(formatFor(T), Input, Output, UncompressedSize);
85 }
86
87 #if LLVM_ENABLE_ZLIB
88
convertZlibCodeToString(int Code)89 static 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
isAvailable()105 bool zlib::isAvailable() { return true; }
106
compress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & CompressedBuffer,int Level)107 void zlib::compress(ArrayRef<uint8_t> Input,
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
decompress(ArrayRef<uint8_t> Input,uint8_t * Output,size_t & UncompressedSize)123 Error 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),
131 inconvertibleErrorCode())
132 : Error::success();
133 }
134
decompress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output,size_t UncompressedSize)135 Error zlib::decompress(ArrayRef<uint8_t> Input,
136 SmallVectorImpl<uint8_t> &Output,
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
isAvailable()146 bool zlib::isAvailable() { return false; }
compress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & CompressedBuffer,int Level)147 void zlib::compress(ArrayRef<uint8_t> Input,
148 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level) {
149 llvm_unreachable("zlib::compress is unavailable");
150 }
decompress(ArrayRef<uint8_t> Input,uint8_t * UncompressedBuffer,size_t & UncompressedSize)151 Error zlib::decompress(ArrayRef<uint8_t> Input, uint8_t *UncompressedBuffer,
152 size_t &UncompressedSize) {
153 llvm_unreachable("zlib::decompress is unavailable");
154 }
decompress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & UncompressedBuffer,size_t UncompressedSize)155 Error zlib::decompress(ArrayRef<uint8_t> Input,
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
isAvailable()164 bool zstd::isAvailable() { return true; }
165
166 #include <zstd.h> // Ensure ZSTD library is included
167
compress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & CompressedBuffer,int Level,bool EnableLdm)168 void zstd::compress(ArrayRef<uint8_t> Input,
169 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level,
170 bool EnableLdm) {
171 ZSTD_CCtx *Cctx = ZSTD_createCCtx();
172 if (!Cctx)
173 report_bad_alloc_error("Failed to create ZSTD_CCtx");
174
175 if (ZSTD_isError(ZSTD_CCtx_setParameter(
176 Cctx, ZSTD_c_enableLongDistanceMatching, EnableLdm ? 1 : 0))) {
177 ZSTD_freeCCtx(Cctx);
178 report_bad_alloc_error("Failed to set ZSTD_c_enableLongDistanceMatching");
179 }
180
181 if (ZSTD_isError(
182 ZSTD_CCtx_setParameter(Cctx, ZSTD_c_compressionLevel, Level))) {
183 ZSTD_freeCCtx(Cctx);
184 report_bad_alloc_error("Failed to set ZSTD_c_compressionLevel");
185 }
186
187 unsigned long CompressedBufferSize = ZSTD_compressBound(Input.size());
188 CompressedBuffer.resize_for_overwrite(CompressedBufferSize);
189
190 size_t const CompressedSize =
191 ZSTD_compress2(Cctx, CompressedBuffer.data(), CompressedBufferSize,
192 Input.data(), Input.size());
193
194 ZSTD_freeCCtx(Cctx);
195
196 if (ZSTD_isError(CompressedSize))
197 report_bad_alloc_error("Compression failed");
198
199 __msan_unpoison(CompressedBuffer.data(), CompressedSize);
200 if (CompressedSize < CompressedBuffer.size())
201 CompressedBuffer.truncate(CompressedSize);
202 }
203
decompress(ArrayRef<uint8_t> Input,uint8_t * Output,size_t & UncompressedSize)204 Error zstd::decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
205 size_t &UncompressedSize) {
206 const size_t Res = ::ZSTD_decompress(
207 Output, UncompressedSize, (const uint8_t *)Input.data(), Input.size());
208 UncompressedSize = Res;
209 // Tell MemorySanitizer that zstd output buffer is fully initialized.
210 // This avoids a false report when running LLVM with uninstrumented ZLib.
211 __msan_unpoison(Output, UncompressedSize);
212 return ZSTD_isError(Res) ? make_error<StringError>(ZSTD_getErrorName(Res),
213 inconvertibleErrorCode())
214 : Error::success();
215 }
216
decompress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output,size_t UncompressedSize)217 Error zstd::decompress(ArrayRef<uint8_t> Input,
218 SmallVectorImpl<uint8_t> &Output,
219 size_t UncompressedSize) {
220 Output.resize_for_overwrite(UncompressedSize);
221 Error E = zstd::decompress(Input, Output.data(), UncompressedSize);
222 if (UncompressedSize < Output.size())
223 Output.truncate(UncompressedSize);
224 return E;
225 }
226
227 #else
isAvailable()228 bool zstd::isAvailable() { return false; }
compress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & CompressedBuffer,int Level,bool EnableLdm)229 void zstd::compress(ArrayRef<uint8_t> Input,
230 SmallVectorImpl<uint8_t> &CompressedBuffer, int Level,
231 bool EnableLdm) {
232 llvm_unreachable("zstd::compress is unavailable");
233 }
decompress(ArrayRef<uint8_t> Input,uint8_t * Output,size_t & UncompressedSize)234 Error zstd::decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
235 size_t &UncompressedSize) {
236 llvm_unreachable("zstd::decompress is unavailable");
237 }
decompress(ArrayRef<uint8_t> Input,SmallVectorImpl<uint8_t> & Output,size_t UncompressedSize)238 Error zstd::decompress(ArrayRef<uint8_t> Input,
239 SmallVectorImpl<uint8_t> &Output,
240 size_t UncompressedSize) {
241 llvm_unreachable("zstd::decompress is unavailable");
242 }
243 #endif
244