Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 185 insertions, 185 deletions

diff --git a/contrib/libs/zstd/lib/common/entropy_common.c b/contrib/libs/zstd/lib/common/entropy_common.c
index 8be420e3311..4229b40c5ee 100644
--- a/contrib/libs/zstd/lib/common/entropy_common.c
+++ b/contrib/libs/zstd/lib/common/entropy_common.c
@@ -1,6 +1,6 @@
 /* ******************************************************************
  * Common functions of New Generation Entropy library
- * Copyright (c) Yann Collet, Facebook, Inc. 
+ * Copyright (c) Yann Collet, Facebook, Inc.
  *
  *  You can contact the author at :
  *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
@@ -38,11 +38,11 @@ const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
 /*-**************************************************************
 *  FSE NCount encoding-decoding
 ****************************************************************/
-static U32 FSE_ctz(U32 val) 
+static U32 FSE_ctz(U32 val)
 {
-    assert(val != 0); 
-    { 
-#   if defined(_MSC_VER)   /* Visual */ 
+    assert(val != 0);
+    {
+#   if defined(_MSC_VER)   /* Visual */
         if (val != 0) {
             unsigned long r;
             _BitScanForward(&r, val);
@@ -51,25 +51,25 @@ static U32 FSE_ctz(U32 val)
             /* Should not reach this code path */
             __assume(0);
         }
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */ 
-        return __builtin_ctz(val); 
-#   elif defined(__ICCARM__)    /* IAR Intrinsic */ 
-        return __CTZ(val); 
-#   else   /* Software version */ 
-        U32 count = 0; 
-        while ((val & 1) == 0) { 
-            val >>= 1; 
-            ++count; 
-        } 
-        return count; 
-#   endif 
-    } 
-} 
- 
-FORCE_INLINE_TEMPLATE 
-size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
-                           const void* headerBuffer, size_t hbSize) 
-{ 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
+        return __builtin_ctz(val);
+#   elif defined(__ICCARM__)    /* IAR Intrinsic */
+        return __CTZ(val);
+#   else   /* Software version */
+        U32 count = 0;
+        while ((val & 1) == 0) {
+            val >>= 1;
+            ++count;
+        }
+        return count;
+#   endif
+    }
+}
+
+FORCE_INLINE_TEMPLATE
+size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                           const void* headerBuffer, size_t hbSize)
+{
     const BYTE* const istart = (const BYTE*) headerBuffer;
     const BYTE* const iend = istart + hbSize;
     const BYTE* ip = istart;
@@ -79,23 +79,23 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
     U32 bitStream;
     int bitCount;
     unsigned charnum = 0;
-    unsigned const maxSV1 = *maxSVPtr + 1; 
+    unsigned const maxSV1 = *maxSVPtr + 1;
     int previous0 = 0;
 
-    if (hbSize < 8) { 
-        /* This function only works when hbSize >= 8 */ 
-        char buffer[8] = {0}; 
-        ZSTD_memcpy(buffer, headerBuffer, hbSize); 
+    if (hbSize < 8) {
+        /* This function only works when hbSize >= 8 */
+        char buffer[8] = {0};
+        ZSTD_memcpy(buffer, headerBuffer, hbSize);
         {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,
                                                     buffer, sizeof(buffer));
             if (FSE_isError(countSize)) return countSize;
             if (countSize > hbSize) return ERROR(corruption_detected);
             return countSize;
     }   }
-    assert(hbSize >= 8); 
+    assert(hbSize >= 8);
 
     /* init */
-    ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */ 
+    ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */
     bitStream = MEM_readLE32(ip);
     nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
     if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
@@ -106,58 +106,58 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
     threshold = 1<<nbBits;
     nbBits++;
 
-    for (;;) { 
+    for (;;) {
         if (previous0) {
-            /* Count the number of repeats. Each time the 
-             * 2-bit repeat code is 0b11 there is another 
-             * repeat. 
-             * Avoid UB by setting the high bit to 1. 
-             */ 
-            int repeats = FSE_ctz(~bitStream | 0x80000000) >> 1; 
-            while (repeats >= 12) { 
-                charnum += 3 * 12; 
-                if (LIKELY(ip <= iend-7)) { 
-                    ip += 3; 
+            /* Count the number of repeats. Each time the
+             * 2-bit repeat code is 0b11 there is another
+             * repeat.
+             * Avoid UB by setting the high bit to 1.
+             */
+            int repeats = FSE_ctz(~bitStream | 0x80000000) >> 1;
+            while (repeats >= 12) {
+                charnum += 3 * 12;
+                if (LIKELY(ip <= iend-7)) {
+                    ip += 3;
                 } else {
-                    bitCount -= (int)(8 * (iend - 7 - ip)); 
-                    bitCount &= 31; 
-                    ip = iend - 4; 
-                } 
-                bitStream = MEM_readLE32(ip) >> bitCount; 
-                repeats = FSE_ctz(~bitStream | 0x80000000) >> 1; 
+                    bitCount -= (int)(8 * (iend - 7 - ip));
+                    bitCount &= 31;
+                    ip = iend - 4;
+                }
+                bitStream = MEM_readLE32(ip) >> bitCount;
+                repeats = FSE_ctz(~bitStream | 0x80000000) >> 1;
             }
-            charnum += 3 * repeats; 
-            bitStream >>= 2 * repeats; 
-            bitCount += 2 * repeats; 
- 
-            /* Add the final repeat which isn't 0b11. */ 
-            assert((bitStream & 3) < 3); 
-            charnum += bitStream & 3; 
+            charnum += 3 * repeats;
+            bitStream >>= 2 * repeats;
+            bitCount += 2 * repeats;
+
+            /* Add the final repeat which isn't 0b11. */
+            assert((bitStream & 3) < 3);
+            charnum += bitStream & 3;
             bitCount += 2;
- 
-            /* This is an error, but break and return an error 
-             * at the end, because returning out of a loop makes 
-             * it harder for the compiler to optimize. 
-             */ 
-            if (charnum >= maxSV1) break; 
- 
-            /* We don't need to set the normalized count to 0 
-             * because we already memset the whole buffer to 0. 
-             */ 
- 
-            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+
+            /* This is an error, but break and return an error
+             * at the end, because returning out of a loop makes
+             * it harder for the compiler to optimize.
+             */
+            if (charnum >= maxSV1) break;
+
+            /* We don't need to set the normalized count to 0
+             * because we already memset the whole buffer to 0.
+             */
+
+            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
                 assert((bitCount >> 3) <= 3); /* For first condition to work */
                 ip += bitCount>>3;
                 bitCount &= 7;
             } else {
-                bitCount -= (int)(8 * (iend - 4 - ip)); 
-                bitCount &= 31; 
-                ip = iend - 4; 
-            } 
-            bitStream = MEM_readLE32(ip) >> bitCount; 
-        } 
-        { 
-            int const max = (2*threshold-1) - remaining; 
+                bitCount -= (int)(8 * (iend - 4 - ip));
+                bitCount &= 31;
+                ip = iend - 4;
+            }
+            bitStream = MEM_readLE32(ip) >> bitCount;
+        }
+        {
+            int const max = (2*threshold-1) - remaining;
             int count;
 
             if ((bitStream & (threshold-1)) < (U32)max) {
@@ -170,43 +170,43 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
             }
 
             count--;   /* extra accuracy */
-            /* When it matters (small blocks), this is a 
-             * predictable branch, because we don't use -1. 
-             */ 
-            if (count >= 0) { 
-                remaining -= count; 
-            } else { 
-                assert(count == -1); 
-                remaining += count; 
-            } 
+            /* When it matters (small blocks), this is a
+             * predictable branch, because we don't use -1.
+             */
+            if (count >= 0) {
+                remaining -= count;
+            } else {
+                assert(count == -1);
+                remaining += count;
+            }
             normalizedCounter[charnum++] = (short)count;
             previous0 = !count;
- 
-            assert(threshold > 1); 
-            if (remaining < threshold) { 
-                /* This branch can be folded into the 
-                 * threshold update condition because we 
-                 * know that threshold > 1. 
-                 */ 
-                if (remaining <= 1) break; 
-                nbBits = BIT_highbit32(remaining) + 1; 
-                threshold = 1 << (nbBits - 1); 
+
+            assert(threshold > 1);
+            if (remaining < threshold) {
+                /* This branch can be folded into the
+                 * threshold update condition because we
+                 * know that threshold > 1.
+                 */
+                if (remaining <= 1) break;
+                nbBits = BIT_highbit32(remaining) + 1;
+                threshold = 1 << (nbBits - 1);
             }
-            if (charnum >= maxSV1) break; 
+            if (charnum >= maxSV1) break;
 
-            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
                 ip += bitCount>>3;
                 bitCount &= 7;
             } else {
                 bitCount -= (int)(8 * (iend - 4 - ip));
-                bitCount &= 31; 
+                bitCount &= 31;
                 ip = iend - 4;
             }
-            bitStream = MEM_readLE32(ip) >> bitCount; 
-    }   } 
+            bitStream = MEM_readLE32(ip) >> bitCount;
+    }   }
     if (remaining != 1) return ERROR(corruption_detected);
