First version of a support utility to provide generalized compression in

LLVM that handles availability and unavailability of bzip2 and zlib.

llvm-svn: 16648

llvm/include/llvm/Support/Compressor.h

+//===- llvm/Support/Compressor.h --------------------------------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// 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 declares the llvm::Compressor class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_COMPRESSOR_H
+#define LLVM_SUPPORT_COMPRESSOR_H
+
+#include <llvm/Support/DataTypes.h>
+
+namespace llvm {
+
+  /// This class provides an abstraction for compressing a block of memory using
+  /// a standard compression utility such as bzip2 or libz. This interface
+  /// allos us to abstraction the notion of compression and deal with alternate
+  /// compression scheme availability depending on the configured platform. This
+  /// facility will always favor a bzip2 implementation if its available.
+  /// Otherwise, libz will be used if its available. If neither zlib nor bzip2
+  /// are available, a very simple algorithm provided by the Compressor class
+  /// will be used The type of compression used can be determined by inspecting 
+  /// the first byte of the compressed output. ASCII values '0', '1', and '2', 
+  /// denote the compression type as given in the Algorithm enumeration below.
+  /// The Compressor is intended for use with memory mapped files where the 
+  /// entire data block to be compressed or decompressed is available in 
+  /// memory. Output, however, can be gathered in repeated calls to a callback.
+  /// @since 1.4
+  /// @brief An abstraction for memory to memory data compression
+  class Compressor {
+    /// @name Types
+    /// @{
+    public:
+      enum Algorithm {
+        COMP_TYPE_SIMPLE = '0',  ///< Use simple but ubiquitous algorithm
+        COMP_TYPE_ZLIB = '1',    ///< Use zlib algorithm, if available
+        COMP_TYPE_BZIP2 = '2',   ///< Use bzip2 algorithm (preferred)
+      };
+
+      /// A callback function type used by the Compressor to get the next chunk 
+      /// of data to which (de)compressed output will be written. This function
+      /// must be written by the caller to provide the buffering of the output
+      /// data.
+      /// @returns 0 for success, 1 for failure
+      /// @throws nothing
+      /// @brief Output callback function type
+      typedef unsigned (OutputDataCallback)(char*& buffer, unsigned& size);
+
+    /// @}
+    /// @name Methods
+    /// @{
+    public:
+      /// This function does the compression work. The block of memory starting
+      /// at \p in and extending for \p size bytes is compressed. The compressed
+      /// output is written to memory blocks returned by the \p cb callback. The
+      /// caller must provide an implementation of the OutputDataCallback
+      /// function type and provide its address as \p cb. Note that the callback
+      /// function will be called as many times as necessary to complete the
+      /// compression of the \p in block but that the total size will generally
+      /// be less than \p size. It is a good idea to provide as large a value to
+      /// the callback's \p size parameter as possible so that fewer calls to
+      /// the callback are made. The \p hint parameter tells the function which
+      /// kind of compression to start with. However, if its not available on
+      /// the platform, the algorithm "falls back" from bzip2 -> zlib -> simple.
+      /// @throws std::string if an error occurs
+      /// @returns the total size of the compressed data
+      /// @brief Compress a block of memory.
+      static uint64_t compress(char* in, unsigned size, OutputDataCallback* cb,
+                               Algorithm hint = COMP_TYPE_BZIP2);
+
+      /// This function does the decompression work. The block of memory
+      /// starting at \p in and extending for \p size bytes is decompressed. The
+      /// decompressed output is written to memory blocks returned by the \p cb
+      /// callback. The caller must provide an implementation of the
+      /// OutputDataCallback function type and provide its address as \p cb.
+      /// Note that the callback function will be called as many times as
+      /// necessary to complete the compression of the \p in block but that the
+      /// total size will generally be greater than \p size. It is a good idea
+      /// to provide as large a value to the callback's \p size parameter as 
+      /// possible so that fewer calls to the callback are made.
+      /// @throws std::string if an error occurs
+      /// @returns the total size of the decompressed data
+      /// @brief Decompress a block of memory.
+      static uint64_t decompress(char *in, unsigned size, 
+                                 OutputDataCallback* cb);
+
+    /// @}
+  };
+}
+
+// vim: sw=2 ai
+
+#endif

