libdeflate 0.1.1 → 0.2.0

data/ext/libdeflate/libdeflate/lib/gzip_compress.c

@@ -1,95 +0,0 @@
-/*
- * gzip_compress.c - compress with a gzip wrapper
- *
- * Originally public domain; changes after 2016-09-07 are copyrighted.
- *
- * Copyright 2016 Eric Biggers
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "deflate_compress.h"
-#include "gzip_constants.h"
-#include "unaligned.h"
-
-#include "libdeflate.h"
-
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress(struct libdeflate_compressor *c,
-			 const void *in, size_t in_size,
-			 void *out, size_t out_nbytes_avail)
-{
-	u8 *out_next = out;
-	unsigned compression_level;
-	u8 xfl;
-	size_t deflate_size;
-
-	if (out_nbytes_avail <= GZIP_MIN_OVERHEAD)
-		return 0;
-
-	/* ID1 */
-	*out_next++ = GZIP_ID1;
-	/* ID2 */
-	*out_next++ = GZIP_ID2;
-	/* CM */
-	*out_next++ = GZIP_CM_DEFLATE;
-	/* FLG */
-	*out_next++ = 0;
-	/* MTIME */
-	put_unaligned_le32(GZIP_MTIME_UNAVAILABLE, out_next);
-	out_next += 4;
-	/* XFL */
-	xfl = 0;
-	compression_level = deflate_get_compression_level(c);
-	if (compression_level < 2)
-		xfl |= GZIP_XFL_FASTEST_COMRESSION;
-	else if (compression_level >= 8)
-		xfl |= GZIP_XFL_SLOWEST_COMRESSION;
-	*out_next++ = xfl;
-	/* OS */
-	*out_next++ = GZIP_OS_UNKNOWN;	/* OS  */
-
-	/* Compressed data  */
-	deflate_size = libdeflate_deflate_compress(c, in, in_size, out_next,
-					out_nbytes_avail - GZIP_MIN_OVERHEAD);
-	if (deflate_size == 0)
-		return 0;
-	out_next += deflate_size;
-
-	/* CRC32 */
-	put_unaligned_le32(libdeflate_crc32(0, in, in_size), out_next);
-	out_next += 4;
-
-	/* ISIZE */
-	put_unaligned_le32((u32)in_size, out_next);
-	out_next += 4;
-
-	return out_next - (u8 *)out;
-}
-
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress_bound(struct libdeflate_compressor *c,
-			       size_t in_nbytes)
-{
-	return GZIP_MIN_OVERHEAD +
-	       libdeflate_deflate_compress_bound(c, in_nbytes);
-}

data/ext/libdeflate/libdeflate/lib/gzip_constants.h

@@ -1,45 +0,0 @@
-/*
- * gzip_constants.h - constants for the gzip wrapper format
- */
-
-#ifndef LIB_GZIP_CONSTANTS_H
-#define LIB_GZIP_CONSTANTS_H
-
-#define GZIP_MIN_HEADER_SIZE	10
-#define GZIP_FOOTER_SIZE	8
-#define GZIP_MIN_OVERHEAD	(GZIP_MIN_HEADER_SIZE + GZIP_FOOTER_SIZE)
-
-#define GZIP_ID1		0x1F
-#define GZIP_ID2		0x8B
-
-#define GZIP_CM_DEFLATE		8
-
-#define GZIP_FTEXT		0x01
-#define GZIP_FHCRC		0x02
-#define GZIP_FEXTRA		0x04
-#define GZIP_FNAME		0x08
-#define GZIP_FCOMMENT		0x10
-#define GZIP_FRESERVED		0xE0
-
-#define GZIP_MTIME_UNAVAILABLE	0
-
-#define GZIP_XFL_SLOWEST_COMRESSION	0x02
-#define GZIP_XFL_FASTEST_COMRESSION	0x04
-
-#define GZIP_OS_FAT		0
-#define GZIP_OS_AMIGA		1
-#define GZIP_OS_VMS		2
-#define GZIP_OS_UNIX		3
-#define GZIP_OS_VM_CMS		4
-#define GZIP_OS_ATARI_TOS	5
-#define GZIP_OS_HPFS		6
-#define GZIP_OS_MACINTOSH	7
-#define GZIP_OS_Z_SYSTEM	8
-#define GZIP_OS_CP_M		9
-#define GZIP_OS_TOPS_20		10
-#define GZIP_OS_NTFS		11
-#define GZIP_OS_QDOS		12
-#define GZIP_OS_RISCOS		13
-#define GZIP_OS_UNKNOWN		255
-
-#endif /* LIB_GZIP_CONSTANTS_H */

