Line data    Source code

       1             : //===--- Compression.cpp - Compression implementation ---------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : //  This file implements compression functions.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Support/Compression.h"
      15             : #include "llvm/ADT/SmallVector.h"
      16             : #include "llvm/ADT/StringRef.h"
      17             : #include "llvm/Config/config.h"
      18             : #include "llvm/Support/Compiler.h"
      19             : #include "llvm/Support/Error.h"
      20             : #include "llvm/Support/ErrorHandling.h"
      21             : #if LLVM_ENABLE_ZLIB == 1 && HAVE_ZLIB_H
      22             : #include <zlib.h>
      23             : #endif
      24             : 
      25             : using namespace llvm;
      26             : 
      27             : #if LLVM_ENABLE_ZLIB == 1 && HAVE_LIBZ
      28          10 : static Error createError(StringRef Err) {
      29          10 :   return make_error<StringError>(Err, inconvertibleErrorCode());
      30             : }
      31             : 
      32          10 : static StringRef convertZlibCodeToString(int Code) {
      33          10 :   switch (Code) {
      34             :   case Z_MEM_ERROR:
      35           0 :     return "zlib error: Z_MEM_ERROR";
      36             :   case Z_BUF_ERROR:
      37           8 :     return "zlib error: Z_BUF_ERROR";
      38             :   case Z_STREAM_ERROR:
      39           0 :     return "zlib error: Z_STREAM_ERROR";
      40             :   case Z_DATA_ERROR:
      41           2 :     return "zlib error: Z_DATA_ERROR";
      42           0 :   case Z_OK:
      43             :   default:
      44           0 :     llvm_unreachable("unknown or unexpected zlib status code");
      45             :   }
      46             : }
      47             : 
      48       12253 : bool zlib::isAvailable() { return true; }
      49             : 
      50        5445 : Error zlib::compress(StringRef InputBuffer,
      51             :                      SmallVectorImpl<char> &CompressedBuffer, int Level) {
      52        5445 :   unsigned long CompressedSize = ::compressBound(InputBuffer.size());
      53             :   CompressedBuffer.reserve(CompressedSize);
      54             :   int Res =
      55        5445 :       ::compress2((Bytef *)CompressedBuffer.data(), &CompressedSize,
      56             :                   (const Bytef *)InputBuffer.data(), InputBuffer.size(), Level);
      57             :   // Tell MemorySanitizer that zlib output buffer is fully initialized.
      58             :   // This avoids a false report when running LLVM with uninstrumented ZLib.
      59             :   __msan_unpoison(CompressedBuffer.data(), CompressedSize);
      60        5445 :   CompressedBuffer.set_size(CompressedSize);
      61        5445 :   return Res ? createError(convertZlibCodeToString(Res)) : Error::success();
      62             : }
      63             : 
      64        6817 : Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
      65             :                        size_t &UncompressedSize) {
      66             :   int Res =
      67        6817 :       ::uncompress((Bytef *)UncompressedBuffer, (uLongf *)&UncompressedSize,
      68             :                    (const Bytef *)InputBuffer.data(), InputBuffer.size());
      69             :   // Tell MemorySanitizer that zlib output buffer is fully initialized.
      70             :   // This avoids a false report when running LLVM with uninstrumented ZLib.
      71             :   __msan_unpoison(UncompressedBuffer, UncompressedSize);
      72        6817 :   return Res ? createError(convertZlibCodeToString(Res)) : Error::success();
      73             : }
      74             : 
      75        6768 : Error zlib::uncompress(StringRef InputBuffer,
      76             :                        SmallVectorImpl<char> &UncompressedBuffer,
      77             :                        size_t UncompressedSize) {
      78        6768 :   UncompressedBuffer.resize(UncompressedSize);
      79             :   Error E =
      80        6768 :       uncompress(InputBuffer, UncompressedBuffer.data(), UncompressedSize);
      81        6768 :   UncompressedBuffer.resize(UncompressedSize);
      82        6768 :   return E;
      83             : }
      84             : 
      85           5 : uint32_t zlib::crc32(StringRef Buffer) {
      86          10 :   return ::crc32(0, (const Bytef *)Buffer.data(), Buffer.size());
      87             : }
      88             : 
      89             : #else
      90             : bool zlib::isAvailable() { return false; }
      91             : Error zlib::compress(StringRef InputBuffer,
      92             :                      SmallVectorImpl<char> &CompressedBuffer, int Level) {
      93             :   llvm_unreachable("zlib::compress is unavailable");
      94             : }
      95             : Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
      96             :                        size_t &UncompressedSize) {
      97             :   llvm_unreachable("zlib::uncompress is unavailable");
      98             : }
      99             : Error zlib::uncompress(StringRef InputBuffer,
     100             :                        SmallVectorImpl<char> &UncompressedBuffer,
     101             :                        size_t UncompressedSize) {
     102             :   llvm_unreachable("zlib::uncompress is unavailable");
     103             : }
     104             : uint32_t zlib::crc32(StringRef Buffer) {
     105             :   llvm_unreachable("zlib::crc32 is unavailable");
     106             : }
     107             : #endif