llvm/lib/Support/Compressor.cpp

+//===- lib/Support/Compressor.cpp -------------------------------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// 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
+// block compression.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Config/config.h"
+#include "llvm/Support/Compressor.h"
+#include "llvm/ADT/StringExtras.h"
+#include <cassert>
+#include <string>
+
+#ifdef HAVE_BZIP2
+#include <bzlib.h>
+#endif
+
+#ifdef HAVE_ZLIB
+#include <zlib.h>
+#endif
+
+#ifndef HAVE_BZIP2
+# ifndef HAVE_ZLIB
+#  warning No compression library is available!!
+# endif
+#endif
+
+namespace {
+
+inline int getdata(char*& buffer, unsigned& size, 
+                   llvm::Compressor::OutputDataCallback* cb) {
+  buffer = 0;
+  size = 0;
+  int result = (*cb)(buffer, size);
+  assert(buffer != 0 && "Invalid result from Compressor callback");
+  assert(size != 0 && "Invalid result from Compressor callback");
+  return result;
+}
+
+//===----------------------------------------------------------------------===//
+//=== RLCOMP - very simple run length compression scheme
+//===   The code below transforms the input into blocks that are either 
+//===   compressed or not. Each block starts with a header byte that provides
+//===   the length of the block. Values < 128 are uncompressed, values >128
+//===   are compressed. The value 128 is illegal. Currently, the algorithm is
+//===   not completed and is #if'd out.
+//===----------------------------------------------------------------------===//
+
+enum {
+  MAX_RLCOMP_OUT = 32768
+};
+
+struct RLCOMP_stream {
+  // User provided fields
+  char* next_in;
+  unsigned avail_in;
+  char* next_out;
+  unsigned avail_out;
+
+  // Information fields
+  uint64_t output_count; // Total count of output bytes
+
+#if 0
+  // Algorithm fields
+  unsigned block_len;    // Length of current block
+  unsigned compression;  // State of compression 0=no, 1=yes, 2=indeterminate
+  char buffer[128];      // compression buffer (not used for decompress)
+  unsigned buflen;       // bytes in compression buffer
+  bool pending;          // is data pending to be written
+  char pending_data;     // the pending data
+  unsigned clen;         // length of the compressed block
+#endif
+};
+
+void RLCOMP_init(RLCOMP_stream* s) {
+  s->output_count = 0;
+#if 0
+  s->block_len = 0;
+  s->compression = 2;
+  s->buflen = 0;
+  s->pending = false;
+  s->pending_data = 0;
+  s->clen = 0;
+#endif
+}
+
+inline bool RLCOMP_getchar(RLCOMP_stream* s, unsigned& data) {
+#if 0
+  if (s->avail_in) {
+    data = *s->next_in++;
+    s->avail_in--;
+    return true;
+  }
+#endif
+  return false;
+}
+
+inline bool RLCOMP_putchar(RLCOMP_stream* s, unsigned data) {
+#if 0
+  if (s->avail_out) {
+    *s->next_out++ = data;
+    s->avail_out--;
+    s->output_count++;
+    return true;
+  } else {
+    s->pending = true;
+    s->pending_data = data;
+    return false;
+  }
+#else
+  return false;
+#endif
+}
+
+bool RLCOMP_compress(RLCOMP_stream* s) {
+  assert(s && "Invalid RLCOMP_stream");
+  assert(s->next_in != 0);
+  assert(s->next_out != 0);
+  assert(s->avail_in >= 1);
+  assert(s->avail_out >= 1);
+
+#if 0
+
+  // Handle pending data from the last time in
+  if (s->pending) {
+    RLCOMP_putchar(s,s->pending_data);
+    s->pending = false;
+  }
+
+  unsigned c = 0;
+  unsigned lastc = 0;
+  // Handle the degenerate len=1 case
+  if (!RLCOMP_getchar(s,lastc)) {
+    RLCOMP_putchar(s,1);
+    return RLCOMP_putchar(s,lastc);
+  }
+
+  while (RLCOMP_getchar(s,c)) {
+    switch(s->compression) {
+      case 0:
+        if (lastc == c) {
+          s->compression = 1;
+          s->clen = 2 ;
+        } else {
+          if (!RLCOMP_putchar(s, c))
+            return false;
+        }
+        break;
+
+      case 1:
+        if (lastc != c) {
+          s->compression = 2;
+          if (!RLCOMP_putchar(s, s->clen))
+            return false;
+        } else {
+          s->clen++;
+        }
+        break;
+
+      case 2:
+        break;
+    }
+    lastc = c;
+  }
+#endif
+  if (s->avail_out >= s->avail_in) {
+    ::memcpy(s->next_out, s->next_in, s->avail_in);
+    s->output_count += s->avail_in;
+    s->avail_out -= s->avail_in;
+    s->next_in += s->avail_in;
+    s->avail_in = 0;
+    return true;
+  } else {
+    ::memcpy(s->next_out, s->next_in, s->avail_out);
+    s->output_count += s->avail_out;
+    s->avail_in -= s->avail_out;
+    s->next_in += s->avail_out;
+    s->avail_out = 0;
+    return false;
+  }
+}
+
+bool RLCOMP_decompress(RLCOMP_stream* s) {
+  assert(s && "Invalid RLCOMP_stream");
+  assert(s->next_in != 0);
+  assert(s->next_out != 0);
+  assert(s->avail_in >= 1);
+  assert(s->avail_out >= 1);
+
+#if 0
+  unsigned c = 0;
+  while (RLCOMP_getchar(s,c)) {
+    switch(s->compression) {
+      case 0: // This is not a compressed block
+        s->block_len--;
+        if (!RLCOMP_putchar(s,c))
+          return false;
+        break;
+
+      case 1: // This is a comperssed block
+        while (s->block_len-- > 0)
+          if (!RLCOMP_putchar(s,c))
+            return false;
+        break;
+
+      case 2: // This is the length field
+        if (c < 128) {
+          s->compression = 0;
+          s->block_len = c;
+        } else {
+          s->compression = 1;
+          s->block_len = c - 128;
+        }
+        continue;
+
+      default: // oops!
+        throw std::string("Invalid compression state");
+    }
+    if (s->block_len <= 0)
+      s->compression = 2;
+  }
+
+  if (s->repeat > 0)
+    throw std::string("Invalid compression state");
+#endif
+  if (s->avail_out >= s->avail_in) {
+    ::memcpy(s->next_out, s->next_in, s->avail_in);
+    s->output_count += s->avail_in;
+    s->avail_out -= s->avail_in;
+    s->next_in += s->avail_in;
+    s->avail_in = 0;
+    return true;
+  } else {
+    ::memcpy(s->next_out, s->next_in, s->avail_out);
+    s->output_count += s->avail_out;
+    s->avail_in -= s->avail_out;
+    s->next_in += s->avail_out;
+    s->avail_out = 0;
+    return false;
+  }
+}
+
+void RLCOMP_end(RLCOMP_stream* strm) {
+}
+
+}
+
+namespace llvm {
+
+// Compress in one of three ways
+uint64_t Compressor::compress(char* in, unsigned size, 
+                              OutputDataCallback* cb, Algorithm hint) {
+  assert(in && "Can't compress null buffer");
+  assert(size && "Can't compress empty buffer");
+  assert(cb && "Can't compress without a callback function");
+
+  uint64_t result = 0;
+
+  switch (hint) {
+    case COMP_TYPE_BZIP2: {
+#if defined(HAVE_BZIP2)
+      // Set up the bz_stream
+      bz_stream bzdata;
+      bzdata.bzalloc = 0;
+      bzdata.bzfree = 0;
+      bzdata.opaque = 0;
+      bzdata.next_in = in;
+      bzdata.avail_in = size;
+      bzdata.next_out = 0;
+      bzdata.avail_out = 0;
+      switch ( BZ2_bzCompressInit(&bzdata, 9, 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_OK:
+        default:
+          break;
+      }
+
+      // Get a block of memory
+      if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb)) {
+        BZ2_bzCompressEnd(&bzdata);
+        throw std::string("Can't allocate output buffer");
+      }
+
+      // Put compression code in first byte
+      (*bzdata.next_out++) = COMP_TYPE_BZIP2;
+      bzdata.avail_out--;
+
+      // 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)) {
+          BZ2_bzCompressEnd(&bzdata);
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+      switch (bzerr) {
+        case BZ_SEQUENCE_ERROR:
+        case BZ_PARAM_ERROR: throw std::string("Param/Sequence error");
+        case BZ_FINISH_OK:
+        case BZ_STREAM_END: break;
+        default: throw std::string("Oops: ") + utostr(unsigned(bzerr));
+      }
+
+      // Finish
+      result = (static_cast<uint64_t>(bzdata.total_out_hi32) << 32) |
+          bzdata.total_out_lo32 + 1;
+
+      BZ2_bzCompressEnd(&bzdata);
+      break;
+#else
+      // FALL THROUGH
+#endif
+    }
+
+    case COMP_TYPE_ZLIB: {
+#if defined(HAVE_ZLIB)
+      z_stream zdata;
+      zdata.zalloc = Z_NULL;
+      zdata.zfree = Z_NULL;
+      zdata.opaque = Z_NULL;
+      zdata.next_in = reinterpret_cast<Bytef*>(in);
+      zdata.avail_in = size;
+      if (Z_OK != deflateInit(&zdata,Z_BEST_COMPRESSION))
+        throw std::string(zdata.msg ? zdata.msg : "zlib error");
+
+      if (0 != getdata((char*&)(zdata.next_out), zdata.avail_out,cb)) {
+        deflateEnd(&zdata);
+        throw std::string("Can't allocate output buffer");
+      }
+
+      (*zdata.next_out++) = COMP_TYPE_ZLIB;
+      zdata.avail_out--;
+
+      int flush = 0;
+      while ( Z_OK == deflate(&zdata,0) && zdata.avail_out == 0) {
+        if (0 != getdata((char*&)zdata.next_out, zdata.avail_out, cb)) {
+          deflateEnd(&zdata);
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      while ( Z_STREAM_END != deflate(&zdata, Z_FINISH)) {
+        if (0 != getdata((char*&)zdata.next_out, zdata.avail_out, cb)) {
+          deflateEnd(&zdata);
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      result = static_cast<uint64_t>(zdata.total_out) + 1;
+      deflateEnd(&zdata);
+      break;
+
+#else
+    // FALL THROUGH
+#endif
+    }
+
+    case COMP_TYPE_SIMPLE: {
+      RLCOMP_stream sdata;
+      sdata.next_in = in;
+      sdata.avail_in = size;
+      RLCOMP_init(&sdata);
+
+      if (0 != getdata(sdata.next_out, sdata.avail_out,cb)) {
+        throw std::string("Can't allocate output buffer");
+      }
+
+      *(sdata.next_out++) = COMP_TYPE_SIMPLE;
+      sdata.avail_out--;
+
+      while (!RLCOMP_compress(&sdata)) {
+        if (0 != getdata(sdata.next_out, sdata.avail_out,cb)) {
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      result = sdata.output_count + 1;
+      RLCOMP_end(&sdata);
+      break;
+    }
+    default:
+      throw std::string("Invalid compression type hint");
+  }
+  return result;
+}
+
+// Decompress in one of three ways
+uint64_t Compressor::decompress(char *in, unsigned size, 
+                                OutputDataCallback* cb) {
+  assert(in && "Can't decompress null buffer");
+  assert(size > 1 && "Can't decompress empty buffer");
+  assert(cb && "Can't decompress without a callback function");
+
+  uint64_t result = 0;
+
+  switch (*in++) {
+    case COMP_TYPE_BZIP2: {
+#if !defined(HAVE_BZIP2)
+      throw std::string("Can't decompress BZIP2 data");
+#else
+      // Set up the bz_stream
+      bz_stream bzdata;
+      bzdata.bzalloc = 0;
+      bzdata.bzfree = 0;
+      bzdata.opaque = 0;
+      bzdata.next_in = in;
+      bzdata.avail_in = size - 1;
+      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_OK:
+        default:
+          break;
+      }
+
+      // Get a block of memory
+      if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb)) {
+        BZ2_bzDecompressEnd(&bzdata);
+        throw std::string("Can't allocate output buffer");
+      }
+
+      // Decompress it
+      int bzerr = BZ_OK;
+      while (BZ_OK == (bzerr = BZ2_bzDecompress(&bzdata))) {
+        if (0 != getdata(bzdata.next_out, bzdata.avail_out,cb)) {
+          BZ2_bzDecompressEnd(&bzdata);
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      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;
+      }
+
+      // Finish
+      result = (static_cast<uint64_t>(bzdata.total_out_hi32) << 32) |
+        bzdata.total_out_lo32;
+      BZ2_bzDecompressEnd(&bzdata);
+      break;
+    }
+#endif
+
+    case COMP_TYPE_ZLIB: {
+#if !defined(HAVE_ZLIB)
+      throw std::string("Can't decompress ZLIB data");
+#else
+      z_stream zdata;
+      zdata.zalloc = Z_NULL;
+      zdata.zfree = Z_NULL;
+      zdata.opaque = Z_NULL;
+      zdata.next_in = reinterpret_cast<Bytef*>(in);
+      zdata.avail_in = size - 1;
+      if ( Z_OK != inflateInit(&zdata))
+        throw std::string(zdata.msg ? zdata.msg : "zlib error");
+
+      if (0 != getdata((char*&)zdata.next_out, zdata.avail_out,cb)) {
+        inflateEnd(&zdata);
+        throw std::string("Can't allocate output buffer");
+      }
+
+      int zerr = Z_OK;
+      while (Z_OK == (zerr = inflate(&zdata,0))) {
+        if (0 != getdata((char*&)zdata.next_out, zdata.avail_out,cb)) {
+          inflateEnd(&zdata);
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      if (zerr != Z_STREAM_END)
+        throw std::string(zdata.msg?zdata.msg:"zlib error");
+
+      result = static_cast<uint64_t>(zdata.total_out);
+      inflateEnd(&zdata);
+      break;
+#endif
+    }
+
+    case COMP_TYPE_SIMPLE: {
+      RLCOMP_stream sdata;
+      sdata.next_in = in;
+      sdata.avail_in = size - 1;
+      RLCOMP_init(&sdata);
+
+      if (0 != getdata(sdata.next_out, sdata.avail_out,cb)) {
+        throw std::string("Can't allocate output buffer");
+      }
+
+      while (!RLCOMP_decompress(&sdata)) {
+        if (0 != getdata(sdata.next_out, sdata.avail_out,cb)) {
+          throw std::string("Can't allocate output buffer");
+        }
+      }
+
+      result = sdata.output_count;
+      RLCOMP_end(&sdata);
+      break;
+    }
+
+    default:
+      throw std::string("Unknown type of compressed data");
+  }
+
+  return result;
+}
+
+}
+
+// vim: sw=2 ai