libdeflate 0.1.0

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

@@ -0,0 +1,95 @@
+/*
+ * 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

@@ -0,0 +1,45 @@
+/*
+ * 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

@@ -0,0 +1,130 @@
+/*
+ * 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

@@ -0,0 +1,405 @@
+/*
+ * 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;
+}