Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- llvm/Support/Compression.h ---Compression----------------*- C++ -*-===//
  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 contains basic functions for compression/decompression.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_SUPPORT_COMPRESSION_H
  14. #define LLVM_SUPPORT_COMPRESSION_H
  15.  
  16. #include "llvm/ADT/ArrayRef.h"
  17. #include "llvm/Support/DataTypes.h"
  18.  
  19. namespace llvm {
  20. template <typename T> class SmallVectorImpl;
  21. class Error;
  22.  
  23. // None indicates no compression. The other members are a subset of
  24. // compression::Format, which is used for compressed debug sections in some
  25. // object file formats (e.g. ELF). This is a separate class as we may add new
  26. // compression::Format members for non-debugging purposes.
  27. enum class DebugCompressionType {
  28.   None, ///< No compression
  29.   Zlib, ///< zlib
  30.   Zstd, ///< Zstandard
  31. };
  32.  
  33. namespace compression {
  34. namespace zlib {
  35.  
  36. constexpr int NoCompression = 0;
  37. constexpr int BestSpeedCompression = 1;
  38. constexpr int DefaultCompression = 6;
  39. constexpr int BestSizeCompression = 9;
  40.  
  41. bool isAvailable();
  42.  
  43. void compress(ArrayRef<uint8_t> Input,
  44.               SmallVectorImpl<uint8_t> &CompressedBuffer,
  45.               int Level = DefaultCompression);
  46.  
  47. Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
  48.                  size_t &UncompressedSize);
  49.  
  50. Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
  51.                  size_t UncompressedSize);
  52.  
  53. } // End of namespace zlib
  54.  
  55. namespace zstd {
  56.  
  57. constexpr int NoCompression = -5;
  58. constexpr int BestSpeedCompression = 1;
  59. constexpr int DefaultCompression = 5;
  60. constexpr int BestSizeCompression = 12;
  61.  
  62. bool isAvailable();
  63.  
  64. void compress(ArrayRef<uint8_t> Input,
  65.               SmallVectorImpl<uint8_t> &CompressedBuffer,
  66.               int Level = DefaultCompression);
  67.  
  68. Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
  69.                  size_t &UncompressedSize);
  70.  
  71. Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
  72.                  size_t UncompressedSize);
  73.  
  74. } // End of namespace zstd
  75.  
  76. enum class Format {
  77.   Zlib,
  78.   Zstd,
  79. };
  80.  
  81. inline Format formatFor(DebugCompressionType Type) {
  82.   switch (Type) {
  83.   case DebugCompressionType::None:
  84.     llvm_unreachable("not a compression type");
  85.   case DebugCompressionType::Zlib:
  86.     return Format::Zlib;
  87.   case DebugCompressionType::Zstd:
  88.     return Format::Zstd;
  89.   }
  90.   llvm_unreachable("");
  91. }
  92.  
  93. struct Params {
  94.   constexpr Params(Format F)
  95.       : format(F), level(F == Format::Zlib ? zlib::DefaultCompression
  96.                                            : zstd::DefaultCompression) {}
  97.   Params(DebugCompressionType Type) : Params(formatFor(Type)) {}
  98.  
  99.   Format format;
  100.   int level;
  101.   // This may support multi-threading for zstd in the future. Note that
  102.   // different threads may produce different output, so be careful if certain
  103.   // output determinism is desired.
  104. };
  105.  
  106. // Return nullptr if LLVM was built with support (LLVM_ENABLE_ZLIB,
  107. // LLVM_ENABLE_ZSTD) for the specified compression format; otherwise
  108. // return a string literal describing the reason.
  109. const char *getReasonIfUnsupported(Format F);
  110.  
  111. // Compress Input with the specified format P.Format. If Level is -1, use
  112. // *::DefaultCompression for the format.
  113. void compress(Params P, ArrayRef<uint8_t> Input,
  114.               SmallVectorImpl<uint8_t> &Output);
  115.  
  116. // Decompress Input. The uncompressed size must be available.
  117. Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
  118.                  uint8_t *Output, size_t UncompressedSize);
  119. Error decompress(Format F, ArrayRef<uint8_t> Input,
  120.                  SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
  121. Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
  122.                  SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
  123.  
  124. } // End of namespace compression
  125.  
  126. } // End of namespace llvm
  127.  
  128. #endif
  129.