data/ext/libdeflate/libdeflate/lib/gzip_decompress.c

@@ -1,130 +0,0 @@
-/*
- * gzip_decompress.c - decompress with a gzip wrapper
- *
- * Originally public domain; changes after 2016-09-07 are copyrighted.
- *
- * Copyright 2016 Eric Biggers
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "gzip_constants.h"
-#include "unaligned.h"
-
-#include "libdeflate.h"
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_gzip_decompress(struct libdeflate_decompressor *d,
-			   const void *in, size_t in_nbytes,
-			   void *out, size_t out_nbytes_avail,
-			   size_t *actual_out_nbytes_ret)
-{
-	const u8 *in_next = in;
-	const u8 * const in_end = in_next + in_nbytes;
-	u8 flg;
-	size_t actual_out_nbytes;
-	enum libdeflate_result result;
-
-	if (in_nbytes < GZIP_MIN_OVERHEAD)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* ID1 */
-	if (*in_next++ != GZIP_ID1)
-		return LIBDEFLATE_BAD_DATA;
-	/* ID2 */
-	if (*in_next++ != GZIP_ID2)
-		return LIBDEFLATE_BAD_DATA;
-	/* CM */
-	if (*in_next++ != GZIP_CM_DEFLATE)
-		return LIBDEFLATE_BAD_DATA;
-	flg = *in_next++;
-	/* MTIME */
-	in_next += 4;
-	/* XFL */
-	in_next += 1;
-	/* OS */
-	in_next += 1;
-
-	if (flg & GZIP_FRESERVED)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* Extra field */
-	if (flg & GZIP_FEXTRA) {
-		u16 xlen = get_unaligned_le16(in_next);
-		in_next += 2;
-
-		if (in_end - in_next < (u32)xlen + GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-
-		in_next += xlen;
-	}
-
-	/* Original file name (zero terminated) */
-	if (flg & GZIP_FNAME) {
-		while (*in_next++ != 0 && in_next != in_end)
-			;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* File comment (zero terminated) */
-	if (flg & GZIP_FCOMMENT) {
-		while (*in_next++ != 0 && in_next != in_end)
-			;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* CRC16 for gzip header */
-	if (flg & GZIP_FHCRC) {
-		in_next += 2;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* Compressed data  */
-	result = libdeflate_deflate_decompress(d, in_next,
-					in_end - GZIP_FOOTER_SIZE - in_next,
-					out, out_nbytes_avail,
-					actual_out_nbytes_ret);
-	if (result != LIBDEFLATE_SUCCESS)
-		return result;
-
-	if (actual_out_nbytes_ret)
-		actual_out_nbytes = *actual_out_nbytes_ret;
-	else
-		actual_out_nbytes = out_nbytes_avail;
-
-	in_next = in_end - GZIP_FOOTER_SIZE;
-
-	/* CRC32 */
-	if (libdeflate_crc32(0, out, actual_out_nbytes) !=
-	    get_unaligned_le32(in_next))
-		return LIBDEFLATE_BAD_DATA;
-	in_next += 4;
-
-	/* ISIZE */
-	if ((u32)actual_out_nbytes != get_unaligned_le32(in_next))
-		return LIBDEFLATE_BAD_DATA;
-
-	return LIBDEFLATE_SUCCESS;
-}

data/ext/libdeflate/libdeflate/lib/hc_matchfinder.h

@@ -1,405 +0,0 @@
-/*
- * hc_matchfinder.h - Lempel-Ziv matchfinding with a hash table of linked lists
- *
- * Originally public domain; changes after 2016-09-07 are copyrighted.
- *
- * Copyright 2016 Eric Biggers
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * ---------------------------------------------------------------------------
- *
- *				   Algorithm
- *
- * This is a Hash Chains (hc) based matchfinder.
- *
- * The main data structure is a hash table where each hash bucket contains a
- * linked list (or "chain") of sequences whose first 4 bytes share the same hash
- * code.  Each sequence is identified by its starting position in the input
- * buffer.
- *
- * The algorithm processes the input buffer sequentially.  At each byte
- * position, the hash code of the first 4 bytes of the sequence beginning at
- * that position (the sequence being matched against) is computed.  This
- * identifies the hash bucket to use for that position.  Then, this hash
- * bucket's linked list is searched for matches.  Then, a new linked list node
- * is created to represent the current sequence and is prepended to the list.
- *
- * This algorithm has several useful properties:
- *
- * - It only finds true Lempel-Ziv matches; i.e., those where the matching
- *   sequence occurs prior to the sequence being matched against.
- *
- * - The sequences in each linked list are always sorted by decreasing starting
- *   position.  Therefore, the closest (smallest offset) matches are found
- *   first, which in many compression formats tend to be the cheapest to encode.
- *
- * - Although fast running time is not guaranteed due to the possibility of the
- *   lists getting very long, the worst degenerate behavior can be easily
- *   prevented by capping the number of nodes searched at each position.
- *
- * - If the compressor decides not to search for matches at a certain position,
- *   then that position can be quickly inserted without searching the list.
- *
- * - The algorithm is adaptable to sliding windows: just store the positions
- *   relative to a "base" value that is updated from time to time, and stop
- *   searching each list when the sequences get too far away.
- *
- * ----------------------------------------------------------------------------
- *
- *				 Optimizations
- *
- * The main hash table and chains handle length 4+ matches.  Length 3 matches
- * are handled by a separate hash table with no chains.  This works well for
- * typical "greedy" or "lazy"-style compressors, where length 3 matches are
- * often only helpful if they have small offsets.  Instead of searching a full
- * chain for length 3+ matches, the algorithm just checks for one close length 3
- * match, then focuses on finding length 4+ matches.
- *
- * The longest_match() and skip_positions() functions are inlined into the
- * compressors that use them.  This isn't just about saving the overhead of a
- * function call.  These functions are intended to be called from the inner
- * loops of compressors, where giving the compiler more control over register
- * allocation is very helpful.  There is also significant benefit to be gained
- * from allowing the CPU to predict branches independently at each call site.
- * For example, "lazy"-style compressors can be written with two calls to
- * longest_match(), each of which starts with a different 'best_len' and
- * therefore has significantly different performance characteristics.
- *
- * Although any hash function can be used, a multiplicative hash is fast and
- * works well.
- *
- * On some processors, it is significantly faster to extend matches by whole
- * words (32 or 64 bits) instead of by individual bytes.  For this to be the
- * case, the processor must implement unaligned memory accesses efficiently and
- * must have either a fast "find first set bit" instruction or a fast "find last
- * set bit" instruction, depending on the processor's endianness.
- *
- * The code uses one loop for finding the first match and one loop for finding a
- * longer match.  Each of these loops is tuned for its respective task and in
- * combination are faster than a single generalized loop that handles both
- * tasks.
- *
- * The code also uses a tight inner loop that only compares the last and first
- * bytes of a potential match.  It is only when these bytes match that a full
- * match extension is attempted.
- *
- * ----------------------------------------------------------------------------
- */
-
-#include "matchfinder_common.h"
-
-#define HC_MATCHFINDER_HASH3_ORDER	15
-#define HC_MATCHFINDER_HASH4_ORDER	16
-
-#define HC_MATCHFINDER_TOTAL_HASH_LENGTH		\
-	((1UL << HC_MATCHFINDER_HASH3_ORDER) +		\
-	 (1UL << HC_MATCHFINDER_HASH4_ORDER))
-
-struct hc_matchfinder {
-
-	/* The hash table for finding length 3 matches  */
-	mf_pos_t hash3_tab[1UL << HC_MATCHFINDER_HASH3_ORDER];
-
-	/* The hash table which contains the first nodes of the linked lists for
-	 * finding length 4+ matches  */
-	mf_pos_t hash4_tab[1UL << HC_MATCHFINDER_HASH4_ORDER];
-
-	/* The "next node" references for the linked lists.  The "next node" of
-	 * the node for the sequence with position 'pos' is 'next_tab[pos]'.  */
-	mf_pos_t next_tab[MATCHFINDER_WINDOW_SIZE];
-
-}
-#ifdef _aligned_attribute
-  _aligned_attribute(MATCHFINDER_ALIGNMENT)
-#endif
-;
-
-/* Prepare the matchfinder for a new input buffer.  */
-static forceinline void
-hc_matchfinder_init(struct hc_matchfinder *mf)
-{
-	matchfinder_init((mf_pos_t *)mf, HC_MATCHFINDER_TOTAL_HASH_LENGTH);
-}
-
-static forceinline void
-hc_matchfinder_slide_window(struct hc_matchfinder *mf)
-{
-	matchfinder_rebase((mf_pos_t *)mf,
-			   sizeof(struct hc_matchfinder) / sizeof(mf_pos_t));
-}
-
-/*
- * Find the longest match longer than 'best_len' bytes.
- *
- * @mf
- *	The matchfinder structure.
- * @in_base_p
- *	Location of a pointer which points to the place in the input data the
- *	matchfinder currently stores positions relative to.  This may be updated
- *	by this function.
- * @cur_pos
- *	The current position in the input buffer relative to @in_base (the
- *	position of the sequence being matched against).
- * @best_len
- *	Require a match longer than this length.
- * @max_len
- *	The maximum permissible match length at this position.
- * @nice_len
- *	Stop searching if a match of at least this length is found.
- *	Must be <= @max_len.
- * @max_search_depth
- *	Limit on the number of potential matches to consider.  Must be >= 1.
- * @next_hashes
- *	The precomputed hash codes for the sequence beginning at @in_next.
- *	These will be used and then updated with the precomputed hashcodes for
- *	the sequence beginning at @in_next + 1.
- * @offset_ret
- *	If a match is found, its offset is returned in this location.
- *
- * Return the length of the match found, or 'best_len' if no match longer than
- * 'best_len' was found.
- */
-static forceinline u32
-hc_matchfinder_longest_match(struct hc_matchfinder * const restrict mf,
-			     const u8 ** const restrict in_base_p,
-			     const u8 * const restrict in_next,
-			     u32 best_len,
-			     const u32 max_len,
-			     const u32 nice_len,
-			     const u32 max_search_depth,
-			     u32 * const restrict next_hashes,
-			     u32 * const restrict offset_ret)
-{
-	u32 depth_remaining = max_search_depth;
-	const u8 *best_matchptr = in_next;
-	mf_pos_t cur_node3, cur_node4;
-	u32 hash3, hash4;
-	u32 next_seq3, next_seq4;
-	u32 seq4;
-	const u8 *matchptr;
-	u32 len;
-	u32 cur_pos = in_next - *in_base_p;
-	const u8 *in_base;
-	mf_pos_t cutoff;
-
-	if (cur_pos == MATCHFINDER_WINDOW_SIZE) {
-		hc_matchfinder_slide_window(mf);
-		*in_base_p += MATCHFINDER_WINDOW_SIZE;
-		cur_pos = 0;
-	}
-
-	in_base = *in_base_p;
-	cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE;
-
-	if (unlikely(max_len < 5)) /* can we read 4 bytes from 'in_next + 1'? */
-		goto out;
-
-	/* Get the precomputed hash codes.  */
-	hash3 = next_hashes[0];
-	hash4 = next_hashes[1];
-
-	/* From the hash buckets, get the first node of each linked list.  */
-	cur_node3 = mf->hash3_tab[hash3];
-	cur_node4 = mf->hash4_tab[hash4];
-
-	/* Update for length 3 matches.  This replaces the singleton node in the
-	 * 'hash3' bucket with the node for the current sequence.  */
-	mf->hash3_tab[hash3] = cur_pos;
-
-	/* Update for length 4 matches.  This prepends the node for the current
-	 * sequence to the linked list in the 'hash4' bucket.  */
-	mf->hash4_tab[hash4] = cur_pos;
-	mf->next_tab[cur_pos] = cur_node4;
-
-	/* Compute the next hash codes.  */
-	next_seq4 = load_u32_unaligned(in_next + 1);
-	next_seq3 = loaded_u32_to_u24(next_seq4);
-	next_hashes[0] = lz_hash(next_seq3, HC_MATCHFINDER_HASH3_ORDER);
-	next_hashes[1] = lz_hash(next_seq4, HC_MATCHFINDER_HASH4_ORDER);
-	prefetchw(&mf->hash3_tab[next_hashes[0]]);
-	prefetchw(&mf->hash4_tab[next_hashes[1]]);
-
-	if (best_len < 4) {  /* No match of length >= 4 found yet?  */
-
-		/* Check for a length 3 match if needed.  */
-
-		if (cur_node3 <= cutoff)
-			goto out;
-
-		seq4 = load_u32_unaligned(in_next);
-
-		if (best_len < 3) {
-			matchptr = &in_base[cur_node3];
-			if (load_u24_unaligned(matchptr) == loaded_u32_to_u24(seq4)) {
-				best_len = 3;
-				best_matchptr = matchptr;
-			}
-		}
-
-		/* Check for a length 4 match.  */
-
-		if (cur_node4 <= cutoff)
-			goto out;
-
-		for (;;) {
-			/* No length 4 match found yet.  Check the first 4 bytes.  */
-			matchptr = &in_base[cur_node4];
-
-			if (load_u32_unaligned(matchptr) == seq4)
-				break;
-
-			/* The first 4 bytes did not match.  Keep trying.  */
-			cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-			if (cur_node4 <= cutoff || !--depth_remaining)
-				goto out;
-		}
-
-		/* Found a match of length >= 4.  Extend it to its full length.  */
-		best_matchptr = matchptr;
-		best_len = lz_extend(in_next, best_matchptr, 4, max_len);
-		if (best_len >= nice_len)
-			goto out;
-		cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-		if (cur_node4 <= cutoff || !--depth_remaining)
-			goto out;
-	} else {
-		if (cur_node4 <= cutoff || best_len >= nice_len)
-			goto out;
-	}
-
-	/* Check for matches of length >= 5.  */
-
-	for (;;) {
-		for (;;) {
-			matchptr = &in_base[cur_node4];
-
-			/* Already found a length 4 match.  Try for a longer
-			 * match; start by checking either the last 4 bytes and
-			 * the first 4 bytes, or the last byte.  (The last byte,
-			 * the one which would extend the match length by 1, is
-			 * the most important.)  */
-		#if UNALIGNED_ACCESS_IS_FAST
-			if ((load_u32_unaligned(matchptr + best_len - 3) ==
-			     load_u32_unaligned(in_next + best_len - 3)) &&
-			    (load_u32_unaligned(matchptr) ==
-			     load_u32_unaligned(in_next)))
-		#else
-			if (matchptr[best_len] == in_next[best_len])
-		#endif
-				break;
-
-			/* Continue to the next node in the list.  */
-			cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-			if (cur_node4 <= cutoff || !--depth_remaining)
-				goto out;
-		}
-
-	#if UNALIGNED_ACCESS_IS_FAST
-		len = 4;
-	#else
-		len = 0;
-	#endif
-		len = lz_extend(in_next, matchptr, len, max_len);
-		if (len > best_len) {
-			/* This is the new longest match.  */
-			best_len = len;
-			best_matchptr = matchptr;
-			if (best_len >= nice_len)
-				goto out;
-		}
-
-		/* Continue to the next node in the list.  */
-		cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-		if (cur_node4 <= cutoff || !--depth_remaining)
-			goto out;
-	}
-out:
-	*offset_ret = in_next - best_matchptr;
-	return best_len;
-}
-
-/*
- * Advance the matchfinder, but don't search for matches.
- *
- * @mf
- *	The matchfinder structure.
- * @in_base_p
- *	Location of a pointer which points to the place in the input data the
- *	matchfinder currently stores positions relative to.  This may be updated
- *	by this function.
- * @cur_pos
- *	The current position in the input buffer relative to @in_base.
- * @end_pos
- *	The end position of the input buffer, relative to @in_base.
- * @next_hashes
- *	The precomputed hash codes for the sequence beginning at @in_next.
- *	These will be used and then updated with the precomputed hashcodes for
- *	the sequence beginning at @in_next + @count.
- * @count
- *	The number of bytes to advance.  Must be > 0.
- *
- * Returns @in_next + @count.
- */
-static forceinline const u8 *
-hc_matchfinder_skip_positions(struct hc_matchfinder * const restrict mf,
-			      const u8 ** const restrict in_base_p,
-			      const u8 *in_next,
-			      const u8 * const in_end,
-			      const u32 count,
-			      u32 * const restrict next_hashes)
-{
-	u32 cur_pos;
-	u32 hash3, hash4;
-	u32 next_seq3, next_seq4;
-	u32 remaining = count;
-
-	if (unlikely(count + 5 > in_end - in_next))
-		return &in_next[count];
-
-	cur_pos = in_next - *in_base_p;
-	hash3 = next_hashes[0];
-	hash4 = next_hashes[1];
-	do {
-		if (cur_pos == MATCHFINDER_WINDOW_SIZE) {
-			hc_matchfinder_slide_window(mf);
-			*in_base_p += MATCHFINDER_WINDOW_SIZE;
-			cur_pos = 0;
-		}
-		mf->hash3_tab[hash3] = cur_pos;
-		mf->next_tab[cur_pos] = mf->hash4_tab[hash4];
-		mf->hash4_tab[hash4] = cur_pos;
-
-		next_seq4 = load_u32_unaligned(++in_next);
-		next_seq3 = loaded_u32_to_u24(next_seq4);
-		hash3 = lz_hash(next_seq3, HC_MATCHFINDER_HASH3_ORDER);
-		hash4 = lz_hash(next_seq4, HC_MATCHFINDER_HASH4_ORDER);
-		cur_pos++;
-	} while (--remaining);
-
-	prefetchw(&mf->hash3_tab[hash3]);
-	prefetchw(&mf->hash4_tab[hash4]);
-	next_hashes[0] = hash3;
-	next_hashes[1] = hash4;
-
-	return in_next;
-}

data/ext/libdeflate/libdeflate/lib/lib_common.h

@@ -1,35 +0,0 @@
-/*
- * lib_common.h - internal header included by all library code
- */
-
-#ifndef LIB_LIB_COMMON_H
-#define LIB_LIB_COMMON_H
-
-#ifdef LIBDEFLATE_H
-#  error "lib_common.h must always be included before libdeflate.h"
-   /* because BUILDING_LIBDEFLATE must be set first */
-#endif
-
-#define BUILDING_LIBDEFLATE
-
-#include "common_defs.h"
-
-/*
- * Prefix with "_libdeflate_" all global symbols which are not part of the API.
- * This avoids exposing overly generic names when libdeflate is built as a
- * static library.
- *
- * Note that the chosen prefix is not really important and can be changed
- * without breaking library users.  It was just chosen so that the resulting
- * symbol names are unlikely to conflict with those from any other software.
- * Also note that this fixup has no useful effect when libdeflate is built as a
- * shared library, since these symbols are not exported.
- */
-#define SYM_FIXUP(sym)			_libdeflate_##sym
-#define aligned_malloc			SYM_FIXUP(aligned_malloc)
-#define aligned_free			SYM_FIXUP(aligned_free)
-#define deflate_get_compression_level	SYM_FIXUP(deflate_get_compression_level)
-#define _x86_cpu_features		SYM_FIXUP(_x86_cpu_features)
-#define x86_setup_cpu_features		SYM_FIXUP(x86_setup_cpu_features)
-
-#endif /* LIB_LIB_COMMON_H */