deflate-ruby 1.0.1 → 1.0.2

data/ext/deflate_ruby/libdeflate/scripts/checksum_benchmarks.sh

@@ -1,253 +0,0 @@
-#!/bin/bash
-
-set -eu -o pipefail
-
-__have_cpu_feature() {
-	local feature="$1"
-	local tag
-	case $ARCH in
-	arm*|aarch*)
-		tag="Features"
-		;;
-	*)
-		tag="flags"
-		;;
-	esac
-	grep -q "^$tag"$'[ \t]'"*:.*\<$feature\>" /proc/cpuinfo
-}
-
-have_cpu_features() {
-	local feature
-	for feature; do
-		__have_cpu_feature "$feature" || return 1
-	done
-}
-
-make_and_test() {
-	# Build the checksum program and tests.  Set the special test support
-	# flag to get support for LIBDEFLATE_DISABLE_CPU_FEATURES.
-	rm -rf build
-	CFLAGS="$CFLAGS -DTEST_SUPPORT__DO_NOT_USE=1" \
-		cmake -B build -G Ninja -DLIBDEFLATE_BUILD_TESTS=1 \
-		"${EXTRA_CMAKE_FLAGS[@]}" > /dev/null
-	cmake --build build > /dev/null
-
-	# Run the checksum tests, for good measure.  (This isn't actually part
-	# of the benchmarking.)
-	./build/programs/test_checksums > /dev/null
-}
-
-__do_benchmark() {
-	local impl="$1" speed
-	shift
-	local flags=("$@")
-
-	speed=$(./build/programs/checksum "${CKSUM_FLAGS[@]}" \
-		"${flags[@]}" -t "$FILE" | \
-		grep -o '[0-9]\+ MB/s' | grep -o '[0-9]\+')
-	printf "%-60s%-10s\n" "$CKSUM_NAME ($impl)" "$speed"
-}
-
-do_benchmark() {
-	local impl="$1"
-
-	CFLAGS="${EXTRA_CFLAGS[*]}" make_and_test
-	if [ "$impl" = zlib ]; then
-		__do_benchmark "$impl" "-Z"
-	else
-		__do_benchmark "libdeflate, $impl"
-		if $ENABLE_32BIT; then
-			CFLAGS="-m32 ${EXTRA_CFLAGS[*]}" make_and_test
-			__do_benchmark "libdeflate, $impl, 32-bit"
-		fi
-	fi
-}
-
-sort_by_speed() {
-	awk '{print $NF, $0}' | sort -nr | cut -f2- -d' '
-}
-
-disable_cpu_feature() {
-	LIBDEFLATE_DISABLE_CPU_FEATURES+=",$1"
-	shift
-	if (( $# > 0 )); then
-		EXTRA_CFLAGS+=("$@")
-	fi
-}
-
-cleanup() {
-	if $USING_TMPFILE; then
-		rm "$FILE"
-	fi
-}
-
-ARCH="$(uname -m)"
-USING_TMPFILE=false
-EXTRA_CMAKE_FLAGS=()
-ENABLE_32BIT=false
-
-trap cleanup EXIT
-
-longopts="help"
-longopts+=",cmake-flag:"
-longopts+=",enable-32bit"
-
-usage() {
-	echo "Usage: $0 [--cmake-flag=FLAG]... [--enable-32bit] [FILE]"
-}
-
-if ! options=$(getopt -o "" -l "$longopts" -- "$@"); then
-	usage 1>&2
-	exit 1
-fi
-eval set -- "$options"
-while (( $# >= 1 )); do
-	case "$1" in
-	--cmake-flag)
-		EXTRA_CMAKE_FLAGS+=("$2")
-		shift
-		;;
-	--enable-32bit)
-		ENABLE_32BIT=true
-		;;
-	--help)
-		usage
-		exit 0
-		;;
-	--)
-		shift
-		break
-		;;
-	*)
-		echo 1>&2 "Invalid option: '$1'"
-		usage 1>&2
-		exit 1
-		;;
-	esac
-	shift
-done
-
-if (( $# == 0 )); then
-	# Generate default test data file.
-	FILE=$(mktemp -t checksum_testdata.XXXXXXXXXX)
-	USING_TMPFILE=true
-	echo "Generating 250 MB test file: $FILE"
-	head -c 250000000 /dev/urandom > "$FILE"
-elif (( $# == 1 )); then
-	FILE="$1"
-else
-	usage 1>&2
-	exit 1
-fi
-
-cat << EOF
-Method                                                      Speed (MB/s)
-------                                                      ------------
-EOF
-
-# CRC-32
-CKSUM_NAME="CRC-32"
-CKSUM_FLAGS=()
-EXTRA_CFLAGS=()
-export LIBDEFLATE_DISABLE_CPU_FEATURES=""
-{
-case $ARCH in
-i386|x86_64)
-	if have_cpu_features vpclmulqdq pclmulqdq avx512bw avx512vl; then
-		do_benchmark "VPCLMULQDQ/AVX512/VL512"
-		disable_cpu_feature zmm
-		do_benchmark "VPCLMULQDQ/AVX512/VL256"
-		disable_cpu_feature avx512vl "-mno-avx512vl"
-		disable_cpu_feature avx512bw "-mno-avx512bw"
-	fi
-	if have_cpu_features vpclmulqdq pclmulqdq avx2; then
-		do_benchmark "VPCLMULQDQ/AVX2"
-		disable_cpu_feature vpclmulqdq "-mno-vpclmulqdq"
-	fi
-	if have_cpu_features pclmulqdq avx; then
-		do_benchmark "PCLMULQDQ/AVX"
-		disable_cpu_feature avx "-mno-avx"
-	fi
-	if have_cpu_features pclmulqdq; then
-		do_benchmark "PCLMULQDQ"
-		disable_cpu_feature pclmulqdq "-mno-pclmul"
-	fi
-	;;
-aarch*)
-	EXTRA_CFLAGS=("-march=armv8-a")
-	if have_cpu_features pmull crc32 sha3; then
-		do_benchmark "pmullx12_crc_eor3"
-		disable_cpu_feature sha3
-	fi
-	if have_cpu_features pmull crc32; then
-		do_benchmark "pmullx12_crc"
-		disable_cpu_feature prefer_pmull
-		do_benchmark "crc_pmullcombine"
-	fi
-	if have_cpu_features crc32; then
-		do_benchmark "crc"
-		disable_cpu_feature crc32
-	fi
-	if have_cpu_features pmull; then
-		do_benchmark "pmull4x"
-		disable_cpu_feature pmull
-	fi
-	;;
-esac
-do_benchmark "generic"
-do_benchmark "zlib"
-} | sort_by_speed
-
-# Adler-32
-CKSUM_NAME="Adler-32"
-CKSUM_FLAGS=(-A)
-EXTRA_CFLAGS=()
-export LIBDEFLATE_DISABLE_CPU_FEATURES=""
-echo
-{
-case $ARCH in
-i386|x86_64)
-	if have_cpu_features avx512bw avx512_vnni; then
-		do_benchmark "AVX512VNNI/VL512"
-		disable_cpu_feature zmm
-		if have_cpu_features avx512vl; then
-			do_benchmark "AVX512VNNI/VL256"
-		fi
-		disable_cpu_feature avx512_vnni "-mno-avx512vnni"
-		disable_cpu_feature avx512bw "-mno-avx512bw"
-	fi
-	if have_cpu_features avx2 avx_vnni; then
-		do_benchmark "AVX-VNNI"
-		disable_cpu_feature avx_vnni "-mno-avxvnni"
-	fi
-	if have_cpu_features avx2; then
-		do_benchmark "AVX2"
-		disable_cpu_feature avx2 "-mno-avx2"
-	fi
-	if have_cpu_features sse2; then
-		do_benchmark "SSE2"
-		disable_cpu_feature sse2 "-mno-sse2"
-	fi
-	;;
-arm*)
-	if have_cpu_features neon; then
-		do_benchmark "NEON"
-		disable_cpu_feature neon "-mfpu=vfpv3"
-	fi
-	;;
-aarch*)
-	EXTRA_CFLAGS=("-march=armv8-a")
-	if have_cpu_features asimd asimddp; then
-		do_benchmark "DOTPROD"
-		disable_cpu_feature dotprod
-	fi
-	if have_cpu_features asimd; then
-		do_benchmark "NEON"
-		disable_cpu_feature neon
-		EXTRA_CFLAGS=("-march=armv8-a+nosimd")
-	fi
-	;;
-esac
-do_benchmark "generic"
-do_benchmark "zlib"
-} | sort_by_speed

