external/public-domain/xz/dist/src/liblzma/check/crc32_fast.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       crc32.c
   4 /// \brief      CRC32 calculation
   5 ///
   6 /// Calculate the CRC32 using the slice-by-eight algorithm.
   7 /// It is explained in this document:
   8 /// http://www.intel.com/technology/comms/perfnet/download/CRC_generators.pdf
   9 /// The code in this file is not the same as in Intel's paper, but
  10 /// the basic principle is identical.
  11 //
  12 //  Author:     Lasse Collin
  13 //
  14 //  This file has been put into the public domain.
  15 //  You can do whatever you want with this file.
  16 //
  17 ///////////////////////////////////////////////////////////////////////////////
  18
  19 #include "check.h"
  20 #include "crc_macros.h"
  21
  22
  23 // If you make any changes, do some benchmarking! Seemingly unrelated
  24 // changes can very easily ruin the performance (and very probably is
  25 // very compiler dependent).
  26 extern LZMA_API(uint32_t)
  27 lzma_crc32(const uint8_t *buf, size_t size, uint32_t crc)
  28 {
  29         crc = ~crc;
  30
  31 #ifdef WORDS_BIGENDIAN
  32         crc = bswap32(crc);
  33 #endif
  34
  35         if (size > 8) {
  36                 // Fix the alignment, if needed. The if statement above
  37                 // ensures that this won't read past the end of buf[].
  38                 while ((uintptr_t)(buf) & 7) {
  39                         crc = lzma_crc32_table[0][*buf++ ^ A(crc)] ^ S8(crc);
  40                         --size;
  41                 }
  42
  43                 // Calculate the position where to stop.
  44                 const uint8_t *const limit = buf + (size & ~(size_t)(7));
  45
  46                 // Calculate how many bytes must be calculated separately
  47                 // before returning the result.
  48                 size &= (size_t)(7);
  49
  50                 // Calculate the CRC32 using the slice-by-eight algorithm.
  51                 while (buf < limit) {
  52                         crc ^= *(const uint32_t *)(buf);
  53                         buf += 4;
  54
  55                         crc = lzma_crc32_table[7][A(crc)]
  56                             ^ lzma_crc32_table[6][B(crc)]
  57                             ^ lzma_crc32_table[5][C(crc)]
  58                             ^ lzma_crc32_table[4][D(crc)];
  59
  60                         const uint32_t tmp = *(const uint32_t *)(buf);
  61                         buf += 4;
  62
  63                         // At least with some compilers, it is critical for
  64                         // performance, that the crc variable is XORed
  65                         // between the two table-lookup pairs.
  66                         crc = lzma_crc32_table[3][A(tmp)]
  67                             ^ lzma_crc32_table[2][B(tmp)]
  68                             ^ crc
  69                             ^ lzma_crc32_table[1][C(tmp)]
  70                             ^ lzma_crc32_table[0][D(tmp)];
  71                 }
  72         }
  73
  74         while (size-- != 0)
  75                 crc = lzma_crc32_table[0][*buf++ ^ A(crc)] ^ S8(crc);
  76
  77 #ifdef WORDS_BIGENDIAN
  78         crc = bswap32(crc);
  79 #endif
  80
  81         return ~crc;
  82 }