-    /* Only possible when there are too many zeros. */ 
-    if (charnum > maxSV1) return ERROR(maxSymbolValue_tooSmall); 
+    /* Only possible when there are too many zeros. */
+    if (charnum > maxSV1) return ERROR(maxSymbolValue_tooSmall);
     if (bitCount > 32) return ERROR(corruption_detected);
     *maxSVPtr = charnum-1;
 
@@ -214,44 +214,44 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
     return ip-istart;
 }
 
-/* Avoids the FORCE_INLINE of the _body() function. */ 
-static size_t FSE_readNCount_body_default( 
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
-        const void* headerBuffer, size_t hbSize) 
-{ 
-    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize); 
-} 
+/* Avoids the FORCE_INLINE of the _body() function. */
+static size_t FSE_readNCount_body_default(
+        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+        const void* headerBuffer, size_t hbSize)
+{
+    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
+}
 
-#if DYNAMIC_BMI2 
+#if DYNAMIC_BMI2
 BMI2_TARGET_ATTRIBUTE static size_t FSE_readNCount_body_bmi2(
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
-        const void* headerBuffer, size_t hbSize) 
-{ 
-    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize); 
-} 
-#endif 
- 
-size_t FSE_readNCount_bmi2( 
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
-        const void* headerBuffer, size_t hbSize, int bmi2) 
-{ 
-#if DYNAMIC_BMI2 
-    if (bmi2) { 
-        return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize); 
-    } 
-#endif 
-    (void)bmi2; 
-    return FSE_readNCount_body_default(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize); 
-} 
- 
-size_t FSE_readNCount( 
-        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
-        const void* headerBuffer, size_t hbSize) 
-{ 
-    return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0); 
-} 
- 
- 
+        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+        const void* headerBuffer, size_t hbSize)
+{
+    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
+}
+#endif
+
+size_t FSE_readNCount_bmi2(
+        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+        const void* headerBuffer, size_t hbSize, int bmi2)
+{
+#if DYNAMIC_BMI2
+    if (bmi2) {
+        return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
+    }
+#endif
+    (void)bmi2;
+    return FSE_readNCount_body_default(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
+}
+
+size_t FSE_readNCount(
+        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+        const void* headerBuffer, size_t hbSize)
+{
+    return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0);
+}
+
+
 /*! HUF_readStats() :
     Read compact Huffman tree, saved by HUF_writeCTable().
     `huffWeight` is destination buffer.
@@ -263,17 +263,17 @@ size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
                      U32* nbSymbolsPtr, U32* tableLogPtr,
                      const void* src, size_t srcSize)
 {
-    U32 wksp[HUF_READ_STATS_WORKSPACE_SIZE_U32]; 
-    return HUF_readStats_wksp(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, wksp, sizeof(wksp), /* bmi2 */ 0); 
-} 
- 
-FORCE_INLINE_TEMPLATE size_t 
-HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
-                   U32* nbSymbolsPtr, U32* tableLogPtr, 
-                   const void* src, size_t srcSize, 
-                   void* workSpace, size_t wkspSize, 
-                   int bmi2) 
-{ 
+    U32 wksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
+    return HUF_readStats_wksp(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, wksp, sizeof(wksp), /* bmi2 */ 0);
+}
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                   U32* nbSymbolsPtr, U32* tableLogPtr,
+                   const void* src, size_t srcSize,
+                   void* workSpace, size_t wkspSize,
+                   int bmi2)
+{
     U32 weightTotal;
     const BYTE* ip = (const BYTE*) src;
     size_t iSize;
@@ -281,7 +281,7 @@ HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
-    /* ZSTD_memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */ 
+    /* ZSTD_memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */
 
     if (iSize >= 128) {  /* special header */
         oSize = iSize - 127;
@@ -296,13 +296,13 @@ HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
     }   }   }
     else  {   /* header compressed with FSE (normal case) */
         if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        /* max (hwSize-1) values decoded, as last one is implied */ 
-        oSize = FSE_decompress_wksp_bmi2(huffWeight, hwSize-1, ip+1, iSize, 6, workSpace, wkspSize, bmi2); 
+        /* max (hwSize-1) values decoded, as last one is implied */
+        oSize = FSE_decompress_wksp_bmi2(huffWeight, hwSize-1, ip+1, iSize, 6, workSpace, wkspSize, bmi2);
         if (FSE_isError(oSize)) return oSize;
     }
 
     /* collect weight stats */
