zlib: update to 1.2.11

1 files changed, 197 insertions, 180 deletions

diff --git a/libs/zlib/src/crc32.c b/libs/zlib/src/crc32.c
index a7da8f56fb..9580440c0e 100644
--- a/libs/zlib/src/crc32.c
+++ b/libs/zlib/src/crc32.c
@@ -1,5 +1,5 @@
 /* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h
  *
  * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
@@ -30,17 +30,15 @@
 
 #include "zutil.h"      /* for STDC and FAR definitions */
 
-#define local static
-
 /* Definitions for doing the crc four data bytes at a time. */
 #if !defined(NOBYFOUR) && defined(Z_U4)
 #  define BYFOUR
 #endif
 #ifdef BYFOUR
    local unsigned long crc32_little OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
+                        const unsigned char FAR *, z_size_t));
    local unsigned long crc32_big OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
+                        const unsigned char FAR *, z_size_t));
 #  define TBLS 8
 #else
 #  define TBLS 1
@@ -184,16 +182,16 @@ local void write_table(out, table)
 #include "crc32.h"
 #endif /* DYNAMIC_CRC_TABLE */
 
- /* =========================================================================
-  * This function can be used by asm versions of crc32()
-  */
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
 const z_crc_t FAR * ZEXPORT get_crc_table()
 {
-	#ifdef DYNAMIC_CRC_TABLE
-	if (crc_table_empty)
-		make_crc_table();
-	#endif /* DYNAMIC_CRC_TABLE */
-	return (const z_crc_t FAR *)crc_table;
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const z_crc_t FAR *)crc_table;
 }
 
 /* ========================================================================= */
@@ -201,42 +199,63 @@ const z_crc_t FAR * ZEXPORT get_crc_table()
 #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
 
 /* ========================================================================= */