data/ext/deflate_ruby/libdeflate/scripts/cmake-helper.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-# This script ensures that the 'build' directory has been created and configured
-# with the given CMake options and environment.
-
-set -e
-
-TOPDIR="$(dirname "$0")"/..
-BUILDDIR="$TOPDIR"/build
-
-flags=$(env; echo "@CMAKEOPTS@=$*")
-if [ "$flags" != "$(cat "$BUILDDIR"/.flags 2>/dev/null || true)" ]; then
-	rm -rf "$BUILDDIR"/CMakeCache.txt "$BUILDDIR"/CMakeFiles
-	mkdir -p "$BUILDDIR"
-	cmake -S "$TOPDIR" -B "$BUILDDIR" "$@"
-	echo "$flags" > "$BUILDDIR"/.flags
-fi

data/ext/deflate_ruby/libdeflate/scripts/deflate_benchmarks.sh

@@ -1,119 +0,0 @@
-#!/bin/bash
-
-set -eu -o pipefail
-topdir="$(dirname "$0")/.."
-tmpfile=$(mktemp)
-trap 'rm -f $tmpfile' EXIT
-
-run_benchmark()
-{
-	local best_ctime=1000000000
-	local i
-
-	for i in $(seq "$NUM_ITERATIONS"); do
-		"$@" > "$tmpfile"
-		csize=$(awk '/Compressed/{print $4}' "$tmpfile")
-		ctime=$(awk '/Compression time/{print $3}' "$tmpfile")
-		if (( ctime <  best_ctime )); then
-			best_ctime=$ctime
-		fi
-		: "$i" # make shellcheck happy
-	done
-	CSIZE=$csize
-	CTIME=$best_ctime
-}
-
-multifile()
-{
-	local file results cmd best em
-
-	NUM_ITERATIONS=1
-
-	echo "File | zlib -6 | zlib -9 | libdeflate -6 | libdeflate -9 | libdeflate -12"
-	echo "-----|---------|---------|---------------|---------------|---------------"
-
-	for file in "$@"; do
-		echo -n "$(basename "$file")"
-		results=()
-		cmd=("$topdir/build/programs/benchmark"
-		     -s"$(stat -c "%s" "$file")" "$file")
-		run_benchmark "${cmd[@]}" -Y -6
-		results+=("$CSIZE")
-		run_benchmark "${cmd[@]}" -Y -6
-		results+=("$CSIZE")
-		run_benchmark "${cmd[@]}" -6
-		results+=("$CSIZE")
-		run_benchmark "${cmd[@]}" -9
-		results+=("$CSIZE")
-		run_benchmark "${cmd[@]}" -12
-		results+=("$CSIZE")
-		best=2000000000
-		for result in "${results[@]}"; do
-			if (( result < best)); then
-				best=$result
-			fi
-		done
-		for result in "${results[@]}"; do
-			if (( result == best )); then
-				em="**"
-			else
-				em=""
-			fi
-			echo -n " | ${em}${result}${em}"
-		done
-		echo
-	done
-}
-
-single_file()
-{
-	local file=$1
-	local usize args
-	local include_old=false
-
-	usize=$(stat -c "%s" "$file")
-	: ${NUM_ITERATIONS:=3}
-
-	if [ -e "$topdir/benchmark-old" ]; then
-		include_old=true
-	fi
-	echo -n "Level | libdeflate (new) "
-	if $include_old; then
-		echo -n "| libdeflate (old) "
-	fi
-	echo "| zlib"
-	echo -n "------|------------------"
-	if $include_old; then
-		echo -n "|------------------"
-	fi
-	echo "|-----"
-	for level in {1..12}; do
-		echo -n "$level"
-		args=("$file" -s "$usize" "-$level")
-
-		run_benchmark "$topdir/build/programs/benchmark" "${args[@]}"
-		echo -n " | $CSIZE / $CTIME"
-
-		if $include_old; then
-			run_benchmark "$topdir/benchmark-old" "${args[@]}"
-			echo -n " | $CSIZE / $CTIME"
-		fi
-
-		if (( level > 9 )); then
-			echo -n " | N/A"
-		else
-			run_benchmark "$topdir/build/programs/benchmark" \
-				      "${args[@]}" -Y
-			echo -n " | $CSIZE / $CTIME"
-		fi
-		echo
-	done
-}
-
-if (( $# > 1 )); then
-	multifile "$@"
-elif (( $# == 1 )); then
-	single_file "$@"
-else
-	echo 1>&2 "Usage: $0 FILE..."
-fi

data/ext/deflate_ruby/libdeflate/scripts/exec_tests.sh

@@ -1,38 +0,0 @@
-#!/bin/sh
-#
-# Helper script used by run_tests.sh and android_tests.sh,
-# not intended to be run directly
-#
-
-set -eu
-
-DIR=${1:-.}
-
-cd "$DIR"
-
-run_cmd() {
-	echo "$WRAPPER $*"
-	$WRAPPER "$@" > /dev/null
-}
-
-for prog in ./test_*; do
-	run_cmd "$prog"
-done
-
-for format in '' '-g' '-z'; do
-	for ref_impl in '' '-Y' '-Z'; do
-		run_cmd ./benchmark $format $ref_impl "$TESTDATA"
-	done
-done
-for level in 0 1 3 7 9; do
-	for ref_impl in '' '-Y'; do
-		run_cmd ./benchmark -$level $ref_impl "$TESTDATA"
-	done
-done
-for level in 0 1 3 7 9 12; do
-	for ref_impl in '' '-Z'; do
-		run_cmd ./benchmark -$level $ref_impl "$TESTDATA"
-	done
-done
-
-echo "exec_tests finished successfully" # Needed for 'adb shell'

data/ext/deflate_ruby/libdeflate/scripts/gen-release-archives.sh

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-set -eu -o pipefail
-
-# This script generates source and binary archives that should be posted for
-# each new release of libdeflate.
-
-prefix="libdeflate-$(git describe HEAD | sed 's/^v//')"
-
-# Generate source code archive libdeflate-*.tar.gz
-tarball="${prefix}.tar.gz"
-echo "Generating $tarball"
-git archive --format=tar --prefix="${prefix}/" HEAD \
-	| libdeflate-gzip -12 > "$tarball"
-
-# Generate Windows binary releases libdeflate-*-windows-*-bin.zip
-for arch in 'i686' 'x86_64'; do
-	dir=${prefix}-windows-${arch}-bin
-	zipfile="${dir}.zip"
-	echo "Generating $zipfile"
-	rm -rf build "$dir" "$zipfile"
-	CFLAGS="-Werror" ${arch}-w64-mingw32-cmake -B build -G Ninja \
-		-DLIBDEFLATE_BUILD_TESTS=1 > /dev/null
-	cmake --build build > /dev/null
-	mkdir "$dir"
-	cp libdeflate.h build/libdeflate.{dll,dll.a,a} \
-		build/programs/{benchmark,checksum}.exe "$dir"
-	cp build/programs/libdeflate-gzip.exe "$dir"/gzip.exe
-	cp build/programs/libdeflate-gzip.exe "$dir"/gunzip.exe
-	${arch}-w64-mingw32-strip "$dir"/libdeflate.dll "$dir"/*.exe
-	for file in COPYING NEWS.md README.md; do
-		sed < $file > "$dir/${file}.txt" -e 's/$/\r/g'
-	done
-	(cd "$dir" && zip -q -r "../${zipfile}" .)
-done
-
-echo "Successfully generated release archives"

data/ext/deflate_ruby/libdeflate/scripts/gen_bitreverse_tab.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-#
-# This script computes a table that maps each byte to its bitwise reverse.
-
-def reverse_byte(v):
-    return sum(1 << (7 - bit) for bit in range(8) if (v & (1 << bit)) != 0)
-
-tab = [reverse_byte(v) for v in range(256)]
-
-print('static const u8 bitreverse_tab[256] = {')
-for i in range(0, len(tab), 8):
-    print('\t', end='')
-    for j, v in enumerate(tab[i:i+8]):
-        print(f'0x{v:02x},', end='')
-        if j == 7:
-            print('')
-        else:
-            print(' ', end='')
-print('};')

data/ext/deflate_ruby/libdeflate/scripts/gen_crc32_multipliers.c

@@ -1,199 +0,0 @@
-/*
- * gen_crc32_multipliers.c
- *
- * 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.
- */
-
-/*
- * This program computes the constant multipliers needed for "folding" over
- * various distances with the gzip CRC-32.  Each such multiplier is x^D mod G(x)
- * for some distance D, in bits, over which the folding is occurring.
- *
- * Folding works as follows: let A(x) be a polynomial (possibly reduced
- * partially or fully mod G(x)) for part of the message, and let B(x) be a
- * polynomial (possibly reduced partially or fully mod G(x)) for a later part of
- * the message.  The unreduced combined polynomial is A(x)*x^D + B(x), where D
- * is the number of bits separating the two parts of the message plus len(B(x)).
- * Since mod G(x) can be applied at any point, x^D mod G(x) can be precomputed
- * and used instead of x^D unreduced.  That allows the combined polynomial to be
- * computed relatively easily in a partially-reduced form A(x)*(x^D mod G(x)) +
- * B(x), with length max(len(A(x)) + 31, len(B(x))).  This does require doing a
- * polynomial multiplication (carryless multiplication).
- *
- * "Folding" in this way can be used for the entire CRC computation except the
- * final reduction to 32 bits; this works well when CPU support for carryless
- * multiplication is available.  It can also be used to combine CRCs of
- * different parts of the message that were computed using a different method.
- *
- * Note that the gzip CRC-32 uses bit-reversed polynomials.  I.e., the low order
- * bits are really the high order polynomial coefficients.
- */
-
-#include <inttypes.h>
-#include <stdio.h>
-
-#include "../common_defs.h"
-
-/* The generator polynomial G(x) for the gzip CRC-32 */
-#define CRCPOLY		0xEDB88320 /* G(x) without x^32 term */
-#define CRCPOLY_FULL	(((u64)CRCPOLY << 1) | 1) /* G(x) */
-
-/* Compute x^D mod G(x) */
-static u32
-compute_xD_modG(size_t D)
-{
-	/* Start with x^0 mod G(x) */
-	u32 remainder = 0x80000000;
-
-	/* Each iteration, 'remainder' becomes x^i mod G(x) */
-	for (size_t i = 1; i <= D; i++)
-		remainder = (remainder >> 1) ^ ((remainder & 1) ? CRCPOLY : 0);
-
-	/* Now 'remainder' is x^D mod G(x) */
-	return remainder;
-}
-
-/* Compute floor(x^64 / G(x)) */
-static u64
-compute_x64_div_G(void)
-{
-	u64 quotient = 0;
-	u64 dividend = 0x1;
-
-	for (int i = 0; i < 64 - 32 + 1; i++) {
-		if ((dividend >> i) & 1) {
-			quotient |= (u64)1 << i;
-			dividend ^= CRCPOLY_FULL << i;
-		}
-	}
-
-	return quotient;
-}
-
-static void
-gen_vec_folding_constants(void)
-{
-	/*
-	 * Compute the multipliers needed for CRC-32 folding with carryless
-	 * multiplication instructions that operate on the 64-bit halves of
-	 * 128-bit segments.  Using the terminology from earlier, for each 64-bit
-	 * fold len(A(x)) = 64, and len(B(x)) = 95 since a 64-bit polynomial
-	 * multiplied by a 32-bit one produces a 95-bit one.  When A(x) is the
-	 * low order polynomial half of a 128-bit segments (high order physical
-	 * half), the separation between the message parts is the total length
-	 * of the 128-bit segments separating the values.  When A(x) is the high
-	 * order polynomial half, the separation is 64 bits greater.
-	 */
-	for (int i = 1; i <= 32; i++) {
-		const int sep_lo = 128 * (i - 1);
-		const int sep_hi = sep_lo + 64;
-		const int len_B = 95;
-		int D;
-
-		/* A(x) = high 64 polynomial bits (low 64 physical bits) */
-		D = sep_hi + len_B;
-		printf("#define CRC32_X%d_MODG 0x%08"PRIx32" /* x^%d mod G(x) */\n",
-		       D, compute_xD_modG(D), D);
-
-		/* A(x) = low 64 polynomial bits (high 64 physical bits) */
-		D = sep_lo + len_B;
-		printf("#define CRC32_X%d_MODG 0x%08"PRIx32" /* x^%d mod G(x) */\n",
-		       D, compute_xD_modG(D), D);
-		printf("\n");
-	}
-
-	/* Multiplier for final 96 => 64 bit fold */
-	printf("#define CRC32_X63_MODG 0x%08"PRIx32" /* x^63 mod G(x) */\n",
-	       compute_xD_modG(63));
-
-	/*
-	 * Constants for final 64 => 32 bit reduction.  These constants are the
-	 * odd ones out, as this final reduction step can't use the regular CRC
-	 * folding described above.  It uses Barrett reduction instead.
-	 */
-	printf("#define CRC32_BARRETT_CONSTANT_1 0x%016"PRIx64"ULL /* floor(x^64 / G(x)) */\n",
-	       compute_x64_div_G());
-	printf("#define CRC32_BARRETT_CONSTANT_2 0x%016"PRIx64"ULL /* G(x) */\n",
-	       CRCPOLY_FULL);
-	printf("#define CRC32_BARRETT_CONSTANTS { CRC32_BARRETT_CONSTANT_1, CRC32_BARRETT_CONSTANT_2 }\n");
-}
-
-/* Multipliers for combining the CRCs of separate chunks */
-static void
-gen_chunk_constants(void)
-{
-	const size_t num_chunks = 4;
-	const size_t table_len = 129;
-	const size_t min_chunk_len = 128;
-
-	printf("#define CRC32_NUM_CHUNKS %zu\n", num_chunks);
-	printf("#define CRC32_MIN_VARIABLE_CHUNK_LEN %zuUL\n", min_chunk_len);
-	printf("#define CRC32_MAX_VARIABLE_CHUNK_LEN %zuUL\n",
-	       (table_len - 1) * min_chunk_len);
-	printf("\n");
-	printf("/* Multipliers for implementations that use a variable chunk length */\n");
-	printf("static const u32 crc32_mults_for_chunklen[][CRC32_NUM_CHUNKS - 1] MAYBE_UNUSED = {\n");
-	printf("\t{ 0 /* unused row */ },\n");
-	for (size_t i = 1; i < table_len; i++) {
-		const size_t chunk_len = i*min_chunk_len;
-
-		printf("\t/* chunk_len=%zu */\n", chunk_len);
-		printf("\t{ ");
-		for (size_t j = num_chunks - 1; j >= 1; j--) {
-			const size_t D = (j * 8 * chunk_len) - 33;
-
-			printf("0x%08"PRIx32" /* x^%zu mod G(x) */, ",
-			       compute_xD_modG(D), D);
-		}
-		printf("},\n");
-	}
-	printf("};\n");
-	printf("\n");
-
-	printf("/* Multipliers for implementations that use a large fixed chunk length */\n");
-	const size_t fixed_chunk_len = 32768;
-	printf("#define CRC32_FIXED_CHUNK_LEN %zuUL\n", fixed_chunk_len);
-	for (int j = 1; j < num_chunks; j++) {
-		const size_t D = (j * 8 * fixed_chunk_len) - 33;
-
-		printf("#define CRC32_FIXED_CHUNK_MULT_%d 0x%08"PRIx32" /* x^%zu mod G(x) */\n",
-		       j, compute_xD_modG(D), D);
-	}
-}
-
-int
-main(void)
-{
-	printf("/*\n"
-	       " * crc32_multipliers.h - constants for CRC-32 folding\n"
-	       " *\n"
-	       " * THIS FILE WAS GENERATED BY gen_crc32_multipliers.c.  DO NOT EDIT.\n"
-	       " */\n"
-	       "\n");
-
-	gen_vec_folding_constants();
-	printf("\n");
-	gen_chunk_constants();
-	return 0;
-}