Unroll wildCopy32 into wildCopy64 #1262

Workflow file for this run

.github/workflows/ci.yml at 1913714

	# For details, see README.md in this directory.

	###############################################################
	# C compilers
	#
	# - gcc
	# - clang
	#
	# Known Issue
	# - All test cases which described as 'fail' must be fixed and replaced with 'true'.
	# - gcc-11 (x32, x86) : "../lib/lz4hc.c:148: LZ4HC_countBack: Assertion `(size_t)(match - mMin) < (1U<<31)' failed."
	# - all clangs (x32, x86) : "../lib/lz4hc.c:282: int LZ4HC_InsertAndGetWiderMatch(...): Assertion `matchPtr >= lowPrefixPtr' failed."
	#
	name: lz4 CI
	on: [push, pull_request]
	permissions:
	contents: read

	concurrency:
	cancel-in-progress: true
	group: ${{ github.workflow }}-${{ github.head_ref }}

	jobs:
	lz4-c-compilers:
	name: CC=${{ matrix.cc }}, ${{ matrix.os }}
	strategy:
	fail-fast: false # 'false' means Don't stop matrix workflows even if some matrix failed.
	matrix:
	include: [
	# You can access the following values via ${{ matrix.??? }}
	#
	# pkgs : apt-get package names. It can include multiple package names which are delimited by space.
	# cc : C compiler executable.
	# cxx : C++ compiler executable for targets `cxxtest` and `ctocxxtest`.
	# x32 : Set 'true' if compiler supports x32. Otherwise, set 'false'.
	# Set 'fail' if it supports x32 but fails for now. 'fail' cases must be removed.
	# x86 : Set 'true' if compiler supports x86 (-m32). Otherwise, set 'false'.
	# Set 'fail' if it supports x86 but fails for now. 'fail' cases must be removed.
	# cxxtest : Set 'true' if it can be compiled as C++ code. Otherwise, set 'false'.
	# freestanding : Set 'true' if it can be compiled and execute freestanding code. Otherwise, set 'false'.
	# Usually, it requires Linux, x86_64 and gcc/g++.
	# os : GitHub Actions YAML workflow label. See https://github.com/actions/virtual-environments#available-environments

	# cc
	{ pkgs: '', cc: cc, cxx: c++, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-latest, },

	# gcc
	{ pkgs: '', cc: gcc, cxx: g++, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-latest, },
	{ pkgs: 'gcc-13 g++-13 lib32gcc-13-dev libx32gcc-13-dev', cc: gcc-13, cxx: g++-13, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-22.04, },
	{ pkgs: 'gcc-12 g++-12 lib32gcc-12-dev libx32gcc-12-dev', cc: gcc-12, cxx: g++-12, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-22.04, },
	{ pkgs: 'gcc-11 g++-11 lib32gcc-11-dev libx32gcc-11-dev', cc: gcc-11, cxx: g++-11, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-22.04, },
	{ pkgs: 'gcc-10 g++-10 lib32gcc-10-dev libx32gcc-10-dev', cc: gcc-10, cxx: g++-10, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-22.04, },
	{ pkgs: 'gcc-9 g++-9 lib32gcc-9-dev libx32gcc-9-dev', cc: gcc-9, cxx: g++-9, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-22.04, },
	{ pkgs: 'gcc-8 g++-8 lib32gcc-8-dev libx32gcc-8-dev', cc: gcc-8, cxx: g++-8, x32: 'true', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-20.04, },
	{ pkgs: 'gcc-7 g++-7 lib32gcc-7-dev libx32gcc-7-dev', cc: gcc-7, cxx: g++-7, x32: 'true', x86: 'true', cxxtest: 'true', freestanding: 'true', os: ubuntu-20.04, },

	# clang
	{ pkgs: 'lib32gcc-13-dev libx32gcc-13-dev', cc: clang, cxx: clang++, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-latest, },
	{ pkgs: 'clang-15 lib32gcc-13-dev libx32gcc-13-dev', cc: clang-15, cxx: clang++-15, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-22.04, },
	{ pkgs: 'clang-14 lib32gcc-13-dev libx32gcc-13-dev', cc: clang-14, cxx: clang++-14, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-22.04, },
	{ pkgs: 'clang-13 lib32gcc-13-dev libx32gcc-13-dev', cc: clang-13, cxx: clang++-13, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-22.04, },
	{ pkgs: 'clang-12 lib32gcc-13-dev libx32gcc-13-dev', cc: clang-12, cxx: clang++-12, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-22.04, },
	{ pkgs: 'clang-11 lib32gcc-12-dev libx32gcc-12-dev', cc: clang-11, cxx: clang++-11, x32: 'false', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-22.04, },
	{ pkgs: 'clang-10 lib32gcc-11-dev libx32gcc-11-dev', cc: clang-10, cxx: clang++-10, x32: 'fail', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-20.04, },
	{ pkgs: 'clang-9 lib32gcc-11-dev libx32gcc-11-dev', cc: clang-9, cxx: clang++-9, x32: 'fail', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-20.04, },
	{ pkgs: 'clang-8 lib32gcc-11-dev libx32gcc-11-dev', cc: clang-8, cxx: clang++-8, x32: 'fail', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-20.04, },
	{ pkgs: 'clang-7 lib32gcc-7-dev libx32gcc-7-dev', cc: clang-7, cxx: clang++-7, x32: 'fail', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-20.04, },
	{ pkgs: 'clang-6.0 lib32gcc-11-dev libx32gcc-11-dev', cc: clang-6.0, cxx: clang++-6.0, x32: 'fail', x86: 'true', cxxtest: 'true', freestanding: 'false', os: ubuntu-20.04, },
	]

	runs-on: ${{ matrix.os }}
	env: # Set environment variables
	# We globally set CC and CXX to improve compatibility
	CC: ${{ matrix.cc }}
	CXX: ${{ matrix.cxx }}
	FIXME__LZ4_CI_IGNORE : ' echo Error. But we ignore it for now.'
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib
	sudo apt-get install ${{ matrix.pkgs }}

	- name: Environment info
	run: \|
	echo && type $CC && which $CC && $CC --version
	echo && type $CXX && which $CXX && $CXX --version

	- name: make
	if: always()
	run: make -j V=1

	- name: install test
	if: always()
	run: make -C tests test-install V=1

	- name: make all
	if: always()
	run: make clean; CFLAGS="-Werror -O0" make -j all V=1

	- name: make c_standards (C90)
	if: always()
	run: make clean; make -j c_standards_c90 V=1

	- name: make c_standards (C11)
	if: always()
	run: make clean; make -j c_standards_c11 V=1

	- name: c lib for c++ program
	if: ${{ matrix.cxxtest == 'true' }}
	run: make clean; make -j ctocxxtest V=1

	- name: compiled as c++ source
	if: ${{ matrix.cxxtest == 'true' }}
	run: make clean; make -j cxxtest V=1

	- name: make test-freestanding
	if: ${{ matrix.freestanding == 'true' }}
	run: make clean; make test-freestanding V=1

	- name: make -C programs default -D_FORTIFY_SOURCE=2
	if: always()
	run: make clean; CFLAGS='-fPIC' LDFLAGS='-pie -fPIE -D_FORTIFY_SOURCE=2' make -j -C programs default V=1

	- name: make -C tests test-lz4
	if: always()
	run: make clean; make -j V=1 -C tests test-lz4

	- name: make -C tests test CFLAGS='-mx32'
	if: ${{ matrix.x32 == 'true' }}
	run: make clean; CFLAGS='-mx32' make -j -C tests test V=1

	- name: make -C tests test-lz4c32
	if: ${{ matrix.x86 == 'true' }}
	run: make clean; CFLAGS='-Werror -O1' make -j -C tests test-lz4c32 V=1


	###############################################################
	# #
	# Remove this block when we relevant tests run properly #
	# #

	- name: make -C tests test CFLAGS='-mx32' \|\| echo Ignore failure for now.
	if: ${{ matrix.x32 == 'fail' }}
	run: make clean; CFLAGS='-mx32' make -C tests test V=1 \|\| $FIXME__LZ4_CI_IGNORE

	# #
	###############################################################



	###############################################################
	# LZ4 self tests
	#
	# - Fullbench
	# - Fuzzer
	# - LZ4 Frame
	# - LZ4 versions
	# - Custom LZ4_DISTANCE_MAX
	#
	lz4-benchmark:
	name: Fullbench
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib

	- name: test-lz4
	run: make -j -C tests test-lz4 V=1

	- name: test-lz4c
	run: make -j -C tests test-lz4c V=1

	- name: test-lz4c32
	run: make -j -C tests test-lz4c32 V=1

	- name: test-fullbench
	run: make -j -C tests test-fullbench V=1

	- name: test-fullbench32
	run: make -j -C tests test-fullbench32 V=1


	lz4-fuzzer:
	name: Fuzzer test
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib

	- name: setup
	run: sudo sysctl -w vm.mmap_min_addr=4096

	- name: fuzzer
	run: make -j -C tests test-fuzzer V=1

	- name: fuzzer32
	run: make -C tests test-fuzzer32 V=1


	lz4-standard-makefile-variables:
	name: LZ4 Makefile - support for standard variables
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: make standard_variables
	run: make standard_variables V=1


	lz4-versions:
	name: LZ4 versions test
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib

	- name: versionsTest
	run: make -j -C tests versionsTest V=1


	lz4-abi:
	name: LZ4 inter-versions ABI compatibility test
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib

	- name: abiTests
	run: make -j -C tests abiTests V=1


	lz4-frame:
	name: LZ4 frame test
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib

	- name: LZ4 frame test
	run: make -j -C tests test-frametest V=1

	- name: LZ4 frame test (32-bit)
	run: make -j -C tests test-frametest32 V=1

	lz4-memory-usage:
	name: test different values of LZ4_MEMORY_USAGE
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: LZ4_MEMORY_USAGE
	run: make V=1 -C tests test-compile-with-lz4-memory-usage

	# Custom LZ4_DISTANCE_MAX ; lz4-wlib (CLI linked to dynamic library); LZ4_USER_MEMORY_FUNCTIONS
	lz4-custom-distance:
	name: Custom LZ4_DISTANCE_MAX
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: custom LZ4_DISTANCE_MAX; test LZ4_USER_MEMORY_FUNCTIONS
	run: \|
	CPPFLAGS='-DLZ4_DISTANCE_MAX=8000' make V=1 check
	make clean
	make -C programs lz4-wlib V=1
	make clean
	make -C tests fullbench-wmalloc V=1 # test LZ4_USER_MEMORY_FUNCTIONS
	make clean
	CC="c++ -Wno-deprecated" make -C tests fullbench-wmalloc V=1 # stricter function signature check

	# test block device compression #1086
	lz4cli-block-device:
	name: Test lz4 compression on a block device
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: create a block device, compress it with lz4 # alternative : blindly use /dev/loop0, seems to always exist
	run: \|
	make lz4
	dd if=/dev/zero of=full0.img bs=2M count=1
	BLOCK_DEVICE=$(sudo losetup --show -fP full0.img)
	sudo chmod 666 $BLOCK_DEVICE
	./lz4 -v $BLOCK_DEVICE -c > /dev/null
	sudo losetup -d $BLOCK_DEVICE
	rm full0.img


	###############################################################
	# Check tools
	#
	# - cppcheck
	# - scan-build
	# - valgrind
	# - ubsan
	# - asan
	# - unicode-lint
	# - build examples
	#
	lz4-cppcheck:
	name: make cppcheck
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install cppcheck

	- name: Environment info
	run: echo && type cppcheck && which cppcheck && cppcheck --version

	- name: cppcheck
	# This test script ignores the exit code of cppcheck.
	# See known issues in README.md.
	run: make V=1 clean cppcheck \|\| echo There are some cppcheck reports but we ignore it.


	lz4-scan-build:
	name: make staticAnalyze
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install clang-tools

	- name: Environment info
	run: \|
	echo && type gcc && which gcc && gcc --version
	echo && type clang && which clang && clang --version
	echo && type scan-build && which scan-build # scan-build doesn't have any --version equivalent option
	echo && type make && which make && make -v
	echo && cat /proc/cpuinfo \|\| echo /proc/cpuinfo is not present

	- name: make staticAnalyze
	run: make V=1 clean staticAnalyze


	lz4-valgrind:
	name: valgrind
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install valgrind

	- name: Environment info
	run: \|
	echo && type cc && which cc && cc --version
	echo && type valgrind && which valgrind && valgrind --version

	- name: valgrind
	run: make V=1 -C tests test-mem


	lz4-ubsan-x64:
	name: Linux x64 ubsan
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: ubsan
	run: \|
	make clean
	make V=1 usan


	lz4-ubsan-x86:
	name: Linux x86 ubsan
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib
	sudo apt-get install lib32gcc-11-dev

	- name: ubsan32
	run: \|
	make clean
	CC=clang make V=1 usan32


	lz4-asan-x64:
	name: Linux x64 ASAN
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: setup
	run: sudo sysctl -w vm.mmap_min_addr=4096

	- name: check lz4
	run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j check V=1

	- name: frametest
	run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j -C tests test-frametest V=1

	- name: fuzzer
	run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j -C tests test-fuzzer V=1

	lz4-msan-x64:
	name: Linux x64 MSAN
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: check lz4
	run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j check V=1

	- name: frametest
	run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j -C tests test-frametest V=1

	- name: fuzzer
	run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j -C tests test-fuzzer V=1

	lz4-tsan-x64:
	name: Linux x64 TSAN
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: lz4 cli
	run: make clean; CC=clang CFLAGS=-fsanitize=thread LDFLAGS=-fsanitize=thread make -j -C tests test-lz4 V=1


	unicode-lint:
	name: lint unicode in ./lib/, ./tests/ and ./programs/
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: unicode lint
	run: bash ./tests/unicode_lint.sh

	lz4-examples:
	name: make examples
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: apt-get install
	run: \|
	sudo apt-get update

	- name: Environment info
	run: \|
	echo && type cc && which cc && cc --version
	echo && type c++ && which c++ && c++ --version

	- name: examples
	run: make V=1 clean examples

	# lasts ~8mn
	oss-fuzz:
	runs-on: ubuntu-latest
	strategy:
	fail-fast: false
	matrix:
	sanitizer: [address, undefined, memory]
	steps:
	- name: Build Fuzzers (${{ matrix.sanitizer }})
	id: build
	uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
	with:
	oss-fuzz-project-name: 'lz4'
	dry-run: false
	sanitizer: ${{ matrix.sanitizer }}
	- name: Run Fuzzers (${{ matrix.sanitizer }})
	uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
	with:
	oss-fuzz-project-name: 'lz4'
	fuzz-seconds: 300
	dry-run: false
	sanitizer: ${{ matrix.sanitizer }}
	- name: Upload Crash
	uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # https://github.com/actions/upload-artifact v4.3.3
	if: failure() && steps.build.outcome == 'success'
	with:
	name: ${{ matrix.sanitizer }}-artifacts
	path: ./out/artifacts



	###############################################################
	# Platforms
	#
	# - QEMU (ARM, ARM64, PPC, PPC64LE, S390X)
	# - macOS
	# - Windows
	#

	# QEMU
	# All tests use QEMU (static) and gcc cross compiler.
	#
	lz4-qemu-platforms:
	name: QEMU ${{ matrix.type }}
	strategy:
	fail-fast: false # 'false' means Don't stop matrix workflows even if some matrix instance failed.
	matrix:
	include: [
	# You can access the following values via ${{ matrix.??? }}
	# type : Architecture type for `if:` statement.
	# pkgs : apt-get package names. You can include multiple packages which are delimited by space.
	# xcc : gcc cross C compiler executable.
	# xemu : QEMU static emulator executable.
	# os : GitHub Actions YAML workflow label. See https://github.com/actions/virtual-environments#available-environments

	{ type: ARM, pkgs: 'qemu-system-arm gcc-arm-linux-gnueabi', xcc: arm-linux-gnueabi-gcc, xemu: qemu-arm-static, os: ubuntu-latest, },
	{ type: ARM64, pkgs: 'qemu-system-arm gcc-aarch64-linux-gnu', xcc: aarch64-linux-gnu-gcc, xemu: qemu-aarch64-static, os: ubuntu-latest, },
	{ type: PPC, pkgs: 'qemu-system-ppc gcc-powerpc-linux-gnu', xcc: powerpc-linux-gnu-gcc, xemu: qemu-ppc-static, os: ubuntu-latest, },
	{ type: PPC64LE, pkgs: 'qemu-system-ppc gcc-powerpc64le-linux-gnu', xcc: powerpc64le-linux-gnu-gcc, xemu: qemu-ppc64le-static, os: ubuntu-latest, },
	{ type: S390X, pkgs: 'qemu-system-s390x gcc-s390x-linux-gnu', xcc: s390x-linux-gnu-gcc, xemu: qemu-s390x-static, os: ubuntu-latest, },
	{ type: MIPS, pkgs: 'qemu-system-mips gcc-mips-linux-gnu', xcc: mips-linux-gnu-gcc, xemu: qemu-mips-static, os: ubuntu-latest, },
	{ type: M68K, pkgs: 'qemu-system-m68k gcc-m68k-linux-gnu', xcc: m68k-linux-gnu-gcc, xemu: qemu-m68k-static, os: ubuntu-latest, },
	{ type: RISC-V, pkgs: 'qemu-system-riscv64 gcc-riscv64-linux-gnu', xcc: riscv64-linux-gnu-gcc, xemu: qemu-riscv64-static, os: ubuntu-latest, },
	{ type: SPARC, pkgs: 'qemu-system-sparc gcc-sparc64-linux-gnu', xcc: sparc64-linux-gnu-gcc, xemu: qemu-sparc64-static, os: ubuntu-20.04, },
	]

	runs-on: ${{ matrix.os }}
	env: # Set environment variables
	XCC: ${{ matrix.xcc }}
	XEMU: ${{ matrix.xemu }}
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: apt-get install
	run: \|
	sudo apt-get update
	sudo apt-get install gcc-multilib
	sudo apt-get install qemu-utils qemu-user-static
	sudo apt-get install ${{ matrix.pkgs }}

	- name: Environment info
	run: \|
	echo && type $XCC && which $XCC && $XCC --version
	echo && $XCC -v # Show built-in specs
	echo && type $XEMU && which $XEMU && $XEMU --version

	- name: ARM-ARM64-PPC-S390X
	if: ${{ matrix.type == 'ARM' \|\| matrix.type == 'ARM64' \|\| matrix.type == 'PPC' \|\| matrix.type == 'S390X'}}
	run: make platformTest V=1 CC=$XCC QEMU_SYS=$XEMU

	- name: PPC64LE
	if: ${{ matrix.type == 'PPC64LE' }}
	run: CFLAGS=-m64 make platformTest V=1 CC=$XCC QEMU_SYS=$XEMU

	- name: MIPS-M68K-RISCV-SPARC
	if: ${{ matrix.type == 'MIPS' \|\| matrix.type == 'M68K' \|\| matrix.type == 'RISC-V' \|\| matrix.type == 'SPARC' }}
	run: make platformTest V=1 CC=$XCC QEMU_SYS=$XEMU



	# macOS
	lz4-platform-macos-latest:
	name: macOS
	runs-on: macos-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: Environment info
	run: \|
	echo && type cc && which cc && cc --version
	echo && type make && which make && make -v
	echo && sysctl -a \| grep machdep.cpu # cpuinfo

	- name: make default
	run: make clean; CFLAGS="-Werror -O0" make default V=1

	- name: make test
	run: make clean; CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" make -j test V=1

	- name: Ensure `make test` doesn't depend on the status of the console
	# see issue #990 for detailed explanations
	run: make -j test > /dev/null


	# Windows
	lz4-platform-windows:
	name: ${{ matrix.system.os }}
	runs-on: ${{ matrix.system.os }}
	strategy:
	fail-fast: false # 'false' means Don't stop matrix workflows even if some matrix failed.
	matrix:
	system: [
	{ os: windows-2022, build_path: ".\\build\\VS2022" },
	]
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: Build ${{ matrix.system.os }}, Win32
	run: \|
	pushd ${{ matrix.system.build_path }}
	.\\build-and-test-win32-release.bat
	popd

	- name: Build ${{ matrix.system.os }}, x64
	run: \|
	pushd ${{ matrix.system.build_path }}
	.\\build-and-test-x64-release.bat
	popd


	###############################################################
	# Build systems (other than make)
	#
	# - cmake
	# - meson
	#

	# cmake
	lz4-build-cmake:
	name: cmake
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: Environment info
	run: \|
	echo && type cmake && which cmake && cmake --version
	echo && type make && which make && make -v

	- name: cmake
	run: \|
	CFLAGS="-Werror -O1" cmake -S build/cmake -B build -D CMAKE_INSTALL_PREFIX=install
	VERBOSE=1 cmake --build build --target install
	cmake -S tests/cmake -B build_test -D CMAKE_INSTALL_PREFIX=install
	VERBOSE=1 cmake --build build_test

	lz4-build-cmake-static-lib: # See https://github.com/lz4/lz4/issues/1269
	name: cmake (static lib)
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: Environment info
	run: \|
	echo && type cmake && which cmake && cmake --version
	echo && type make && which make && make -v

	- name: cmake (static lib)
	run: \|
	CFLAGS="-Werror -O1" cmake -S build/cmake -B build -D CMAKE_INSTALL_PREFIX=install_test_dir -DBUILD_STATIC_LIBS=ON
	VERBOSE=1 cmake --build build --target install
	cmake -S tests/cmake -B build_test -D CMAKE_INSTALL_PREFIX=install_test_dir
	VERBOSE=1 cmake --build build_test

	# Invoke cmake via Makefile
	lz4-build-make-cmake:
	name: make cmakebuild
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: make cmakebuild
	# V=1 for lz4 Makefile, VERBOSE=1 for cmake Makefile.
	run: make clean; make cmakebuild V=1 VERBOSE=1


	# Meson
	lz4-build-meson:
	name: Meson + Ninja
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # https://github.com/actions/setup-python v5.1.0
	with:
	python-version: '3.x'

	- name: Install
	run: \|
	sudo apt-get update
	sudo apt-get install tree ninja-build
	python -m pip install --upgrade pip
	pip3 install --user meson

	- name: Environment info
	run: \|
	echo && type clang && which clang && clang --version
	echo && type python && which python && python --version
	echo && type meson && which meson && meson --version

	- name: setup
	# 'run: >' replaces all newlines in the following block with spaces
	run: >
	meson setup
	--fatal-meson-warnings
	--buildtype=debug
	-Db_lundef=false
	-Dauto_features=enabled
	-Dprograms=true
	-Dcontrib=true
	-Dtests=true
	-Dexamples=true
	build/meson builddir

	- name: test
	run: \|
	meson test -C builddir

	- name: staging
	run: \|
	cd builddir
	DESTDIR=./staging ninja install
	tree ./staging



	############################################################
	# Check git tag for LZ4 releases
	#
	lz4-check-tag:
	name: git version tag checking for release
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
	- name: make -C tests checkTag
	if: startsWith(github.ref, 'refs/tags/v') # If git tag name starts with 'v'
	run: \|
	echo "tag=${GITHUB_REF#refs/*/}"
	make -C tests checkTag
	tests/checkTag ${GITHUB_REF#refs/*/}



	############################################################
	# Gather CI environment information.
	#
	lz4-env-info:
	name: GH-Actions Virtual Env Info (${{ matrix.os }})
	strategy:
	matrix:
	include: [
	{ os: ubuntu-latest, }, # https://github.com/actions/virtual-environments/
	{ os: ubuntu-22.04, }, # https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2204-Readme.md
	{ os: ubuntu-20.04, }, # https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-Readme.md
	]

	runs-on: ${{ matrix.os }}
	steps:
	- uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

	- name: init
	run: \|
	sudo apt-get update

	- name: cc --version
	run: echo && type cc && which cc && cc --version

	- name: gcc --version
	run: echo && type gcc && which gcc && gcc --version

	- name: clang --version
	run: echo && type clang && which clang && clang --version

	- name: make -v
	run: echo && type make && which make && make -v

	- name: g++ --version
	run: echo && type g++ && which g++ && g++ --version

	- name: git --version
	run: echo && type git && which git && git --version

	- name: gcc packages (apt-cache)
	run: apt-cache search gcc \| grep "^gcc-[0-9\.]* " \| sort

	- name: lib32gcc packages for i386 (apt-cache)
	run: apt-cache search lib32gcc \| grep "^lib32gcc-" \| sort

	- name: libx32gcc packages for x32 (apt-cache)
	run: apt-cache search libx32gcc \| grep "^libx32gcc-" \| sort

	- name: gcc multilib packages (apt-cache)
	run: apt-cache search multilib \| grep "gcc-" \| sort

	- name: clang packages (apt-cache)
	run: apt-cache search clang \| grep "^clang-[0-9\.]* " \| sort

	- name: QEMU packages (apt-cache)
	run: apt-cache search qemu \| grep "^qemu-system-.*QEMU full system" \| sort

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Unroll wildCopy32 into wildCopy64 #1262

Workflow file

Unroll wildCopy32 into wildCopy64 #1262

Jobs

Run details

Workflow file for this run