+unsigned long ZEXPORT crc32_z(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+        z_crc_t endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+/* ========================================================================= */
 unsigned long ZEXPORT crc32(crc, buf, len)
-unsigned long crc;
-const unsigned char FAR *buf;
-uInt len;
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    uInt len;
 {
-	if (buf == Z_NULL) return 0UL;
-
-	#ifdef DYNAMIC_CRC_TABLE
-	if (crc_table_empty)
-		make_crc_table();
-	#endif /* DYNAMIC_CRC_TABLE */
-
-	#ifdef BYFOUR
-	if (sizeof(void *) == sizeof(ptrdiff_t)) {
-		z_crc_t endian;
-
-		endian = 1;
-		if (*((unsigned char *)(&endian)))
-			return crc32_little(crc, buf, len);
-		else
-			return crc32_big(crc, buf, len);
-	}
-	#endif /* BYFOUR */
-	crc = crc ^ 0xffffffffUL;
-	while (len >= 8) {
-		DO8;
-		len -= 8;
-	}
-	if (len) do {
-		DO1;
-	} while (--len);
-	return crc ^ 0xffffffffUL;
+    return crc32_z(crc, buf, len);
 }
 
 #ifdef BYFOUR
 
+/*
+   This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+   integer pointer type. This violates the strict aliasing rule, where a
+   compiler can assume, for optimization purposes, that two pointers to
+   fundamentally different types won't ever point to the same memory. This can
+   manifest as a problem only if one of the pointers is written to. This code
+   only reads from those pointers. So long as this code remains isolated in
+   this compilation unit, there won't be a problem. For this reason, this code
+   should not be copied and pasted into a compilation unit in which other code
+   writes to the buffer that is passed to these routines.
+ */
+
 /* ========================================================================= */
 #define DOLIT4 c ^= *buf4++; \
         c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
@@ -245,78 +264,76 @@ uInt len;
 
 /* ========================================================================= */
 local unsigned long crc32_little(crc, buf, len)
-unsigned long crc;
-const unsigned char FAR *buf;
-unsigned len;
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
 {
-	register z_crc_t c;
-	register const z_crc_t FAR *buf4;
-
-	c = (z_crc_t)crc;
-	c = ~c;
-	while (len && ((ptrdiff_t)buf & 3)) {
-		c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-		len--;
-	}
-
-	buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
-	while (len >= 32) {
-		DOLIT32;
-		len -= 32;
-	}
-	while (len >= 4) {
-		DOLIT4;
-		len -= 4;
-	}
-	buf = (const unsigned char FAR *)buf4;
-
-	if (len) do {
-		c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-	} while (--len);
-	c = ~c;
-	return (unsigned long)c;
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = (z_crc_t)crc;
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
 }
 
 /* ========================================================================= */
-#define DOBIG4 c ^= *++buf4; \
+#define DOBIG4 c ^= *buf4++; \
         c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
             crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
 #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
 
 /* ========================================================================= */
 local unsigned long crc32_big(crc, buf, len)
-unsigned long crc;
-const unsigned char FAR *buf;
-unsigned len;
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
 {
-	register z_crc_t c;
-	register const z_crc_t FAR *buf4;
-
-	c = ZSWAP32((z_crc_t)crc);
-	c = ~c;
-	while (len && ((ptrdiff_t)buf & 3)) {
-		c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-		len--;
-	}
-
-	buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
-	buf4--;
-	while (len >= 32) {
-		DOBIG32;
-		len -= 32;
-	}
-	while (len >= 4) {
-		DOBIG4;
-		len -= 4;
-	}
-	buf4++;
-	buf = (const unsigned char FAR *)buf4;
-
-	if (len) do {
-		c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-	} while (--len);
-	c = ~c;
-	return (unsigned long)(ZSWAP32(c));
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = ZSWAP32((z_crc_t)crc);
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(ZSWAP32(c));
 }
 
 #endif /* BYFOUR */
@@ -325,101 +342,101 @@ unsigned len;
 
 /* ========================================================================= */
 local unsigned long gf2_matrix_times(mat, vec)
-unsigned long *mat;
-unsigned long vec;
+    unsigned long *mat;
+    unsigned long vec;
 {
-	unsigned long sum;
-
-	sum = 0;
-	while (vec) {
-		if (vec & 1)
-			sum ^= *mat;
-		vec >>= 1;
-		mat++;
-	}
-	return sum;
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
 }
 
 /* ========================================================================= */
 local void gf2_matrix_square(square, mat)
-unsigned long *square;
-unsigned long *mat;
+    unsigned long *square;
+    unsigned long *mat;
 {
-	int n;
+    int n;
 
-	for (n = 0; n < GF2_DIM; n++)
-		square[n] = gf2_matrix_times(mat, mat[n]);
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
 }
 
 /* ========================================================================= */
 local uLong crc32_combine_(crc1, crc2, len2)
-uLong crc1;
-uLong crc2;
-z_off64_t len2;
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
 {
-	int n;
-	unsigned long row;
-	unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
-	unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
-
-	/* degenerate case (also disallow negative lengths) */
-	if (len2 <= 0)
-		return crc1;
-
-	/* put operator for one zero bit in odd */
-	odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
-	row = 1;
-	for (n = 1; n < GF2_DIM; n++) {
-		odd[n] = row;
-		row <<= 1;
-	}
-
-	/* put operator for two zero bits in even */
-	gf2_matrix_square(even, odd);
-
-	/* put operator for four zero bits in odd */
-	gf2_matrix_square(odd, even);
-
-	/* apply len2 zeros to crc1 (first square will put the operator for one
-		zero byte, eight zero bits, in even) */
-	do {
-		/* apply zeros operator for this bit of len2 */
-		gf2_matrix_square(even, odd);
-		if (len2 & 1)
-			crc1 = gf2_matrix_times(even, crc1);
-		len2 >>= 1;
-
-		/* if no more bits set, then done */
-		if (len2 == 0)
-			break;
-
-		/* another iteration of the loop with odd and even swapped */
-		gf2_matrix_square(odd, even);
-		if (len2 & 1)
-			crc1 = gf2_matrix_times(odd, crc1);
-		len2 >>= 1;
-
-		/* if no more bits set, then done */
-	} while (len2 != 0);
-
-	/* return combined crc */
-	crc1 ^= crc2;
-	return crc1;
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case (also disallow negative lengths) */
+    if (len2 <= 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
 }
 
 /* ========================================================================= */
 uLong ZEXPORT crc32_combine(crc1, crc2, len2)
-uLong crc1;
-uLong crc2;
-z_off_t len2;
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
 {
-	return crc32_combine_(crc1, crc2, len2);
+    return crc32_combine_(crc1, crc2, len2);
 }
 
 uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
-uLong crc1;
-uLong crc2;
-z_off64_t len2;
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
 {
-	return crc32_combine_(crc1, crc2, len2);
+    return crc32_combine_(crc1, crc2, len2);
 }