forked from OSchip/llvm-project
147 lines
4.8 KiB
C++
147 lines
4.8 KiB
C++
//===-- LZMA.cpp ----------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Host/Config.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Error.h"
|
|
|
|
#if LLDB_ENABLE_LZMA
|
|
#include <lzma.h>
|
|
#endif // LLDB_ENABLE_LZMA
|
|
|
|
namespace lldb_private {
|
|
|
|
namespace lzma {
|
|
|
|
#if !LLDB_ENABLE_LZMA
|
|
bool isAvailable() { return false; }
|
|
llvm::Expected<uint64_t>
|
|
getUncompressedSize(llvm::ArrayRef<uint8_t> InputBuffer) {
|
|
llvm_unreachable("lzma::getUncompressedSize is unavailable");
|
|
}
|
|
|
|
llvm::Error uncompress(llvm::ArrayRef<uint8_t> InputBuffer,
|
|
llvm::SmallVectorImpl<uint8_t> &Uncompressed) {
|
|
llvm_unreachable("lzma::uncompress is unavailable");
|
|
}
|
|
|
|
#else // LLDB_ENABLE_LZMA
|
|
|
|
bool isAvailable() { return true; }
|
|
|
|
static const char *convertLZMACodeToString(lzma_ret Code) {
|
|
switch (Code) {
|
|
case LZMA_STREAM_END:
|
|
return "lzma error: LZMA_STREAM_END";
|
|
case LZMA_NO_CHECK:
|
|
return "lzma error: LZMA_NO_CHECK";
|
|
case LZMA_UNSUPPORTED_CHECK:
|
|
return "lzma error: LZMA_UNSUPPORTED_CHECK";
|
|
case LZMA_GET_CHECK:
|
|
return "lzma error: LZMA_GET_CHECK";
|
|
case LZMA_MEM_ERROR:
|
|
return "lzma error: LZMA_MEM_ERROR";
|
|
case LZMA_MEMLIMIT_ERROR:
|
|
return "lzma error: LZMA_MEMLIMIT_ERROR";
|
|
case LZMA_FORMAT_ERROR:
|
|
return "lzma error: LZMA_FORMAT_ERROR";
|
|
case LZMA_OPTIONS_ERROR:
|
|
return "lzma error: LZMA_OPTIONS_ERROR";
|
|
case LZMA_DATA_ERROR:
|
|
return "lzma error: LZMA_DATA_ERROR";
|
|
case LZMA_BUF_ERROR:
|
|
return "lzma error: LZMA_BUF_ERROR";
|
|
case LZMA_PROG_ERROR:
|
|
return "lzma error: LZMA_PROG_ERROR";
|
|
default:
|
|
llvm_unreachable("unknown or unexpected lzma status code");
|
|
}
|
|
}
|
|
|
|
llvm::Expected<uint64_t>
|
|
getUncompressedSize(llvm::ArrayRef<uint8_t> InputBuffer) {
|
|
lzma_stream_flags opts{};
|
|
if (InputBuffer.size() < LZMA_STREAM_HEADER_SIZE) {
|
|
return llvm::createStringError(
|
|
llvm::inconvertibleErrorCode(),
|
|
"size of xz-compressed blob (%lu bytes) is smaller than the "
|
|
"LZMA_STREAM_HEADER_SIZE (%lu bytes)",
|
|
InputBuffer.size(), LZMA_STREAM_HEADER_SIZE);
|
|
}
|
|
|
|
// Decode xz footer.
|
|
lzma_ret xzerr = lzma_stream_footer_decode(
|
|
&opts, InputBuffer.take_back(LZMA_STREAM_HEADER_SIZE).data());
|
|
if (xzerr != LZMA_OK) {
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"lzma_stream_footer_decode()=%s",
|
|
convertLZMACodeToString(xzerr));
|
|
}
|
|
if (InputBuffer.size() < (opts.backward_size + LZMA_STREAM_HEADER_SIZE)) {
|
|
return llvm::createStringError(
|
|
llvm::inconvertibleErrorCode(),
|
|
"xz-compressed buffer size (%lu bytes) too small (required at "
|
|
"least %lu bytes) ",
|
|
InputBuffer.size(), (opts.backward_size + LZMA_STREAM_HEADER_SIZE));
|
|
}
|
|
|
|
// Decode xz index.
|
|
lzma_index *xzindex;
|
|
uint64_t memlimit(UINT64_MAX);
|
|
size_t inpos = 0;
|
|
xzerr = lzma_index_buffer_decode(
|
|
&xzindex, &memlimit, nullptr,
|
|
InputBuffer.take_back(LZMA_STREAM_HEADER_SIZE + opts.backward_size)
|
|
.data(),
|
|
&inpos, InputBuffer.size());
|
|
if (xzerr != LZMA_OK) {
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"lzma_index_buffer_decode()=%s",
|
|
convertLZMACodeToString(xzerr));
|
|
}
|
|
|
|
// Get size of uncompressed file to construct an in-memory buffer of the
|
|
// same size on the calling end (if needed).
|
|
uint64_t uncompressedSize = lzma_index_uncompressed_size(xzindex);
|
|
|
|
// Deallocate xz index as it is no longer needed.
|
|
lzma_index_end(xzindex, nullptr);
|
|
|
|
return uncompressedSize;
|
|
}
|
|
|
|
llvm::Error uncompress(llvm::ArrayRef<uint8_t> InputBuffer,
|
|
llvm::SmallVectorImpl<uint8_t> &Uncompressed) {
|
|
llvm::Expected<uint64_t> uncompressedSize = getUncompressedSize(InputBuffer);
|
|
|
|
if (auto err = uncompressedSize.takeError())
|
|
return err;
|
|
|
|
Uncompressed.resize(*uncompressedSize);
|
|
|
|
// Decompress xz buffer to buffer.
|
|
uint64_t memlimit = UINT64_MAX;
|
|
size_t inpos = 0;
|
|
size_t outpos = 0;
|
|
lzma_ret ret = lzma_stream_buffer_decode(
|
|
&memlimit, 0, nullptr, InputBuffer.data(), &inpos, InputBuffer.size(),
|
|
Uncompressed.data(), &outpos, Uncompressed.size());
|
|
if (ret != LZMA_OK) {
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"lzma_stream_buffer_decode()=%s",
|
|
convertLZMACodeToString(ret));
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
#endif // LLDB_ENABLE_LZMA
|
|
|
|
} // end of namespace lzma
|
|
} // namespace lldb_private
|