-    ZSTD_memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32)); 
+    ZSTD_memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
     weightTotal = 0;
     {   U32 n; for (n=0; n<oSize; n++) {
             if (huffWeight[n] > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
@@ -332,37 +332,37 @@ HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
     *nbSymbolsPtr = (U32)(oSize+1);
     return iSize+1;
 }
- 
-/* Avoids the FORCE_INLINE of the _body() function. */ 
-static size_t HUF_readStats_body_default(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
-                     U32* nbSymbolsPtr, U32* tableLogPtr, 
-                     const void* src, size_t srcSize, 
-                     void* workSpace, size_t wkspSize) 
-{ 
-    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 0); 
-} 
- 
-#if DYNAMIC_BMI2 
+
+/* Avoids the FORCE_INLINE of the _body() function. */
+static size_t HUF_readStats_body_default(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize,
+                     void* workSpace, size_t wkspSize)
+{
+    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 0);
+}
+
+#if DYNAMIC_BMI2
 static BMI2_TARGET_ATTRIBUTE size_t HUF_readStats_body_bmi2(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr, 
-                     const void* src, size_t srcSize, 
-                     void* workSpace, size_t wkspSize) 
-{ 
-    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 1); 
-} 
-#endif 
- 
-size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
-                     U32* nbSymbolsPtr, U32* tableLogPtr, 
-                     const void* src, size_t srcSize, 
-                     void* workSpace, size_t wkspSize, 
-                     int bmi2) 
-{ 
-#if DYNAMIC_BMI2 
-    if (bmi2) { 
-        return HUF_readStats_body_bmi2(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize); 
-    } 
-#endif 
-    (void)bmi2; 
-    return HUF_readStats_body_default(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize); 
-} 
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize,
+                     void* workSpace, size_t wkspSize)
+{
+    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 1);
+}
+#endif
+
+size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize,
+                     void* workSpace, size_t wkspSize,
+                     int bmi2)
+{
+#if DYNAMIC_BMI2
+    if (bmi2) {
+        return HUF_readStats_body_bmi2(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);
+    }
+#endif
+    (void)bmi2;
+    return HUF_readStats_body_default(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);
+}