//===- lib/Support/Compressor.cpp -------------------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the llvm::Compressor class, an abstraction for memory
enum CompressionTypes {
COMP_TYPE_NONE = '0',
- COMP_TYPE_BZIP2 = '2',
+ COMP_TYPE_BZIP2 = '2'
};
-static int getdata(char*& buffer, size_t &size,
+static int getdata(char*& buffer, size_t &size,
llvm::Compressor::OutputDataCallback* cb, void* context) {
buffer = 0;
size = 0;
return result;
}
-static int getdata(char*& buffer, unsigned &size,
- llvm::Compressor::OutputDataCallback* cb, void* context) {
+static int getdata_uns(char*& buffer, unsigned &size,
+ llvm::Compressor::OutputDataCallback* cb, void* context)
+{
size_t SizeOut;
int Res = getdata(buffer, SizeOut, cb, context);
size = SizeOut;
}
//===----------------------------------------------------------------------===//
-//=== NULLCOMP - a compression like set of routines that just copies data
+//=== NULLCOMP - a compression like set of routines that just copies data
//=== without doing any compression. This is provided so that if the
//=== configured environment doesn't have a compression library the
//=== program can still work, albeit using more data/memory.
/// This structure is only used when a bytecode file is compressed.
/// As bytecode is being decompressed, the memory buffer might need
-/// to be reallocated. The buffer allocation is handled in a callback
+/// to be reallocated. The buffer allocation is handled in a callback
/// and this structure is needed to retain information across calls
/// to the callback.
/// @brief An internal buffer object used for handling decompression
struct BufferContext {
char* buff;
size_t size;
- BufferContext(size_t compressedSize) {
+ BufferContext(size_t compressedSize) {
// Null to indicate malloc of a new block
- buff = 0;
+ buff = 0;
// Compute the initial length of the uncompression buffer. Note that this
// is twice the length of the compressed buffer and will be doubled again
- // in the callback for an initial allocation of 4x compressedSize. This
- // calculation is based on the typical compression ratio of bzip2 on LLVM
- // bytecode files which typically ranges in the 50%-75% range. Since we
- // typically get at least 50%, doubling is insufficient. By using a 4x
+ // in the callback for an initial allocation of 4x compressedSize. This
+ // calculation is based on the typical compression ratio of bzip2 on LLVM
+ // bytecode files which typically ranges in the 50%-75% range. Since we
+ // typically get at least 50%, doubling is insufficient. By using a 4x
// multiplier on the first allocation, we minimize the impact of having to
// copy the buffer on reallocation.
- size = compressedSize*2;
+ size = compressedSize*2;
}
/// trimTo - Reduce the size of the buffer down to the specified amount. This
/// This function handles allocation of the buffer used for decompression of
/// compressed bytecode files. It is called by Compressor::decompress which is
- /// called by BytecodeReader::ParseBytecode.
+ /// called by BytecodeReader::ParseBytecode.
static size_t callback(char*&buff, size_t &sz, void* ctxt){
// Case the context variable to our BufferContext
BufferContext* bc = reinterpret_cast<BufferContext*>(ctxt);
// Figure out what to return to the Compressor. If this is the first call,
// then bc->buff will be null. In this case we want to return the entire
// buffer because there was no previous allocation. Otherwise, when the
- // buffer is reallocated, we save the new base pointer in the
- // BufferContext.buff field but return the address of only the extension,
- // mid-way through the buffer (since its size was doubled). Furthermore,
+ // buffer is reallocated, we save the new base pointer in the
+ // BufferContext.buff field but return the address of only the extension,
+ // mid-way through the buffer (since its size was doubled). Furthermore,
// the sz result must be 1/2 the total size of the buffer.
if (bc->buff == 0 ) {
buff = bc->buff = new_buff;
}
};
-} // end anonymous namespace
+} // end anonymous namespace
namespace {
// This structure retains the context when compressing the bytecode file. The
// WriteCompressedData function below uses it to keep track of the previously
-// filled chunk of memory (which it writes) and how many bytes have been
+// filled chunk of memory (which it writes) and how many bytes have been
// written.
struct WriterContext {
// Initialize the context
- WriterContext(std::ostream*OS, size_t CS)
+ WriterContext(std::ostream*OS, size_t CS)
: chunk(0), sz(0), written(0), compSize(CS), Out(OS) {}
// Make sure we clean up memory
sz = 0;
}
- // This function is a callback used by the Compressor::compress function to
+ // This function is a callback used by the Compressor::compress function to
// allocate memory for the compression buffer. This function fulfills that
// responsibility but also writes the previous (now filled) buffer out to the
- // stream.
+ // stream.
static size_t callback(char*& buffer, size_t &size, void* context) {
// Cast the context to the structure it must point to.
WriterContext* ctxt = reinterpret_cast<WriterContext*>(context);
} // end anonymous namespace
// Compress in one of three ways
-size_t Compressor::compress(const char* in, size_t size,
- OutputDataCallback* cb, void* context) {
+size_t Compressor::compress(const char* in, size_t size,
+ OutputDataCallback* cb, void* context,
+ std::string* error ) {
assert(in && "Can't compress null buffer");
assert(size && "Can't compress empty buffer");
assert(cb && "Can't compress without a callback function");
bzdata.next_out = 0;
bzdata.avail_out = 0;
switch ( BZ2_bzCompressInit(&bzdata, 5, 0, 100) ) {
- case BZ_CONFIG_ERROR: throw std::string("bzip2 library mis-compiled");
- case BZ_PARAM_ERROR: throw std::string("Compressor internal error");
- case BZ_MEM_ERROR: throw std::string("Out of memory");
+ case BZ_CONFIG_ERROR:
+ if (error)
+ *error = "bzip2 library mis-compiled";
+ return result;
+ case BZ_PARAM_ERROR:
+ if (error)
+ *error = "Compressor internal error";
+ return result;
+ case BZ_MEM_ERROR:
+ if (error)
+ *error = "Out of memory";
+ return result;
case BZ_OK:
default:
break;
}
// Get a block of memory
- if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb,context)) {
+ if (0 != getdata_uns(bzdata.next_out, bzdata.avail_out,cb,context)) {
BZ2_bzCompressEnd(&bzdata);
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
// Put compression code in first byte
// Compress it
int bzerr = BZ_FINISH_OK;
while (BZ_FINISH_OK == (bzerr = BZ2_bzCompress(&bzdata, BZ_FINISH))) {
- if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb,context)) {
+ if (0 != getdata_uns(bzdata.next_out, bzdata.avail_out,cb,context)) {
BZ2_bzCompressEnd(&bzdata);
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
}
switch (bzerr) {
case BZ_SEQUENCE_ERROR:
- case BZ_PARAM_ERROR: throw std::string("Param/Sequence error");
+ case BZ_PARAM_ERROR:
+ if (error)
+ *error = "Param/Sequence error";
+ return result;
case BZ_FINISH_OK:
case BZ_STREAM_END: break;
- default: throw std::string("Oops: ") + utostr(unsigned(bzerr));
+ default:
+ if (error)
+ *error = "BZip2 Error: " + utostr(unsigned(bzerr));
+ return result;
}
// Finish
NULLCOMP_init(&sdata);
if (0 != getdata(sdata.next_out, sdata.avail_out,cb,context)) {
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
*(sdata.next_out++) = COMP_TYPE_NONE;
while (!NULLCOMP_compress(&sdata)) {
if (0 != getdata(sdata.next_out, sdata.avail_out,cb,context)) {
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
}
return result;
}
-size_t Compressor::compressToNewBuffer(const char* in, size_t size, char*&out) {
+size_t Compressor::compressToNewBuffer(const char* in, size_t size, char*&out,
+ std::string* error) {
BufferContext bc(size);
- size_t result = compress(in,size,BufferContext::callback,(void*)&bc);
+ size_t result = compress(in,size,BufferContext::callback,(void*)&bc,error);
bc.trimTo(result);
out = bc.buff;
return result;
}
-size_t
-Compressor::compressToStream(const char*in, size_t size, std::ostream& out) {
+size_t
+Compressor::compressToStream(const char*in, size_t size, std::ostream& out,
+ std::string* error) {
// Set up the context and writer
WriterContext ctxt(&out, size / 2);
// Compress everything after the magic number (which we'll alter).
size_t zipSize = Compressor::compress(in,size,
- WriterContext::callback, (void*)&ctxt);
+ WriterContext::callback, (void*)&ctxt,error);
- if (ctxt.chunk) {
+ if (zipSize && ctxt.chunk) {
ctxt.write(zipSize - ctxt.written);
}
return zipSize;
// Decompress in one of three ways
size_t Compressor::decompress(const char *in, size_t size,
- OutputDataCallback* cb, void* context) {
+ OutputDataCallback* cb, void* context,
+ std::string* error) {
assert(in && "Can't decompress null buffer");
assert(size > 1 && "Can't decompress empty buffer");
assert(cb && "Can't decompress without a callback function");
bzdata.next_out = 0;
bzdata.avail_out = 0;
switch ( BZ2_bzDecompressInit(&bzdata, 0, 0) ) {
- case BZ_CONFIG_ERROR: throw std::string("bzip2 library mis-compiled");
- case BZ_PARAM_ERROR: throw std::string("Compressor internal error");
- case BZ_MEM_ERROR: throw std::string("Out of memory");
+ case BZ_CONFIG_ERROR:
+ if (error)
+ *error = "bzip2 library mis-compiled";
+ return result;
+ case BZ_PARAM_ERROR:
+ if (error)
+ *error = "Compressor internal error";
+ return result;
+ case BZ_MEM_ERROR:
+ if (error)
+ *error = "Out of memory";
+ return result;
case BZ_OK:
default:
break;
}
// Get a block of memory
- if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb,context)) {
+ if (0 != getdata_uns(bzdata.next_out, bzdata.avail_out,cb,context)) {
BZ2_bzDecompressEnd(&bzdata);
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
// Decompress it
int bzerr = BZ_OK;
- while (BZ_OK == (bzerr = BZ2_bzDecompress(&bzdata))) {
- if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb,context)) {
+ while ( BZ_OK == (bzerr = BZ2_bzDecompress(&bzdata)) &&
+ bzdata.avail_in != 0 ) {
+ if (0 != getdata_uns(bzdata.next_out, bzdata.avail_out,cb,context)) {
BZ2_bzDecompressEnd(&bzdata);
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
}
switch (bzerr) {
- case BZ_PARAM_ERROR: throw std::string("Compressor internal error");
- case BZ_MEM_ERROR: throw std::string("Out of memory");
- case BZ_DATA_ERROR: throw std::string("Data integrity error");
- case BZ_DATA_ERROR_MAGIC:throw std::string("Data is not BZIP2");
- default: throw("Ooops");
- case BZ_STREAM_END:
- break;
+ BZ2_bzDecompressEnd(&bzdata);
+ case BZ_PARAM_ERROR:
+ if (error)
+ *error = "Compressor internal error";
+ return result;
+ case BZ_MEM_ERROR:
+ BZ2_bzDecompressEnd(&bzdata);
+ if (error)
+ *error = "Out of memory";
+ return result;
+ case BZ_DATA_ERROR:
+ BZ2_bzDecompressEnd(&bzdata);
+ if (error)
+ *error = "Data integrity error";
+ return result;
+ case BZ_DATA_ERROR_MAGIC:
+ BZ2_bzDecompressEnd(&bzdata);
+ if (error)
+ *error = "Data is not BZIP2";
+ return result;
+ case BZ_OK:
+ BZ2_bzDecompressEnd(&bzdata);
+ if (error)
+ *error = "Insufficient input for bzip2";
+ return result;
+ case BZ_STREAM_END: break;
+ default:
+ BZ2_bzDecompressEnd(&bzdata);
+ if (error)
+ *error = "Unknown result code from bzDecompress";
+ return result;
}
// Finish
NULLCOMP_init(&sdata);
if (0 != getdata(sdata.next_out, sdata.avail_out,cb,context)) {
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
while (!NULLCOMP_decompress(&sdata)) {
if (0 != getdata(sdata.next_out, sdata.avail_out,cb,context)) {
- throw std::string("Can't allocate output buffer");
+ if (error)
+ *error = "Can't allocate output buffer";
+ return result;
}
}
}
default:
- throw std::string("Unknown type of compressed data");
+ if (error)
+ *error = "Unknown type of compressed data";
+ return result;
}
return result;
}
-size_t
-Compressor::decompressToNewBuffer(const char* in, size_t size, char*&out) {
+size_t
+Compressor::decompressToNewBuffer(const char* in, size_t size, char*&out,
+ std::string* error) {
BufferContext bc(size);
- size_t result = decompress(in,size,BufferContext::callback,(void*)&bc);
+ size_t result = decompress(in,size,BufferContext::callback,(void*)&bc,error);
out = bc.buff;
return result;
}
-size_t
-Compressor::decompressToStream(const char*in, size_t size, std::ostream& out){
+size_t
+Compressor::decompressToStream(const char*in, size_t size, std::ostream& out,
+ std::string* error) {
// Set up the context and writer
WriterContext ctxt(&out,size / 2);
- // Compress everything after the magic number (which we'll alter)
+ // Decompress everything after the magic number (which we'll alter)
size_t zipSize = Compressor::decompress(in,size,
- WriterContext::callback, (void*)&ctxt);
+ WriterContext::callback, (void*)&ctxt,error);
- if (ctxt.chunk) {
+ if (zipSize && ctxt.chunk) {
ctxt.write(zipSize - ctxt.written);
}
return zipSize;
}
-
-// vim: sw=2 ai
projects / oota-llvm.git / blobdiff