From 7cecc7b089b1903563b3556eb8ed631ff326ede9 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Tue, 15 Nov 2016 17:51:29 -0800 Subject: fixed a limit case scenario --- lib/lz4frame.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/lz4frame.c b/lib/lz4frame.c index c8e5bde..3c2b788 100644 --- a/lib/lz4frame.c +++ b/lib/lz4frame.c @@ -897,10 +897,11 @@ static size_t LZ4F_decodeHeader(LZ4F_dctx* dctxPtr, const void* src, size_t srcS FREEMEM(dctxPtr->tmpIn); dctxPtr->tmpIn = (BYTE*)ALLOCATOR(dctxPtr->maxBlockSize); if (dctxPtr->tmpIn == NULL) return err0r(LZ4F_ERROR_allocation_failed); - dctxPtr->maxBufferSize = bufferNeeded; FREEMEM(dctxPtr->tmpOutBuffer); + dctxPtr->maxBufferSize = 0; dctxPtr->tmpOutBuffer= (BYTE*)ALLOCATOR(bufferNeeded); if (dctxPtr->tmpOutBuffer== NULL) return err0r(LZ4F_ERROR_allocation_failed); + dctxPtr->maxBufferSize = bufferNeeded; } } dctxPtr->tmpInSize = 0; dctxPtr->tmpInTarget = 0; -- cgit v0.12 From a22ca9378be9ace2aa6d08b80f767241d759dc1b Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Wed, 16 Nov 2016 11:36:45 -0800 Subject: updated README for v1.7.3 --- README.md | 44 +++++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index 91661a9..1b4a007 100644 --- a/README.md +++ b/README.md @@ -43,25 +43,29 @@ LZ4 library is provided as open-source software using BSD 2-Clause license. Benchmarks ------------------------- -The benchmark uses the [Open-Source Benchmark program by m^2 (v0.14.3)] -compiled with GCC v4.8.2 on Linux Mint 64-bits v17. -The reference system uses a Core i5-4300U @1.9GHz. +The benchmark uses [lzbench], from @inikep +compiled with GCC v6.2.0 on Linux 64-bits. +The reference system uses a Core i7-3930K CPU @ 4.5GHz. Benchmark evaluates the compression of reference [Silesia Corpus] in single-thread mode. -| Compressor | Ratio | Compression | Decompression | -| ---------- | ----- | ----------- | ------------- | -| memcpy | 1.000 | 4200 MB/s | 4200 MB/s | -|**LZ4 fast 17 (r129)**| 1.607 |**690 MB/s** | **2220 MB/s** | -|**LZ4 default (r129)**|**2.101**|**385 MB/s** | **1850 MB/s** | -| LZO 2.06 | 2.108 | 350 MB/s | 510 MB/s | -| QuickLZ 1.5.1.b6 | 2.238 | 320 MB/s | 380 MB/s | -| Snappy 1.1.0 | 2.091 | 250 MB/s | 960 MB/s | -| [Zstandard] 0.5.1 | 2.876 | 240 MB/s | 620 MB/s | -| LZF v3.6 | 2.073 | 175 MB/s | 500 MB/s | -| [zlib] 1.2.8 -1 | 2.730 | 59 MB/s | 250 MB/s | -|**LZ4 HC (r129)** |**2.720**| 22 MB/s | **1830 MB/s** | -| [zlib] 1.2.8 -6 | 3.099 | 18 MB/s | 270 MB/s | +[lzbench]: https://github.com/inikep/lzbench +[Silesia Corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia + +| Compressor | Ratio | Compression | Decompression | +| ---------- | ----- | ----------- | ------------- | +| memcpy | 1.000 | 7300 MB/s | 7300 MB/s | +|**LZ4 fast 8 (v1.7.3)**| 1.799 |**911 MB/s** | **3360 MB/s** | +|**LZ4 default (v1.7.3)**|**2.101**|**625 MB/s** | **3220 MB/s** | +| LZO 2.09 | 2.108 | 620 MB/s | 845 MB/s | +| QuickLZ 1.5.0 | 2.238 | 510 MB/s | 600 MB/s | +| Snappy 1.1.3 | 2.091 | 450 MB/s | 1550 MB/s | +| LZF v3.6 | 2.073 | 365 MB/s | 820 MB/s | +| [Zstandard] 1.1.1 -1 | 2.876 | 330 MB/s | 930 MB/s | +| [Zstandard] 1.1.1 -3 | 3.164 | 200 MB/s | 810 MB/s | +| [zlib] deflate 1.2.8 -1| 2.730 | 100 MB/s | 370 MB/s | +|**LZ4 HC -9 (v1.7.3)** |**2.720**| 34 MB/s | **3240 MB/s** | +| [zlib] deflate 1.2.8 -6| 3.099 | 33 MB/s | 390 MB/s | [zlib]: http://www.zlib.net/ [Zstandard]: http://www.zstd.net/ @@ -77,6 +81,9 @@ Organizing these blocks and providing a common header format to handle their con is the purpose of the Frame format, defined into [lz4_Frame_format]. Interoperable versions of LZ4 must respect this frame format. +[lz4_Block_format]: doc/lz4_Block_format.md +[lz4_Frame_format]: doc/lz4_Frame_format.md + Other source versions ------------------------- @@ -86,9 +93,4 @@ many contributors have created versions of lz4 in multiple languages (Java, C#, Python, Perl, Ruby, etc.). A list of known source ports is maintained on the [LZ4 Homepage]. - -[Open-Source Benchmark program by m^2 (v0.14.3)]: http://encode.ru/threads/1371-Filesystem-benchmark?p=34029&viewfull=1#post34029 -[Silesia Corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia -[lz4_Block_format]: doc/lz4_Block_format.md -[lz4_Frame_format]: doc/lz4_Frame_format.md [LZ4 Homepage]: http://www.lz4.org -- cgit v0.12 From 1abecbc33c8ec5b84d2623dcbe73136aeb99db37 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 13:02:06 -0800 Subject: fix 32-bits mode. Large File support for Mac OS-X in 32-bits mode Fixed potential undefined behavior Changed makefile for 32-bits mode --- .travis.yml | 4 +- Makefile | 11 ++- NEWS | 3 + lib/Makefile | 10 ++- lib/lz4.c | 8 +- lib/lz4.h | 2 +- programs/Makefile | 26 ++++--- programs/lz4io.c | 23 +++--- tests/Makefile | 222 ++++++++++++++++++++++++++---------------------------- tests/fullbench.c | 63 +--------------- tests/fuzzer.c | 15 ++-- 11 files changed, 174 insertions(+), 213 deletions(-) diff --git a/.travis.yml b/.travis.yml index f4facad..48ccbc6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,7 +17,7 @@ matrix: - os: linux sudo: false - env: Ubu=12.04cont Cmd="make gpptest-native && make clean && make examples && make clean && make cmake && make clean && make travis-install && make clean && make clangtest-native" COMPILER=cc + env: Ubu=12.04cont Cmd="make gpptest-native && make clean examples && make clean cmake && make clean travis-install && make clean clangtest-native" COMPILER=cc # 14.04 LTS Server Edition 64 bit @@ -87,7 +87,7 @@ matrix: packages: - valgrind - - env: Ubu=14.04 Cmd='make -C tests test-lz4 test-lz4c32 CC=gcc-5 MOREFLAGS=-Werror' COMPILER=gcc-5 + - env: Ubu=14.04 Cmd='make -C tests test-lz4 clean test-lz4c32 CC=gcc-5 MOREFLAGS=-Werror' COMPILER=gcc-5 dist: trusty sudo: required addons: diff --git a/Makefile b/Makefile index c6454b0..cbf0932 100644 --- a/Makefile +++ b/Makefile @@ -36,8 +36,8 @@ VOID := /dev/null LIBDIR ?= $(PREFIX)/lib INCLUDEDIR=$(PREFIX)/include -PRGDIR = programs LZ4DIR = lib +PRGDIR = programs TESTDIR = tests @@ -51,12 +51,15 @@ endif .PHONY: default all lib lz4 clean test versionsTest examples -default: lz4 +default: lib lz4 -all: lib lz4 +all: + @$(MAKE) -C $(LZ4DIR) $@ + @$(MAKE) -C $(PRGDIR) $@ + @$(MAKE) -C $(TESTDIR) $@ lib: - @$(MAKE) -C $(LZ4DIR) all + @$(MAKE) -C $(LZ4DIR) lz4: @$(MAKE) -C $(PRGDIR) diff --git a/NEWS b/NEWS index 9bb1a62..b67bf39 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,6 @@ +v1.7.4 +cli : fix : Large file support in 32-bits mode on Mac OS-X + v1.7.3 Changed : moved to versioning; package, cli and library have same version number Improved: Small decompression speed boost diff --git a/lib/Makefile b/lib/Makefile index 4c9b929..216d136 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -70,12 +70,18 @@ else SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER) endif -default: lib +default: lib-release all: lib +all32: CFLAGS+=-m32 +all32: all + lib: liblz4.a liblz4 +lib-release: CFLAGS := -O3 +lib-release: lib + liblz4.a: *.c ifeq ($(BUILD_STATIC),yes) @echo compiling static library @@ -96,7 +102,7 @@ else endif clean: - @$(RM) -f core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* liblz4.pc dll/liblz4.dll dll/liblz4.lib + @$(RM) core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* liblz4.pc dll/liblz4.dll dll/liblz4.lib @echo Cleaning library completed diff --git a/lib/lz4.c b/lib/lz4.c index 89e3a0f..bdbc73f 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -141,12 +141,14 @@ typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; + typedef uintptr_t uptrval; #else typedef unsigned char BYTE; typedef unsigned short U16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; + typedef size_t uptrval; /* generally true, except OpenVMS-64 */ #endif @@ -1139,8 +1141,8 @@ FORCE_INLINE int LZ4_decompress_generic( s = *ip++; length += s; } while ( likely(endOnInput ? ip iend-LASTLITERALS)) goto _output_error; length += s; } while (s==255); - if ((safeDecode) && unlikely((size_t)(op+length)<(size_t)op)) goto _output_error; /* overflow detection */ + if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error; /* overflow detection */ } length += MINMATCH; diff --git a/lib/lz4.h b/lib/lz4.h index babd78c..ec758fe 100644 --- a/lib/lz4.h +++ b/lib/lz4.h @@ -85,7 +85,7 @@ extern "C" { /*========== Version =========== */ #define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */ #define LZ4_VERSION_MINOR 7 /* for new (non-breaking) interface capabilities */ -#define LZ4_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */ +#define LZ4_VERSION_RELEASE 4 /* for tweaks, bug-fixes, or development */ #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) diff --git a/programs/Makefile b/programs/Makefile index de18f78..2f1c3cc 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -29,18 +29,18 @@ DESTDIR ?= PREFIX ?= /usr/local -VOID := /dev/null BINDIR := $(PREFIX)/bin MANDIR := $(PREFIX)/share/man/man1 LZ4DIR := ../lib +VOID := /dev/null CFLAGS ?= -O3 # allows custom optimization flags. For example : CFLAGS="-O2 -g" make -CFLAGS += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow \ +CFLAGS += -g -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow \ -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes \ -Wpointer-arith -Wstrict-aliasing=1 CFLAGS += $(MOREFLAGS) CPPFLAGS:= -I$(LZ4DIR) -DXXH_NAMESPACE=LZ4_ -FLAGS := $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) +FLAGS = $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) # Define *.exe as extension for Windows systems @@ -52,27 +52,29 @@ endif -default: lz4 +default: lz4-release -m32: lz4c32 +all: lz4 lz4c -native: lz4 lz4c - -all: native m32 +all32: CFLAGS+=-m32 +all32: all lz4: $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/lz4frame.o $(LZ4DIR)/xxhash.o bench.o lz4io.o lz4cli.o datagen.o $(CC) $(FLAGS) $^ -o $@$(EXT) -lz4c : $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/lz4frame.o $(LZ4DIR)/xxhash.o bench.o lz4io.o lz4cli.o datagen.o +lz4-release: CFLAGS := -O3 +lz4-release: lz4 + +lz4c : $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/lz4frame.o $(LZ4DIR)/xxhash.o bench.o lz4io.o lz4cli.c datagen.o $(CC) $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) -lz4c32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c datagen.c - $(CC) -m32 $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) +lz4c32: CFLAGS += -m32 +lz4c32: lz4 clean: @$(MAKE) -C $(LZ4DIR) $@ > $(VOID) @$(RM) core *.o *.test tmp* \ - lz4$(EXT) lz4c$(EXT) lz4c32$(EXT) \ + lz4$(EXT) lz4c$(EXT) @echo Cleaning completed diff --git a/programs/lz4io.c b/programs/lz4io.c index 4d076a9..e8eaf60 100644 --- a/programs/lz4io.c +++ b/programs/lz4io.c @@ -34,6 +34,8 @@ * Compiler Options **************************************/ #define _LARGE_FILES /* Large file support on 32-bits AIX */ +#define _FILE_OFFSET_BITS 64 /* off_t width */ +#define _LARGEFILE_SOURCE #if defined(__MINGW32__) && !defined(_POSIX_SOURCE) # define _POSIX_SOURCE 1 /* disable %llu warnings with MinGW on Windows */ @@ -74,6 +76,9 @@ # define SET_SPARSE_FILE_MODE(file) # endif #else +# if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || (defined(__APPLE__) && defined(__MACH__)) +# define fseek fseeko +# endif # define SET_BINARY_MODE(file) # define SET_SPARSE_FILE_MODE(file) #endif @@ -103,9 +108,6 @@ #define MIN_STREAM_BUFSIZE (192 KB) #define LZ4IO_BLOCKSIZEID_DEFAULT 7 -#define sizeT sizeof(size_t) -#define maskT (sizeT - 1) - /************************************** * Macros @@ -623,11 +625,14 @@ static unsigned LZ4IO_readLE32 (const void* s) return value32; } +#define sizeT sizeof(size_t) +#define maskT (sizeT - 1) + static unsigned LZ4IO_fwriteSparse(FILE* file, const void* buffer, size_t bufferSize, unsigned storedSkips) { const size_t* const bufferT = (const size_t*)buffer; /* Buffer is supposed malloc'ed, hence aligned on size_t */ const size_t* ptrT = bufferT; - size_t bufferSizeT = bufferSize / sizeT; + size_t bufferSizeT = bufferSize / sizeT; const size_t* const bufferTEnd = bufferT + bufferSizeT; static const size_t segmentSizeT = (32 KB) / sizeT; @@ -716,11 +721,11 @@ static unsigned long long LZ4IO_decodeLegacyStream(FILE* finput, FILE* foutput) unsigned int blockSize; /* Block Size */ - { size_t const sizeCheck = fread(in_buff, 1, 4, finput); - if (sizeCheck == 0) break; /* Nothing to read : file read is completed */ - if (sizeCheck != 4) EXM_THROW(52, "Read error : cannot access block size "); } - blockSize = LZ4IO_readLE32(in_buff); /* Convert to Little Endian */ - if (blockSize > LZ4_COMPRESSBOUND(LEGACY_BLOCKSIZE)) { + { size_t const sizeCheck = fread(in_buff, 1, 4, finput); + if (sizeCheck == 0) break; /* Nothing to read : file read is completed */ + if (sizeCheck != 4) EXM_THROW(52, "Read error : cannot access block size "); } + blockSize = LZ4IO_readLE32(in_buff); /* Convert to Little Endian */ + if (blockSize > LZ4_COMPRESSBOUND(LEGACY_BLOCKSIZE)) { /* Cannot read next block : maybe new stream ? */ g_magicRead = blockSize; break; diff --git a/tests/Makefile b/tests/Makefile index 4e96769..4b0f503 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -23,21 +23,18 @@ # - LZ4 source repository : https://github.com/lz4/lz4 # ########################################################################## # fuzzer : Test tool, to check lz4 integrity on target platform -# fuzzer32: Same as fuzzer, but forced to compile in 32-bits mode # frametest : Test tool, to check lz4frame integrity on target platform -# frametest32: Same as frametest, but forced to compile in 32-bits mode # fullbench : Precisely measure speed for each LZ4 function variant -# fullbench32: Same as fullbench, but forced to compile in 32-bits mode # datagen : generates synthetic data samples for tests & benchmarks # ########################################################################## DESTDIR ?= PREFIX ?= /usr/local -VOID := /dev/null BINDIR := $(PREFIX)/bin MANDIR := $(PREFIX)/share/man/man1 -LZ4DIR := ../lib +LIBDIR := ../lib PRGDIR := ../programs +VOID := /dev/null TESTDIR := versionsTest PYTHON ?= python3 @@ -46,8 +43,8 @@ CFLAGS += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes \ -Wpointer-arith -Wstrict-aliasing=1 CFLAGS += $(MOREFLAGS) -CPPFLAGS:= -I$(LZ4DIR) -DXXH_NAMESPACE=LZ4_ -FLAGS := $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) +CPPFLAGS:= -I$(LIBDIR) -DXXH_NAMESPACE=LZ4_ +FLAGS = $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) # Define *.exe as extension for Windows systems @@ -56,6 +53,7 @@ EXT =.exe else EXT = endif +LZ4 := $(PRGDIR)/lz4$(EXT) # Default test parameters @@ -64,58 +62,48 @@ FUZZER_TIME := -T3mn NB_LOOPS ?= -i1 -default: native - -m32: fullbench32 fuzzer32 frametest32 - -native: fullbench fuzzer frametest datagen fasttest +default: all -all: native m32 +all: fullbench fuzzer frametest datagen fasttest +all32: CFLAGS+=-m32 +all32: all lz4: - $(MAKE) -C $(PRGDIR) $@ + $(MAKE) -C $(PRGDIR) clean $@ CFLAGS="$(CFLAGS)" lz4c: - $(MAKE) -C $(PRGDIR) $@ + $(MAKE) -C $(PRGDIR) clean $@ CFLAGS="$(CFLAGS)" -lz4c32: - $(MAKE) -C $(PRGDIR) $@ +lz4c32: # create a 32-bits version for 32/64 interop tests + $(MAKE) -C $(PRGDIR) clean $@ CFLAGS="-m32 $(CFLAGS)" + cp $(LZ4) $(LZ4)c32 -fullbench : $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/lz4frame.o $(LZ4DIR)/xxhash.o fullbench.c +fullbench : $(LIBDIR)/lz4.o $(LIBDIR)/lz4hc.o $(LIBDIR)/lz4frame.o $(LIBDIR)/xxhash.o fullbench.c $(CC) $(FLAGS) $^ -o $@$(EXT) -fullbench32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c - $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) +fullbench-lib: fullbench.c $(LIBDIR)/xxhash.c + $(MAKE) -C $(LIBDIR) liblz4.a + $(CC) $(FLAGS) $^ -o $@$(EXT) $(LIBDIR)/liblz4.a -fullbench-lib: fullbench.c $(LZ4DIR)/xxhash.c - $(MAKE) -C $(LZ4DIR) liblz4.a - $(CC) $(FLAGS) $^ -o $@$(EXT) $(LZ4DIR)/liblz4.a +fullbench-dll: fullbench.c $(LIBDIR)/xxhash.c + $(MAKE) -C $(LIBDIR) liblz4 + $(CC) $(FLAGS) $^ -o $@$(EXT) -DLZ4_DLL_IMPORT=1 $(LIBDIR)/dll/liblz4.dll -fullbench-dll: fullbench.c $(LZ4DIR)/xxhash.c - $(MAKE) -C $(LZ4DIR) liblz4 - $(CC) $(FLAGS) $^ -o $@$(EXT) -DLZ4_DLL_IMPORT=1 $(LZ4DIR)/dll/liblz4.dll - -fuzzer : $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/xxhash.o fuzzer.c +fuzzer : $(LIBDIR)/lz4.o $(LIBDIR)/lz4hc.o $(LIBDIR)/xxhash.o fuzzer.c $(CC) $(FLAGS) $^ -o $@$(EXT) -fuzzer32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c - $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) - -frametest: $(LZ4DIR)/lz4frame.o $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/xxhash.o frametest.c +frametest: $(LIBDIR)/lz4frame.o $(LIBDIR)/lz4.o $(LIBDIR)/lz4hc.o $(LIBDIR)/xxhash.o frametest.c $(CC) $(FLAGS) $^ -o $@$(EXT) -frametest32: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c - $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) - -fasttest: $(LZ4DIR)/lz4.o fasttest.c +fasttest: $(LIBDIR)/lz4.o fasttest.c $(CC) $(FLAGS) $^ -o $@$(EXT) datagen : $(PRGDIR)/datagen.c datagencli.c $(CC) $(FLAGS) -I$(PRGDIR) $^ -o $@$(EXT) clean: - @$(MAKE) -C $(LZ4DIR) $@ > $(VOID) + @$(MAKE) -C $(LIBDIR) $@ > $(VOID) @$(RM) core *.o *.test tmp* \ fullbench-dll$(EXT) fullbench-lib$(EXT) \ fullbench$(EXT) fullbench32$(EXT) \ @@ -134,40 +122,44 @@ versionsTest: #FreeBSD targets ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU FreeBSD)) -test: test-lz4 test-lz4c test-fasttest test-frametest test-fullbench test-fuzzer +MD5:=md5sum +ifneq (,$(filter $(shell uname), Darwin )) +MD5:=md5 -r +endif -test32: test-lz4c32 test-frametest32 test-fullbench32 test-fuzzer32 +test: test-lz4 test-lz4c test-fasttest test-frametest test-fullbench test-fuzzer -test-all: test test32 +test32: CFLAGS+=-m32 +test32: test test-lz4-sparse: lz4 datagen @echo "\n ---- test sparse file support ----" ./datagen -g5M -P100 > tmpSrc - $(PRGDIR)/lz4 -B4D tmpSrc | $(PRGDIR)/lz4 -dv --sparse > tmpB4 + $(LZ4) -B4D tmpSrc | $(LZ4) -dv --sparse > tmpB4 diff -s tmpSrc tmpB4 - $(PRGDIR)/lz4 -B5D tmpSrc | $(PRGDIR)/lz4 -dv --sparse > tmpB5 + $(LZ4) -B5D tmpSrc | $(LZ4) -dv --sparse > tmpB5 diff -s tmpSrc tmpB5 - $(PRGDIR)/lz4 -B6D tmpSrc | $(PRGDIR)/lz4 -dv --sparse > tmpB6 + $(LZ4) -B6D tmpSrc | $(LZ4) -dv --sparse > tmpB6 diff -s tmpSrc tmpB6 - $(PRGDIR)/lz4 -B7D tmpSrc | $(PRGDIR)/lz4 -dv --sparse > tmpB7 + $(LZ4) -B7D tmpSrc | $(LZ4) -dv --sparse > tmpB7 diff -s tmpSrc tmpB7 - $(PRGDIR)/lz4 tmpSrc | $(PRGDIR)/lz4 -dv --no-sparse > tmpNoSparse + $(LZ4) tmpSrc | $(LZ4) -dv --no-sparse > tmpNoSparse diff -s tmpSrc tmpNoSparse ls -ls tmp* - ./datagen -s1 -g1200007 -P100 | $(PRGDIR)/lz4 | $(PRGDIR)/lz4 -dv --sparse > tmpOdd # Odd size file (to generate non-full last block) + ./datagen -s1 -g1200007 -P100 | $(LZ4) | $(LZ4) -dv --sparse > tmpOdd # Odd size file (to generate non-full last block) ./datagen -s1 -g1200007 -P100 | diff -s - tmpOdd ls -ls tmpOdd @$(RM) tmp* @echo "\n Compatibility with Console :" - echo "Hello World 1 !" | $(PRGDIR)/lz4 | $(PRGDIR)/lz4 -d -c - echo "Hello World 2 !" | $(PRGDIR)/lz4 | $(PRGDIR)/lz4 -d | cat - echo "Hello World 3 !" | $(PRGDIR)/lz4 --no-frame-crc | $(PRGDIR)/lz4 -d -c + echo "Hello World 1 !" | $(LZ4) | $(LZ4) -d -c + echo "Hello World 2 !" | $(LZ4) | $(LZ4) -d | cat + echo "Hello World 3 !" | $(LZ4) --no-frame-crc | $(LZ4) -d -c @echo "\n Compatibility with Append :" ./datagen -P100 -g1M > tmp1M cat tmp1M tmp1M > tmp2M - $(PRGDIR)/lz4 -B5 -v tmp1M tmpC - $(PRGDIR)/lz4 -d -v tmpC tmpR - $(PRGDIR)/lz4 -d -v tmpC >> tmpR + $(LZ4) -B5 -v tmp1M tmpC + $(LZ4) -d -v tmpC tmpR + $(LZ4) -d -v tmpC >> tmpR ls -ls tmp* diff tmp2M tmpR @$(RM) tmp* @@ -175,14 +167,15 @@ test-lz4-sparse: lz4 datagen test-lz4-contentSize: lz4 datagen @echo "\n ---- test original size support ----" ./datagen -g15M > tmp - $(PRGDIR)/lz4 -v tmp | $(PRGDIR)/lz4 -t - $(PRGDIR)/lz4 -v --content-size tmp | $(PRGDIR)/lz4 -d > tmp2 + $(LZ4) -v tmp | $(LZ4) -t + $(LZ4) -v --content-size tmp | $(LZ4) -d > tmp2 diff -s tmp tmp2 # test large size [2-4] GB - @./datagen -g3G -P100 | $(PRGDIR)/lz4 | $(PRGDIR)/lz4 --decompress --force --sparse - tmp + @./datagen -g3G -P100 | $(LZ4) --verbose | $(LZ4) --decompress --force --sparse - tmp @ls -ls tmp - $(PRGDIR)/lz4 --quiet --content-size tmp | $(PRGDIR)/lz4 --verbose --decompress --force --sparse - tmp2 + @./datagen -g3G -P100 | $(LZ4) --quiet --content-size | $(LZ4) --verbose --decompress --force --sparse - tmp2 @ls -ls tmp2 + diff -s tmp tmp2 @$(RM) tmp* test-lz4-frame-concatenation: lz4 datagen @@ -190,10 +183,10 @@ test-lz4-frame-concatenation: lz4 datagen @echo -n > empty.test @echo hi > nonempty.test cat nonempty.test empty.test nonempty.test > orig.test - @$(PRGDIR)/lz4 -zq empty.test > empty.lz4.test - @$(PRGDIR)/lz4 -zq nonempty.test > nonempty.lz4.test + @$(LZ4) -zq empty.test > empty.lz4.test + @$(LZ4) -zq nonempty.test > nonempty.lz4.test cat nonempty.lz4.test empty.lz4.test nonempty.lz4.test > concat.lz4.test - $(PRGDIR)/lz4 -d concat.lz4.test > result.test + $(LZ4) -d concat.lz4.test > result.test sdiff orig.test result.test @$(RM) *.test @echo frame concatenation test completed @@ -203,54 +196,54 @@ test-lz4-multiple: lz4 datagen @./datagen -s1 > tmp1 2> $(VOID) @./datagen -s2 -g100K > tmp2 2> $(VOID) @./datagen -s3 -g1M > tmp3 2> $(VOID) - $(PRGDIR)/lz4 -f -m tmp* + $(LZ4) -f -m tmp* ls -ls tmp* @$(RM) tmp1 tmp2 tmp3 - $(PRGDIR)/lz4 -df -m *.lz4 + $(LZ4) -df -m *.lz4 ls -ls tmp* - $(PRGDIR)/lz4 -f -m tmp1 notHere tmp2; echo $$? + $(LZ4) -f -m tmp1 notHere tmp2; echo $$? @$(RM) tmp* test-lz4-basic: lz4 datagen @echo "\n ---- test lz4 basic compression/decompression ----" - ./datagen -g0 | $(PRGDIR)/lz4 -v | $(PRGDIR)/lz4 -t - ./datagen -g16KB | $(PRGDIR)/lz4 -9 | $(PRGDIR)/lz4 -t + ./datagen -g0 | $(LZ4) -v | $(LZ4) -t + ./datagen -g16KB | $(LZ4) -9 | $(LZ4) -t ./datagen -g20KB > tmpSrc - $(PRGDIR)/lz4 < tmpSrc | $(PRGDIR)/lz4 -d > tmpRes + $(LZ4) < tmpSrc | $(LZ4) -d > tmpRes diff -q tmpSrc tmpRes - $(PRGDIR)/lz4 --no-frame-crc < tmpSrc | $(PRGDIR)/lz4 -d > tmpRes + $(LZ4) --no-frame-crc < tmpSrc | $(LZ4) -d > tmpRes diff -q tmpSrc tmpRes - ./datagen | $(PRGDIR)/lz4 | $(PRGDIR)/lz4 -t - ./datagen -g6M -P99 | $(PRGDIR)/lz4 -9BD | $(PRGDIR)/lz4 -t - ./datagen -g17M | $(PRGDIR)/lz4 -9v | $(PRGDIR)/lz4 -qt - ./datagen -g33M | $(PRGDIR)/lz4 --no-frame-crc | $(PRGDIR)/lz4 -t - ./datagen -g256MB | $(PRGDIR)/lz4 -vqB4D | $(PRGDIR)/lz4 -t + ./datagen | $(LZ4) | $(LZ4) -t + ./datagen -g6M -P99 | $(LZ4) -9BD | $(LZ4) -t + ./datagen -g17M | $(LZ4) -9v | $(LZ4) -qt + ./datagen -g33M | $(LZ4) --no-frame-crc | $(LZ4) -t + ./datagen -g256MB | $(LZ4) -vqB4D | $(LZ4) -t @$(RM) tmp* test-lz4-hugefile: lz4 datagen @echo "\n ---- test huge files compression/decompression ----" - ./datagen -g6GB | $(PRGDIR)/lz4 -vB5D | $(PRGDIR)/lz4 -qt - ./datagen -g6GB | $(PRGDIR)/lz4 -v5BD | $(PRGDIR)/lz4 -qt + ./datagen -g6GB | $(LZ4) -vB5D | $(LZ4) -qt + ./datagen -g6GB | $(LZ4) -v5BD | $(LZ4) -qt @$(RM) tmp* test-lz4-testmode: lz4 datagen @echo "\n ---- bench mode ----" - $(PRGDIR)/lz4 -bi1 + $(LZ4) -bi1 @echo "\n ---- test mode ----" - ./datagen | $(PRGDIR)/lz4 -t && false || true - ./datagen | $(PRGDIR)/lz4 -tf && false || true + ./datagen | $(LZ4) -t && false || true + ./datagen | $(LZ4) -tf && false || true @echo "\n ---- pass-through mode ----" - ./datagen | $(PRGDIR)/lz4 -d > $(VOID) && false || true - ./datagen | $(PRGDIR)/lz4 -df > $(VOID) + ./datagen | $(LZ4) -d > $(VOID) && false || true + ./datagen | $(LZ4) -df > $(VOID) @echo "Hello World !" > tmp1 - $(PRGDIR)/lz4 -dcf tmp1 + $(LZ4) -dcf tmp1 @echo "from underground..." > tmp2 - $(PRGDIR)/lz4 -dcfm tmp1 tmp2 + $(LZ4) -dcfm tmp1 tmp2 @echo "\n ---- test cli ----" - $(PRGDIR)/lz4 file-does-not-exist && false || true - $(PRGDIR)/lz4 -f file-does-not-exist && false || true - $(PRGDIR)/lz4 -fm file1-dne file2-dne && false || true - $(PRGDIR)/lz4 -fm file1-dne file2-dne && false || true + $(LZ4) file-does-not-exist && false || true + $(LZ4) -f file-does-not-exist && false || true + $(LZ4) -fm file1-dne file2-dne && false || true + $(LZ4) -fm file1-dne file2-dne && false || true test-lz4: lz4 datagen test-lz4-basic test-lz4-multiple test-lz4-sparse \ test-lz4-frame-concatenation test-lz4-testmode test-lz4-contentSize \ @@ -258,53 +251,54 @@ test-lz4: lz4 datagen test-lz4-basic test-lz4-multiple test-lz4-sparse \ test-lz4c: lz4c datagen @echo "\n ---- test lz4c version ----" - ./datagen -g256MB | $(PRGDIR)/lz4c -l -v | $(PRGDIR)/lz4c -t + ./datagen -g256MB | $(LZ4)c -l -v | $(LZ4)c -t + +test-lz4c32: CFLAGS+=-m32 +test-lz4c32: test-lz4 test-interop-32-64: lz4 lz4c32 datagen @echo "\n ---- test interoperability 32-bits -vs- 64 bits ----" - ./datagen -g16KB | $(PRGDIR)/lz4c32 -9 | $(PRGDIR)/lz4 -t - ./datagen -P10 | $(PRGDIR)/lz4 -9B4 | $(PRGDIR)/lz4c32 -t - ./datagen | $(PRGDIR)/lz4c32 | $(PRGDIR)/lz4 -t - ./datagen -g1M | $(PRGDIR)/lz4 -3B5 | $(PRGDIR)/lz4c32 -t - ./datagen -g256MB | $(PRGDIR)/lz4c32 -vqB4D | $(PRGDIR)/lz4 -qt - ./datagen -g1G -P90 | $(PRGDIR)/lz4 | $(PRGDIR)/lz4c32 -t - ./datagen -g6GB | $(PRGDIR)/lz4c32 -vq9BD | $(PRGDIR)/lz4 -qt + ./datagen -g16KB | $(LZ4)c32 -9 | $(LZ4) -t + ./datagen -P10 | $(LZ4) -9B4 | $(LZ4)c32 -t + ./datagen | $(LZ4)c32 | $(LZ4) -t + ./datagen -g1M | $(LZ4) -3B5 | $(LZ4)c32 -t + ./datagen -g256MB | $(LZ4)c32 -vqB4D | $(LZ4) -qt + ./datagen -g1G -P90 | $(LZ4) | $(LZ4)c32 -t + ./datagen -g6GB | $(LZ4)c32 -vq9BD | $(LZ4) -qt test-lz4c32-basic: lz4c32 datagen @echo "\n ---- test lz4c32 32-bits version ----" - ./datagen -g16KB | $(PRGDIR)/lz4c32 -9 | $(PRGDIR)/lz4c32 -t - ./datagen | $(PRGDIR)/lz4c32 | $(PRGDIR)/lz4c32 -t - ./datagen -g256MB | $(PRGDIR)/lz4c32 -vqB4D | $(PRGDIR)/lz4c32 -qt - ./datagen -g6GB | $(PRGDIR)/lz4c32 -vqB5D | $(PRGDIR)/lz4c32 -qt + ./datagen -g16KB | $(LZ4)c32 -9 | $(LZ4)c32 -t + ./datagen | $(LZ4)c32 | $(LZ4)c32 -t + ./datagen -g256MB | $(LZ4)c32 -vqB4D | $(LZ4)c32 -qt + ./datagen -g6GB | $(LZ4)c32 -vqB5D | $(LZ4)c32 -qt test-platform: @echo "\n ---- test lz4 $(QEMU_SYS) platform ----" - $(QEMU_SYS) ./datagen -g16KB | $(QEMU_SYS) $(PRGDIR)/lz4 -9 | $(QEMU_SYS) $(PRGDIR)/lz4 -t - $(QEMU_SYS) ./datagen | $(QEMU_SYS) $(PRGDIR)/lz4 | $(QEMU_SYS) $(PRGDIR)/lz4 -t - $(QEMU_SYS) ./datagen -g256MB | $(QEMU_SYS) $(PRGDIR)/lz4 -vqB4D | $(QEMU_SYS) $(PRGDIR)/lz4 -qt + $(QEMU_SYS) ./datagen -g16KB | $(QEMU_SYS) $(LZ4) -9 | $(QEMU_SYS) $(LZ4) -t + $(QEMU_SYS) ./datagen | $(QEMU_SYS) $(LZ4) | $(QEMU_SYS) $(LZ4) -t + $(QEMU_SYS) ./datagen -g256MB | $(QEMU_SYS) $(LZ4) -vqB4D | $(QEMU_SYS) $(LZ4) -qt ifneq ($(QEMU_SYS),qemu-arm-static) - $(QEMU_SYS) ./datagen -g3GB | $(QEMU_SYS) $(PRGDIR)/lz4 -vqB5D | $(QEMU_SYS) $(PRGDIR)/lz4 -qt + $(QEMU_SYS) ./datagen -g3GB | $(QEMU_SYS) $(LZ4) -vqB5D | $(QEMU_SYS) $(LZ4) -qt endif -test-lz4c32: test-lz4c32-basic test-interop-32-64 - test-fullbench: fullbench ./fullbench --no-prompt $(NB_LOOPS) $(TEST_FILES) -test-fullbench32: fullbench32 - ./fullbench32 --no-prompt $(NB_LOOPS) $(TEST_FILES) +test-fullbench32: CFLAGS += -m32 +test-fullbench32: test-fullbench test-fuzzer: fuzzer ./fuzzer $(FUZZER_TIME) -test-fuzzer32: fuzzer32 - ./fuzzer32 $(FUZZER_TIME) +test-fuzzer32: CFLAGS += -m32 +test-fuzzer32: test-fuzzer test-frametest: frametest ./frametest $(FUZZER_TIME) -test-frametest32: frametest32 - ./frametest32 $(FUZZER_TIME) +test-frametest32: CFLAGS += -m32 +test-frametest32: test-frametest test-fasttest: fasttest ./fasttest @@ -313,17 +307,17 @@ test-mem: lz4 datagen fuzzer frametest fullbench @echo "\n ---- valgrind tests : memory analyzer ----" valgrind --leak-check=yes --error-exitcode=1 ./datagen -g50M > $(VOID) ./datagen -g16KB > tmp - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 -9 -BD -f tmp $(VOID) + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) -9 -BD -f tmp $(VOID) ./datagen -g16KB -s2 > tmp2 ./datagen -g16KB -s3 > tmp3 - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 --force --multiple tmp tmp2 tmp3 + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) --force --multiple tmp tmp2 tmp3 ./datagen -g16MB > tmp - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 -9 -B5D -f tmp tmp2 - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 -t tmp2 - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 -bi1 tmp + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) -9 -B5D -f tmp tmp2 + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) -t tmp2 + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) -bi1 tmp valgrind --leak-check=yes --error-exitcode=1 ./fullbench -i1 tmp tmp2 ./datagen -g256MB > tmp - valgrind --leak-check=yes --error-exitcode=1 $(PRGDIR)/lz4 -B4D -f -vq tmp $(VOID) + valgrind --leak-check=yes --error-exitcode=1 $(LZ4) -B4D -f -vq tmp $(VOID) $(RM) tmp* valgrind --leak-check=yes --error-exitcode=1 ./fuzzer -i64 -t1 valgrind --leak-check=yes --error-exitcode=1 ./frametest -i256 diff --git a/tests/fullbench.c b/tests/fullbench.c index 1cac1e0..03dfe19 100644 --- a/tests/fullbench.c +++ b/tests/fullbench.c @@ -229,16 +229,6 @@ static int local_LZ4_saveDict(const char* in, char* out, int inSize) return LZ4_saveDict(&LZ4_stream, out, inSize); } -static int local_LZ4_compress_default(const char* in, char* out, int inSize) -{ - return LZ4_compress_default(in, out, inSize, LZ4_compressBound(inSize)); -} - -static int local_LZ4_compress_limitedOutput(const char* in, char* out, int inSize) -{ - return LZ4_compress_default(in, out, inSize, LZ4_compressBound(inSize)-1); -} - static int local_LZ4_compress_default_large(const char* in, char* out, int inSize) { return LZ4_compress_default(in, out, inSize, LZ4_compressBound(inSize)); @@ -279,26 +269,6 @@ static int local_LZ4_compress_fast_continue0(const char* in, char* out, int inSi return LZ4_compress_fast_continue(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize), 0); } -static int local_LZ4_compress_withState(const char* in, char* out, int inSize) -{ - return LZ4_compress_fast_extState(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize), 1); -} - -static int local_LZ4_compress_limitedOutput_withState(const char* in, char* out, int inSize) -{ - return LZ4_compress_fast_extState(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize)-1, 1); -} - -static int local_LZ4_compress_continue(const char* in, char* out, int inSize) -{ - return LZ4_compress_fast_continue(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize), 1); -} - -static int local_LZ4_compress_limitedOutput_continue(const char* in, char* out, int inSize) -{ - return LZ4_compress_fast_continue(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize)-1, 1); -} - #ifndef LZ4_DLL_IMPORT /* declare hidden function */ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize); @@ -328,31 +298,16 @@ static int local_LZ4_compress_HC(const char* in, char* out, int inSize) return LZ4_compress_HC(in, out, inSize, LZ4_compressBound(inSize), 9); } -static int local_LZ4_compressHC_withStateHC(const char* in, char* out, int inSize) +static int local_LZ4_compress_HC_extStateHC(const char* in, char* out, int inSize) { return LZ4_compress_HC_extStateHC(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize), 9); } -static int local_LZ4_compressHC_limitedOutput_withStateHC(const char* in, char* out, int inSize) -{ - return LZ4_compress_HC_extStateHC(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize)-1, 9); -} - -static int local_LZ4_compressHC_limitedOutput(const char* in, char* out, int inSize) -{ - return LZ4_compress_HC(in, out, inSize, LZ4_compressBound(inSize)-1, 9); -} - -static int local_LZ4_compressHC_continue(const char* in, char* out, int inSize) +static int local_LZ4_compress_HC_continue(const char* in, char* out, int inSize) { return LZ4_compress_HC_continue(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize)); } -static int local_LZ4_compressHC_limitedOutput_continue(const char* in, char* out, int inSize) -{ - return LZ4_compress_HC_continue(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize)-1); -} - /* decompression functions */ static int local_LZ4_decompress_fast(const char* in, char* out, int inSize, int outSize) @@ -530,11 +485,8 @@ int fullSpeedBench(const char** fileNamesTable, int nbFiles) case 8 : compressionFunction = local_LZ4_compress_fast_continue0; initFunction = local_LZ4_createStream; compressorName = "LZ4_compress_fast_continue(0)"; break; case 10: compressionFunction = local_LZ4_compress_HC; compressorName = "LZ4_compress_HC"; break; - case 11: compressionFunction = local_LZ4_compressHC_limitedOutput; compressorName = "LZ4_compressHC_limitedOutput"; break; - case 12 : compressionFunction = local_LZ4_compressHC_withStateHC; compressorName = "LZ4_compressHC_withStateHC"; break; - case 13: compressionFunction = local_LZ4_compressHC_limitedOutput_withStateHC; compressorName = "LZ4_compressHC_limitedOutput_withStateHC"; break; - case 14: compressionFunction = local_LZ4_compressHC_continue; initFunction = local_LZ4_resetStreamHC; compressorName = "LZ4_compressHC_continue"; break; - case 15: compressionFunction = local_LZ4_compressHC_limitedOutput_continue; initFunction = local_LZ4_resetStreamHC; compressorName = "LZ4_compressHC_limitedOutput_continue"; break; + case 12: compressionFunction = local_LZ4_compress_HC_extStateHC; compressorName = "LZ4_compress_HC_extStateHC"; break; + case 14: compressionFunction = local_LZ4_compress_HC_continue; initFunction = local_LZ4_resetStreamHC; compressorName = "LZ4_compress_HC_continue"; break; #ifndef LZ4_DLL_IMPORT case 20: compressionFunction = local_LZ4_compress_forceDict; initFunction = local_LZ4_resetDictT; compressorName = "LZ4_compress_forceDict"; break; #endif @@ -549,13 +501,6 @@ int fullSpeedBench(const char** fileNamesTable, int nbFiles) if (chunkP[0].origSize < 8) { DISPLAY(" cannot bench %s with less then 8 bytes \n", compressorName); continue; } LZ4_loadDictHC(&LZ4_streamHC, chunkP[0].origBuffer, chunkP[0].origSize); break; - case 60: DISPLAY("Obsolete compression functions : \n"); continue; - case 61: compressionFunction = local_LZ4_compress_default; compressorName = "LZ4_compress_default"; break; - case 62: compressionFunction = local_LZ4_compress_limitedOutput; compressorName = "LZ4_compress_limitedOutput"; break; - case 63: compressionFunction = local_LZ4_compress_withState; compressorName = "LZ4_compress_withState"; break; - case 64: compressionFunction = local_LZ4_compress_limitedOutput_withState; compressorName = "LZ4_compress_limitedOutput_withState"; break; - case 65: compressionFunction = local_LZ4_compress_continue; initFunction = local_LZ4_createStream; compressorName = "LZ4_compress_continue"; break; - case 66: compressionFunction = local_LZ4_compress_limitedOutput_continue; initFunction = local_LZ4_createStream; compressorName = "LZ4_compress_limitedOutput_continue"; break; default : continue; /* unknown ID : just skip */ } diff --git a/tests/fuzzer.c b/tests/fuzzer.c index 301b01a..06cfd40 100644 --- a/tests/fuzzer.c +++ b/tests/fuzzer.c @@ -170,7 +170,7 @@ static void FUZ_fillCompressibleNoiseBuffer(void* buffer, size_t bufferSize, dou static int FUZ_AddressOverflow(void) { char* buffers[MAX_NB_BUFF_I134+1]; - int i, nbBuff=0; + int nbBuff=0; int highAddress = 0; DISPLAY("Overflow tests : "); @@ -185,12 +185,13 @@ static int FUZ_AddressOverflow(void) buffers[0] = (char*)malloc(BLOCKSIZE_I134); buffers[1] = (char*)malloc(BLOCKSIZE_I134); if ((!buffers[0]) || (!buffers[1])) { + free(buffers[0]); free(buffers[1]); DISPLAY("not enough memory for tests \n"); return 0; } for (nbBuff=2; nbBuff < MAX_NB_BUFF_I134; nbBuff++) { - DISPLAY("%3i \b\b\b\b", nbBuff); + DISPLAY("%3i \b\b\b\b", nbBuff); fflush(stdout); buffers[nbBuff] = (char*)malloc(BLOCKSIZE_I134); if (buffers[nbBuff]==NULL) goto _endOfTests; @@ -201,7 +202,7 @@ static int FUZ_AddressOverflow(void) } { size_t const sizeToGenerateOverflow = (size_t)(- ((uintptr_t)buffers[nbBuff-1]) + 512); - int const nbOf255 = (int)((sizeToGenerateOverflow / 255) + 1); + unsigned const nbOf255 = (unsigned)((sizeToGenerateOverflow / 255) + 1); char* const input = buffers[nbBuff-1]; char* output = buffers[nbBuff]; int r; @@ -209,15 +210,15 @@ static int FUZ_AddressOverflow(void) input[1] = (char)0xFF; input[2] = (char)0xFF; input[3] = (char)0xFF; - for(i = 4; i <= nbOf255+4; i++) input[i] = (char)0xff; + { unsigned u; for(u = 4; u <= nbOf255+4; u++) input[u] = (char)0xff; } r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134); - if (r>0) goto _overflowError; + if (r>0) { DISPLAY("LZ4_decompress_safe = %i \n", r); goto _overflowError; } input[0] = (char)0x1F; /* Match length overflow */ input[1] = (char)0x01; input[2] = (char)0x01; input[3] = (char)0x00; r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134); - if (r>0) goto _overflowError; + if (r>0) { DISPLAY("LZ4_decompress_safe = %i \n", r); goto _overflowError; } output = buffers[nbBuff-2]; /* Reverse in/out pointer order */ input[0] = (char)0xF0; /* Literal length overflow */ @@ -237,7 +238,7 @@ static int FUZ_AddressOverflow(void) nbBuff++; _endOfTests: - for (i=0 ; i Date: Thu, 17 Nov 2016 14:02:01 -0800 Subject: fixed Travis test cases --- .travis.yml | 4 ++-- Makefile | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.travis.yml b/.travis.yml index 48ccbc6..e5db749 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,11 +17,11 @@ matrix: - os: linux sudo: false - env: Ubu=12.04cont Cmd="make gpptest-native && make clean examples && make clean cmake && make clean travis-install && make clean clangtest-native" COMPILER=cc + env: Ubu=12.04cont Cmd="make gpptest && make clean examples && make clean cmake && make clean travis-install && make clean clangtest" COMPILER=cc # 14.04 LTS Server Edition 64 bit - - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc + - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 clean versionsTest' COMPILER=cc dist: trusty sudo: required addons: diff --git a/Makefile b/Makefile index cbf0932..be662a5 100644 --- a/Makefile +++ b/Makefile @@ -116,8 +116,8 @@ platformTest: clean @echo "\n ---- test lz4 with $(CC) compiler ----" @$(CC) -v CFLAGS="-O3 -Werror" $(MAKE) -C $(LZ4DIR) all - CFLAGS="-O3 -Werror -static" $(MAKE) -C $(PRGDIR) native - CFLAGS="-O3 -Werror -static" $(MAKE) -C $(TESTDIR) native + CFLAGS="-O3 -Werror -static" $(MAKE) -C $(PRGDIR) all + CFLAGS="-O3 -Werror -static" $(MAKE) -C $(TESTDIR) all $(MAKE) -C $(TESTDIR) test-platform versionsTest: clean @@ -151,11 +151,11 @@ gpptest: clean CC=g++ $(MAKE) -C $(PRGDIR) all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" CC=g++ $(MAKE) -C $(TESTDIR) all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" -gpptest-native: clean +gpptest32: clean g++ -v - CC=g++ $(MAKE) -C $(LZ4DIR) all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" - CC=g++ $(MAKE) -C $(PRGDIR) native CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" - CC=g++ $(MAKE) -C $(TESTDIR) native CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" + CC=g++ $(MAKE) -C $(LZ4DIR) all CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" + CC=g++ $(MAKE) -C $(PRGDIR) native CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" + CC=g++ $(MAKE) -C $(TESTDIR) native CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror" c_standards: clean $(MAKE) all MOREFLAGS="-std=gnu90 -Werror" -- cgit v0.12 From 7d535484738f5536ec3a4eab58146f8c3f6f6834 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 14:39:49 -0800 Subject: added v1.x.y to versions tests --- tests/.gitignore | 1 + tests/Makefile | 1 + tests/test-lz4-versions.py | 4 +++- 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/.gitignore b/tests/.gitignore index 06891ac..4c0f311 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -11,3 +11,4 @@ fasttest # test artefacts tmp* +versionsTest diff --git a/tests/Makefile b/tests/Makefile index 4b0f503..c1ec43d 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -104,6 +104,7 @@ datagen : $(PRGDIR)/datagen.c datagencli.c clean: @$(MAKE) -C $(LIBDIR) $@ > $(VOID) + @$(MAKE) -C $(PRGDIR) $@ > $(VOID) @$(RM) core *.o *.test tmp* \ fullbench-dll$(EXT) fullbench-lib$(EXT) \ fullbench$(EXT) fullbench32$(EXT) \ diff --git a/tests/test-lz4-versions.py b/tests/test-lz4-versions.py index 54b7e13..12c1c66 100644 --- a/tests/test-lz4-versions.py +++ b/tests/test-lz4-versions.py @@ -21,7 +21,7 @@ make_cmd = 'make' git_cmd = 'git' test_dat_src = 'README.md' test_dat = 'test_dat' -head = 'r999' +head = 'v999' def proc(cmd_args, pipe=True, dummy=False): if dummy: @@ -43,6 +43,8 @@ def git(args, pipe=True): def get_git_tags(): stdout, stderr = git(['tag', '-l', 'r[0-9][0-9][0-9]']) tags = stdout.decode('utf-8').split() + stdout, stderr = git(['tag', '-l', 'v[1-9].[0-9].[0-9]']) + tags += stdout.decode('utf-8').split() return tags # https://stackoverflow.com/a/19711609/2132223 -- cgit v0.12 From c0e55ec05f5621bfc16a0f54dedef2a49f48634d Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 14:54:30 -0800 Subject: fixed versionsTest --- .travis.yml | 2 +- programs/Makefile | 5 +++-- tests/Makefile | 1 + tests/test-lz4-versions.py | 4 ++-- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index e5db749..58eee4c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,7 +21,7 @@ matrix: # 14.04 LTS Server Edition 64 bit - - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 clean versionsTest' COMPILER=cc + - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc dist: trusty sudo: required addons: diff --git a/programs/Makefile b/programs/Makefile index 2f1c3cc..9939a44 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -68,13 +68,14 @@ lz4-release: lz4 lz4c : $(LZ4DIR)/lz4.o $(LZ4DIR)/lz4hc.o $(LZ4DIR)/lz4frame.o $(LZ4DIR)/xxhash.o bench.o lz4io.o lz4cli.c datagen.o $(CC) $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) -lz4c32: CFLAGS += -m32 +lz4c32: CFLAGS+=-m32 lz4c32: lz4 + @cp lz4$(EXT) lz4c32$(EXT) clean: @$(MAKE) -C $(LZ4DIR) $@ > $(VOID) @$(RM) core *.o *.test tmp* \ - lz4$(EXT) lz4c$(EXT) + lz4$(EXT) lz4c$(EXT) lz4c32$(EXT) @echo Cleaning completed diff --git a/tests/Makefile b/tests/Makefile index c1ec43d..288b665 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -114,6 +114,7 @@ clean: @rm -fR $(TESTDIR) @echo Cleaning completed +.PHONY: versionsTest versionsTest: $(PYTHON) test-lz4-versions.py diff --git a/tests/test-lz4-versions.py b/tests/test-lz4-versions.py index 12c1c66..d7fd199 100644 --- a/tests/test-lz4-versions.py +++ b/tests/test-lz4-versions.py @@ -84,11 +84,11 @@ if __name__ == '__main__': os.chdir(clone_dir) git(['--work-tree=' + r_dir, 'checkout', tag, '--', '.'], False) os.chdir(r_dir + '/programs') # /path/to/lz4/lz4test//programs - make(['clean', 'lz4c', 'lz4c32'], False) else: os.chdir(programs_dir) - make(['lz4c', 'lz4c32'], False) + make(['clean', 'lz4c'], False) shutil.copy2('lz4c', dst_lz4c) + make(['clean', 'lz4c32'], False) shutil.copy2('lz4c32', dst_lz4c32) # Compress test.dat by all released lz4c and lz4c32 -- cgit v0.12 From 3f6f57768752a5687c2715ad4a7cd4ebfa502bc2 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 15:34:07 -0800 Subject: fixed strict aliasing warnings in fasttest --- tests/fasttest.c | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/tests/fasttest.c b/tests/fasttest.c index 7694e0c..a165293 100644 --- a/tests/fasttest.c +++ b/tests/fasttest.c @@ -51,12 +51,6 @@ int test_compress(const char *input, int inSize, char *output, int outSize) return 0; } -void swap(void **a, void **b) { - void *tmp = *a; - *a = *b; - *b = tmp; -} - /* Returns non-zero on failure. Not a safe function. */ int test_decompress(const char *uncompressed, const char *compressed) { @@ -91,11 +85,10 @@ int test_decompress(const char *uncompressed, const char *compressed) lz4StreamDecode, compressed + offset, output, unBytes); if(bytes <= 0) return 2; /* Check result */ - { - int r = memcmp(uncompressed + unOffset, output, unBytes); + { int const r = memcmp(uncompressed + unOffset, output, unBytes); if (r) return 3; } - swap((void**)&output, (void**)&lastOutput); + { char* const tmp = output; output = lastOutput; lastOutput = tmp; } offset += bytes; unOffset += unBytes; lastBytes = unBytes; -- cgit v0.12 From 8f536a43b15daf1ff7e8c0cffe387f8227f72dd3 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 18:06:22 -0800 Subject: added sanitize32 tests to Travis --- .travis.yml | 38 +++++++++++++++++++++++--------------- Makefile | 3 +++ 2 files changed, 26 insertions(+), 15 deletions(-) diff --git a/.travis.yml b/.travis.yml index 58eee4c..12d7816 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,32 +21,50 @@ matrix: # 14.04 LTS Server Edition 64 bit - - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc + - env: Ubu=14.04 Cmd='make c_standards CC=gcc-6 && make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror' COMPILER=gcc-6 + dist: trusty + sudo: required + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - gcc-6 + + - env: Ubu=14.04 Cmd='make sanitize32' COMPILER=clang dist: trusty sudo: required addons: apt: packages: - - python3 - libc6-dev-i386 - gcc-multilib - - env: Ubu=14.04 Cmd='make -C tests test-frametest32 test-fuzzer32' COMPILER=cc + - env: Ubu=14.04 Cmd='make sanitize' COMPILER=clang dist: trusty sudo: required addons: apt: packages: + + - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc + dist: trusty + sudo: required + addons: + apt: + packages: + - python3 - libc6-dev-i386 - gcc-multilib - - env: Ubu=14.04 Cmd='make sanitize' COMPILER=clang + - env: Ubu=14.04 Cmd='make -C tests test-frametest32 test-fuzzer32' COMPILER=cc dist: trusty sudo: required addons: apt: packages: - - valgrind + - libc6-dev-i386 + - gcc-multilib - env: Ubu=14.04 Cmd='make staticAnalyze' COMPILER=clang dist: trusty @@ -100,16 +118,6 @@ matrix: - gcc-5 - gcc-5-multilib - - env: Ubu=14.04 Cmd='make c_standards CC=gcc-6 && make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror' COMPILER=gcc-6 - dist: trusty - sudo: required - addons: - apt: - sources: - - ubuntu-toolchain-r-test - packages: - - gcc-6 - - env: Ubu=14.04 Cmd='make -C tests test-lz4 CC=clang-3.8' COMPILER=clang-3.8 dist: trusty sudo: required diff --git a/Makefile b/Makefile index be662a5..3a5af81 100644 --- a/Makefile +++ b/Makefile @@ -109,6 +109,9 @@ clangtest-native: clean sanitize: clean CFLAGS="-O3 -g -fsanitize=undefined" $(MAKE) test CC=clang FUZZER_TIME="-T1mn" NB_LOOPS=-i1 +sanitize32: clean + CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test CC=clang FUZZER_TIME="-T1mn" NB_LOOPS=-i1 + staticAnalyze: clean CFLAGS=-g scan-build --status-bugs -v $(MAKE) all -- cgit v0.12 From 8e1ea59ad6e0a91c11d6c290330cd1dfe5e5eced Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 18:30:46 -0800 Subject: attempt to fix sanitize32 package dependency --- .travis.yml | 2 ++ lib/lz4.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 12d7816..3ab2647 100644 --- a/.travis.yml +++ b/.travis.yml @@ -37,6 +37,7 @@ matrix: addons: apt: packages: + - clang - libc6-dev-i386 - gcc-multilib @@ -46,6 +47,7 @@ matrix: addons: apt: packages: + - clang - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc dist: trusty diff --git a/lib/lz4.c b/lib/lz4.c index bdbc73f..c4b0154 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -148,7 +148,7 @@ typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; - typedef size_t uptrval; /* generally true, except OpenVMS-64 */ + typedef size_t uptrval; /* generally true, except OpenVMS-64 */ #endif -- cgit v0.12 From 71814a26f2f9c86cfe81c77a08c84e00bd08e90b Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 18:41:26 -0800 Subject: switch usan32 tests to gcc-5 --- .travis.yml | 8 ++++---- Makefile | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3ab2647..785553a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -31,17 +31,17 @@ matrix: packages: - gcc-6 - - env: Ubu=14.04 Cmd='make sanitize32' COMPILER=clang + - env: Ubu=14.04 Cmd='make usan32' COMPILER=gcc-5 dist: trusty sudo: required addons: apt: packages: - clang - - libc6-dev-i386 - - gcc-multilib + - gcc-5 + - gcc-5-multilib - - env: Ubu=14.04 Cmd='make sanitize' COMPILER=clang + - env: Ubu=14.04 Cmd='make usan' COMPILER=clang dist: trusty sudo: required addons: diff --git a/Makefile b/Makefile index 3a5af81..15acdf9 100644 --- a/Makefile +++ b/Makefile @@ -106,11 +106,11 @@ clangtest-native: clean @CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(PRGDIR) native CC=clang @CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(TESTDIR) native CC=clang -sanitize: clean - CFLAGS="-O3 -g -fsanitize=undefined" $(MAKE) test CC=clang FUZZER_TIME="-T1mn" NB_LOOPS=-i1 +usan: clean + CC=clang CFLAGS="-O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1 -sanitize32: clean - CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test CC=clang FUZZER_TIME="-T1mn" NB_LOOPS=-i1 +usan32: clean + CC=clang CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1 staticAnalyze: clean CFLAGS=-g scan-build --status-bugs -v $(MAKE) all -- cgit v0.12 From a4f4bf21eb43d7e731b6379716ec62e564f93402 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 18:59:14 -0800 Subject: fixed gcc-5 conf --- .travis.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 785553a..803ecb4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -36,8 +36,11 @@ matrix: sudo: required addons: apt: + sources: + - ubuntu-toolchain-r-test packages: - - clang + - libc6-dev-i386 + - gcc-multilib - gcc-5 - gcc-5-multilib -- cgit v0.12 From ffc8c18c1387987c480e831b6736767cdc7d74c7 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 19:08:41 -0800 Subject: usan32 relies on default compiler (by default) --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 15acdf9..a97c4ed 100644 --- a/Makefile +++ b/Makefile @@ -110,7 +110,7 @@ usan: clean CC=clang CFLAGS="-O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1 usan32: clean - CC=clang CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1 + CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1 staticAnalyze: clean CFLAGS=-g scan-build --status-bugs -v $(MAKE) all -- cgit v0.12 From 7a22904a7249f48ddde3467388273d871fb957b0 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 19:21:52 -0800 Subject: moved usan32 tests to gcc-6 --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 803ecb4..3a696a5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -31,7 +31,7 @@ matrix: packages: - gcc-6 - - env: Ubu=14.04 Cmd='make usan32' COMPILER=gcc-5 + - env: Ubu=14.04 Cmd='make usan32' COMPILER=gcc-6 dist: trusty sudo: required addons: @@ -41,8 +41,8 @@ matrix: packages: - libc6-dev-i386 - gcc-multilib - - gcc-5 - - gcc-5-multilib + - gcc-6 + - gcc-6-multilib - env: Ubu=14.04 Cmd='make usan' COMPILER=clang dist: trusty -- cgit v0.12 From 6cabcd151f01c2e56de16030dc79bed25711016d Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 17 Nov 2016 19:28:20 -0800 Subject: removed usan32 tests. Let's summarize : gcc-5 and gcc-6 on Travis do not support UB sanitizer. And clang on Travis is not able to generate -m32 code. Great. It makes the combination impossible to test on Travis ... :( --- .travis.yml | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3a696a5..bf7c7f2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -31,19 +31,6 @@ matrix: packages: - gcc-6 - - env: Ubu=14.04 Cmd='make usan32' COMPILER=gcc-6 - dist: trusty - sudo: required - addons: - apt: - sources: - - ubuntu-toolchain-r-test - packages: - - libc6-dev-i386 - - gcc-multilib - - gcc-6 - - gcc-6-multilib - - env: Ubu=14.04 Cmd='make usan' COMPILER=clang dist: trusty sudo: required -- cgit v0.12 From a91983daa04bc0ba9330f95d3a4922c7e34d404e Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Fri, 18 Nov 2016 17:05:06 -0800 Subject: highly improved speed on -mx32 mode Now -mx32 is fastest mode on x64 CPU --- lib/lz4.c | 84 ++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 40 insertions(+), 44 deletions(-) diff --git a/lib/lz4.c b/lib/lz4.c index c4b0154..fc19493 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -151,14 +151,15 @@ typedef size_t uptrval; /* generally true, except OpenVMS-64 */ #endif +#if defined(__x86_64__) + typedef U64 reg_t; /* 64-bits in x32 mode */ +#else + typedef size_t reg_t; /* 32-bits in x32 mode */ +#endif /*-************************************ * Reading and writing into memory **************************************/ -#define STEPSIZE sizeof(size_t) - -static unsigned LZ4_64bits(void) { return sizeof(void*)==8; } - static unsigned LZ4_isLittleEndian(void) { const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ @@ -171,7 +172,7 @@ static unsigned LZ4_isLittleEndian(void) static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; } static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; } -static size_t LZ4_read_ARCH(const void* memPtr) { return *(const size_t*) memPtr; } +static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; } static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } @@ -180,11 +181,11 @@ static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ -typedef union { U16 u16; U32 u32; size_t uArch; } __attribute__((packed)) unalign; +typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) unalign; static U16 LZ4_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } static U32 LZ4_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } -static size_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArch; } +static reg_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArch; } static void LZ4_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } @@ -201,9 +202,9 @@ static U32 LZ4_read32(const void* memPtr) U32 val; memcpy(&val, memPtr, sizeof(val)); return val; } -static size_t LZ4_read_ARCH(const void* memPtr) +static reg_t LZ4_read_ARCH(const void* memPtr) { - size_t val; memcpy(&val, memPtr, sizeof(val)); return val; + reg_t val; memcpy(&val, memPtr, sizeof(val)); return val; } static void LZ4_write16(void* memPtr, U16 value) @@ -252,12 +253,6 @@ static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd) const BYTE* s = (const BYTE*)srcPtr; BYTE* const e = (BYTE*)dstEnd; -#if 0 - const size_t l2 = 8 - (((size_t)d) & (sizeof(void*)-1)); - LZ4_copy8(d,s); if (d>e-9) return; - d+=l2; s+=l2; -#endif /* join to align */ - do { LZ4_copy8(d,s); d+=8; s+=8; } while (d> 24) * prime8bytes) >> (64 - hashLog)); } -FORCE_INLINE U32 LZ4_hashPosition(const void* p, tableType_t const tableType) +FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType) { - if ((LZ4_64bits()) && (tableType == byU32)) return LZ4_hash5(LZ4_read_ARCH(p), tableType); + if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType); return LZ4_hash4(LZ4_read32(p), tableType); } @@ -460,7 +456,7 @@ FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableTy /** LZ4_compress_generic() : inlined, to ensure branches are decided at compilation time */ FORCE_INLINE int LZ4_compress_generic( - LZ4_stream_t_internal* const dictPtr, + LZ4_stream_t_internal* const cctx, const char* const source, char* const dest, const int inputSize, @@ -474,10 +470,10 @@ FORCE_INLINE int LZ4_compress_generic( const BYTE* ip = (const BYTE*) source; const BYTE* base; const BYTE* lowLimit; - const BYTE* const lowRefLimit = ip - dictPtr->dictSize; - const BYTE* const dictionary = dictPtr->dictionary; - const BYTE* const dictEnd = dictionary + dictPtr->dictSize; - const size_t dictDelta = dictEnd - (const BYTE*)source; + const BYTE* const lowRefLimit = ip - cctx->dictSize; + const BYTE* const dictionary = cctx->dictionary; + const BYTE* const dictEnd = dictionary + cctx->dictSize; + const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source; const BYTE* anchor = (const BYTE*) source; const BYTE* const iend = ip + inputSize; const BYTE* const mflimit = iend - MFLIMIT; @@ -487,7 +483,6 @@ FORCE_INLINE int LZ4_compress_generic( BYTE* const olimit = op + maxOutputSize; U32 forwardH; - size_t refDelta=0; /* Init conditions */ if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0; /* Unsupported inputSize, too large (or negative) */ @@ -499,11 +494,11 @@ FORCE_INLINE int LZ4_compress_generic( lowLimit = (const BYTE*)source; break; case withPrefix64k: - base = (const BYTE*)source - dictPtr->currentOffset; - lowLimit = (const BYTE*)source - dictPtr->dictSize; + base = (const BYTE*)source - cctx->currentOffset; + lowLimit = (const BYTE*)source - cctx->dictSize; break; case usingExtDict: - base = (const BYTE*)source - dictPtr->currentOffset; + base = (const BYTE*)source - cctx->currentOffset; lowLimit = (const BYTE*)source; break; } @@ -511,11 +506,12 @@ FORCE_INLINE int LZ4_compress_generic( if (inputSizehashTable, tableType, base); + LZ4_putPosition(ip, cctx->hashTable, tableType, base); ip++; forwardH = LZ4_hashPosition(ip, tableType); /* Main Loop */ for ( ; ; ) { + ptrdiff_t refDelta = 0; const BYTE* match; BYTE* token; @@ -531,7 +527,7 @@ FORCE_INLINE int LZ4_compress_generic( if (unlikely(forwardIp > mflimit)) goto _last_literals; - match = LZ4_getPositionOnHash(h, dictPtr->hashTable, tableType, base); + match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base); if (dict==usingExtDict) { if (match < (const BYTE*)source) { refDelta = dictDelta; @@ -541,7 +537,7 @@ FORCE_INLINE int LZ4_compress_generic( lowLimit = (const BYTE*)source; } } forwardH = LZ4_hashPosition(forwardIp, tableType); - LZ4_putPositionOnHash(ip, h, dictPtr->hashTable, tableType, base); + LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base); } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0) || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip)) @@ -614,10 +610,10 @@ _next_match: if (ip > mflimit) break; /* Fill table */ - LZ4_putPosition(ip-2, dictPtr->hashTable, tableType, base); + LZ4_putPosition(ip-2, cctx->hashTable, tableType, base); /* Test next position */ - match = LZ4_getPosition(ip, dictPtr->hashTable, tableType, base); + match = LZ4_getPosition(ip, cctx->hashTable, tableType, base); if (dict==usingExtDict) { if (match < (const BYTE*)source) { refDelta = dictDelta; @@ -626,7 +622,7 @@ _next_match: refDelta = 0; lowLimit = (const BYTE*)source; } } - LZ4_putPosition(ip, dictPtr->hashTable, tableType, base); + LZ4_putPosition(ip, cctx->hashTable, tableType, base); if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1) && (match+MAX_DISTANCE>=ip) && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) ) @@ -669,12 +665,12 @@ int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int if (inputSize < LZ4_64Klimit) return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited, byU16, noDict, noDictIssue, acceleration); else - return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration); + return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration); } else { if (inputSize < LZ4_64Klimit) return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration); else - return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration); + return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration); } } @@ -713,7 +709,7 @@ int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int m if (inputSize < LZ4_64Klimit) return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration); else - return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration); + return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration); } @@ -887,7 +883,7 @@ static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, if (*srcSizePtr < LZ4_64Klimit) return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16); else - return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, LZ4_64bits() ? byU32 : byPtr); + return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr); } } @@ -935,7 +931,7 @@ int LZ4_freeStream (LZ4_stream_t* LZ4_stream) } -#define HASH_UNIT sizeof(size_t) +#define HASH_UNIT sizeof(reg_t) int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) { LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse; @@ -971,7 +967,7 @@ int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src) { if ((LZ4_dict->currentOffset > 0x80000000) || - ((size_t)LZ4_dict->currentOffset > (size_t)src)) { /* address space overflow */ + ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) { /* address space overflow */ /* rescale hash table */ U32 const delta = LZ4_dict->currentOffset - 64 KB; const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize; @@ -1432,7 +1428,7 @@ static void LZ4_init(LZ4_stream_t* lz4ds, BYTE* base) int LZ4_resetStreamState(void* state, char* inputBuffer) { - if ((((size_t)state) & 3) != 0) return 1; /* Error : pointer is not aligned on 4-bytes boundary */ + if ((((uptrval)state) & 3) != 0) return 1; /* Error : pointer is not aligned on 4-bytes boundary */ LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer); return 0; } -- cgit v0.12 From 519932afaf5a1d85e5d39de4acebc0a6bc07b9e3 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Fri, 18 Nov 2016 17:16:51 -0800 Subject: attempt -mx32 tests on Travis CI --- .travis.yml | 9 +++++++++ NEWS | 1 + 2 files changed, 10 insertions(+) diff --git a/.travis.yml b/.travis.yml index bf7c7f2..9b73d1f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -58,6 +58,15 @@ matrix: - libc6-dev-i386 - gcc-multilib + - env: Ubu=14.04 Cmd='make -C tests test MOREFLAGS=-mx32' COMPILER=cc + dist: trusty + sudo: required + addons: + apt: + packages: + - libc6-dev-i386 + - gcc-multilib + - env: Ubu=14.04 Cmd='make staticAnalyze' COMPILER=clang dist: trusty sudo: required diff --git a/NEWS b/NEWS index b67bf39..1b2daa4 100644 --- a/NEWS +++ b/NEWS @@ -1,4 +1,5 @@ v1.7.4 +Improved : much better speed in -mx32 mode cli : fix : Large file support in 32-bits mode on Mac OS-X v1.7.3 -- cgit v0.12 From 19df3029e234e4c48c31377c9ef5f7c940da5106 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Fri, 18 Nov 2016 17:54:26 -0800 Subject: fixed #272 (compilation fails on gcc 4.4), reported by @totaam --- Makefile | 6 +++++- NEWS | 1 + README.md | 2 ++ lib/Makefile | 4 ++-- lib/lz4.h | 5 +++-- tests/Makefile | 2 +- 6 files changed, 14 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index a97c4ed..25cedbc 100644 --- a/Makefile +++ b/Makefile @@ -51,7 +51,7 @@ endif .PHONY: default all lib lz4 clean test versionsTest examples -default: lib lz4 +default: lib lz4-release all: @$(MAKE) -C $(LZ4DIR) $@ @@ -62,6 +62,10 @@ lib: @$(MAKE) -C $(LZ4DIR) lz4: + @$(MAKE) -C $(PRGDIR) $@ + @cp $(PRGDIR)/lz4$(EXT) . + +lz4-release: @$(MAKE) -C $(PRGDIR) @cp $(PRGDIR)/lz4$(EXT) . diff --git a/NEWS b/NEWS index 1b2daa4..bb9d1fb 100644 --- a/NEWS +++ b/NEWS @@ -1,6 +1,7 @@ v1.7.4 Improved : much better speed in -mx32 mode cli : fix : Large file support in 32-bits mode on Mac OS-X +fix : compilation on gcc 4.4 (#282), reported by Antoine Martin v1.7.3 Changed : moved to versioning; package, cli and library have same version number diff --git a/README.md b/README.md index 1b4a007..04ba0db 100644 --- a/README.md +++ b/README.md @@ -70,6 +70,8 @@ in single-thread mode. [zlib]: http://www.zlib.net/ [Zstandard]: http://www.zstd.net/ +LZ4 is also compatible and well optimized for x32 mode, for which it provides +10% speed performance. + Documentation ------------------------- diff --git a/lib/Makefile b/lib/Makefile index 216d136..d6e3668 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -46,7 +46,7 @@ DESTDIR?= PREFIX ?= /usr/local CPPFLAGS= -DXXH_NAMESPACE=LZ4_ CFLAGS ?= -O3 -CFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \ +CFLAGS += -g -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \ -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes -Wundef \ -Wpointer-arith -Wstrict-aliasing=1 CFLAGS += $(MOREFLAGS) @@ -102,7 +102,7 @@ else endif clean: - @$(RM) core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* liblz4.pc dll/liblz4.dll dll/liblz4.lib + @$(RM) core *.o *.a *.$(SHARED_EXT) liblz4.pc dll/liblz4.dll dll/liblz4.lib @echo Cleaning library completed diff --git a/lib/lz4.h b/lib/lz4.h index ec758fe..49854e4 100644 --- a/lib/lz4.h +++ b/lib/lz4.h @@ -412,9 +412,10 @@ union LZ4_streamDecode_u { #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS # define LZ4_DEPRECATED(message) /* disable deprecation warnings */ #else -# if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) +# define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +# if (LZ4_GCC_VERSION >= 405) || defined(__clang__) # define LZ4_DEPRECATED(message) __attribute__((deprecated(message))) -# elif defined(__GNUC__) && (__GNUC__ >= 3) +# elif (LZ4_GCC_VERSION >= 301) # define LZ4_DEPRECATED(message) __attribute__((deprecated)) # elif defined(_MSC_VER) # define LZ4_DEPRECATED(message) __declspec(deprecated(message)) diff --git a/tests/Makefile b/tests/Makefile index 288b665..e58d449 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -39,7 +39,7 @@ TESTDIR := versionsTest PYTHON ?= python3 CFLAGS ?= -O3 # can select custom flags. For example : CFLAGS="-O2 -g" make -CFLAGS += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum \ +CFLAGS += -g -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum \ -Wdeclaration-after-statement -Wstrict-prototypes \ -Wpointer-arith -Wstrict-aliasing=1 CFLAGS += $(MOREFLAGS) -- cgit v0.12 From a38cbf9f62a9d7200086b9965745ad7330cac259 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Fri, 18 Nov 2016 18:00:54 -0800 Subject: fixed : shadow global variable on gcc 4.4 (minor) --- programs/lz4io.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/programs/lz4io.c b/programs/lz4io.c index e8eaf60..2ffb541 100644 --- a/programs/lz4io.c +++ b/programs/lz4io.c @@ -853,17 +853,17 @@ static unsigned long long LZ4IO_decompressLZ4F(dRess_t ress, FILE* srcFile, FILE static unsigned long long LZ4IO_passThrough(FILE* finput, FILE* foutput, unsigned char MNstore[MAGICNUMBER_SIZE]) { size_t buffer[PTSIZET]; - size_t read = 1; + size_t readBytes = 1; unsigned long long total = MAGICNUMBER_SIZE; unsigned storedSkips = 0; size_t const sizeCheck = fwrite(MNstore, 1, MAGICNUMBER_SIZE, foutput); if (sizeCheck != MAGICNUMBER_SIZE) EXM_THROW(50, "Pass-through write error"); - while (read) { - read = fread(buffer, 1, PTSIZE, finput); - total += read; - storedSkips = LZ4IO_fwriteSparse(foutput, buffer, read, storedSkips); + while (readBytes) { + readBytes = fread(buffer, 1, PTSIZE, finput); + total += readBytes; + storedSkips = LZ4IO_fwriteSparse(foutput, buffer, readBytes, storedSkips); } if (ferror(finput)) EXM_THROW(51, "Read Error") -- cgit v0.12 From b4db9d7e35e67f509b6d6741efddd8ec087398a2 Mon Sep 17 00:00:00 2001 From: Takayuki MATSUOKA Date: Sat, 19 Nov 2016 22:08:48 +0900 Subject: Add C++14 standard [[deprecated]] attribute See also For __cplusplus predefined macro, https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html For [[deprecated]] attribute, https://isocpp.org/wiki/faq/cpp14-language#deprecated-attribute --- lib/lz4.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/lz4.h b/lib/lz4.h index 49854e4..7420ad8 100644 --- a/lib/lz4.h +++ b/lib/lz4.h @@ -413,7 +413,9 @@ union LZ4_streamDecode_u { # define LZ4_DEPRECATED(message) /* disable deprecation warnings */ #else # define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) -# if (LZ4_GCC_VERSION >= 405) || defined(__clang__) +# if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ +# define LZ4_DEPRECATED(message) [[deprecated(message)]] +# elif (LZ4_GCC_VERSION >= 405) || defined(__clang__) # define LZ4_DEPRECATED(message) __attribute__((deprecated(message))) # elif (LZ4_GCC_VERSION >= 301) # define LZ4_DEPRECATED(message) __attribute__((deprecated)) -- cgit v0.12 From 2dbcebfdac45351abdbbd78c56898691bb6147db Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 11:10:57 -0800 Subject: changes travis test order --- .travis.yml | 60 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9b73d1f..6934175 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,15 +21,14 @@ matrix: # 14.04 LTS Server Edition 64 bit - - env: Ubu=14.04 Cmd='make c_standards CC=gcc-6 && make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror' COMPILER=gcc-6 + - env: Ubu=14.04 Cmd='make -C tests test MOREFLAGS=-mx32' COMPILER=cc dist: trusty sudo: required addons: apt: - sources: - - ubuntu-toolchain-r-test packages: - - gcc-6 + - libc6-dev-i386 + - gcc-multilib - env: Ubu=14.04 Cmd='make usan' COMPILER=clang dist: trusty @@ -39,26 +38,25 @@ matrix: packages: - clang - - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc + - env: Ubu=14.04 Cmd='make c_standards && make -C tests test-lz4 test-mem' COMPILER=cc dist: trusty sudo: required addons: apt: packages: - - python3 - - libc6-dev-i386 - - gcc-multilib + - valgrind - - env: Ubu=14.04 Cmd='make -C tests test-frametest32 test-fuzzer32' COMPILER=cc + - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc dist: trusty sudo: required addons: apt: packages: + - python3 - libc6-dev-i386 - gcc-multilib - - env: Ubu=14.04 Cmd='make -C tests test MOREFLAGS=-mx32' COMPILER=cc + - env: Ubu=14.04 Cmd='make -C tests test-frametest32 test-fuzzer32' COMPILER=cc dist: trusty sudo: required addons: @@ -67,13 +65,15 @@ matrix: - libc6-dev-i386 - gcc-multilib - - env: Ubu=14.04 Cmd='make staticAnalyze' COMPILER=clang + - env: Ubu=14.04 Cmd='make c_standards CC=gcc-6 && make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror' COMPILER=gcc-6 dist: trusty sudo: required addons: apt: + sources: + - ubuntu-toolchain-r-test packages: - - clang + - gcc-6 - env: Ubu=14.04 Cmd='make platformTest CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static && make platformTest CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static' COMPILER=arm-linux-gnueabi-gcc dist: trusty @@ -88,24 +88,6 @@ matrix: - gcc-aarch64-linux-gnu - libc6-dev-arm64-cross - - env: Ubu=14.04 Cmd='make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static && make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS=-m64' COMPILER=powerpc-linux-gnu-gcc - dist: trusty - sudo: required - addons: - apt: - packages: - - qemu-system-ppc - - qemu-user-static - - gcc-powerpc-linux-gnu - - - env: Ubu=14.04 Cmd='make c_standards && make -C tests test-lz4 test-mem' COMPILER=cc - dist: trusty - sudo: required - addons: - apt: - packages: - - valgrind - - env: Ubu=14.04 Cmd='make -C tests test-lz4 clean test-lz4c32 CC=gcc-5 MOREFLAGS=-Werror' COMPILER=gcc-5 dist: trusty sudo: required @@ -130,6 +112,24 @@ matrix: packages: - clang-3.8 + - env: Ubu=14.04 Cmd='make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static && make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS=-m64' COMPILER=powerpc-linux-gnu-gcc + dist: trusty + sudo: required + addons: + apt: + packages: + - qemu-system-ppc + - qemu-user-static + - gcc-powerpc-linux-gnu + + - env: Ubu=14.04 Cmd='make staticAnalyze' COMPILER=clang + dist: trusty + sudo: required + addons: + apt: + packages: + - clang + script: - echo Cmd=$Cmd - $COMPILER -v -- cgit v0.12 From 742f2b683e948d837aff607a2cfff6f67b039f54 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 14:13:00 -0800 Subject: added doc in code comments --- lib/lz4frame.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/lib/lz4frame.h b/lib/lz4frame.h index e26be76..9449e0d 100644 --- a/lib/lz4frame.h +++ b/lib/lz4frame.h @@ -130,6 +130,10 @@ typedef LZ4F_frameType_t frameType_t; typedef LZ4F_contentChecksum_t contentChecksum_t; #endif +/* LZ4F_frameInfo_t : + * makes it possible to supply detailed frame parameters to the stream interface. + * It's not required to set all fields, as long as the structure was initially memset() to zero. + * All reserved fields must be set to zero. */ typedef struct { LZ4F_blockSizeID_t blockSizeID; /* max64KB, max256KB, max1MB, max4MB ; 0 == default */ LZ4F_blockMode_t blockMode; /* blockLinked, blockIndependent ; 0 == default */ @@ -139,6 +143,10 @@ typedef struct { unsigned reserved[2]; /* must be zero for forward compatibility */ } LZ4F_frameInfo_t; +/* LZ4F_preferences_t : + * makes it possible to supply detailed compression parameters to the stream interface. + * It's not required to set all fields, as long as the structure was initially memset() to zero. + * All reserved fields must be set to zero. */ typedef struct { LZ4F_frameInfo_t frameInfo; int compressionLevel; /* 0 == default (fast mode); values above 16 count as 16; values below 0 count as 0 */ -- cgit v0.12 From 2fe3aa9854ef761bb66b109d623b18b9bad91a67 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 15:00:50 -0800 Subject: added examples to make all --- Makefile | 3 +++ examples/HCStreaming_ringBuffer.c | 7 ++++--- examples/blockStreaming_ringBuffer.c | 7 ++++--- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index 25cedbc..700d772 100644 --- a/Makefile +++ b/Makefile @@ -39,6 +39,7 @@ INCLUDEDIR=$(PREFIX)/include LZ4DIR = lib PRGDIR = programs TESTDIR = tests +EXDIR = examples # Define nul output @@ -57,6 +58,7 @@ all: @$(MAKE) -C $(LZ4DIR) $@ @$(MAKE) -C $(PRGDIR) $@ @$(MAKE) -C $(TESTDIR) $@ + @$(MAKE) -C $(EXDIR) $@ lib: @$(MAKE) -C $(LZ4DIR) @@ -73,6 +75,7 @@ clean: @$(MAKE) -C $(PRGDIR) $@ > $(VOID) @$(MAKE) -C $(TESTDIR) $@ > $(VOID) @$(MAKE) -C $(LZ4DIR) $@ > $(VOID) + @$(MAKE) -C $(EXDIR) $@ > $(VOID) @$(MAKE) -C examples $@ > $(VOID) @$(RM) lz4$(EXT) @echo Cleaning completed diff --git a/examples/HCStreaming_ringBuffer.c b/examples/HCStreaming_ringBuffer.c index cfae9d7..a9c00f4 100644 --- a/examples/HCStreaming_ringBuffer.c +++ b/examples/HCStreaming_ringBuffer.c @@ -68,8 +68,9 @@ void test_compress(FILE* outFp, FILE* inpFp) if (0 == inpBytes) break; { - char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)]; - const int cmpBytes = LZ4_compressHC_continue(lz4Stream, inpPtr, cmpBuf, inpBytes); +#define CMPBUFSIZE (LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)) + char cmpBuf[CMPBUFSIZE]; + const int cmpBytes = LZ4_compress_HC_continue(lz4Stream, inpPtr, cmpBuf, inpBytes, CMPBUFSIZE); if(cmpBytes <= 0) break; write_int32(outFp, cmpBytes); @@ -97,7 +98,7 @@ void test_decompress(FILE* outFp, FILE* inpFp) for(;;) { int cmpBytes = 0; - char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)]; + char cmpBuf[CMPBUFSIZE]; { const size_t r0 = read_int32(inpFp, &cmpBytes); diff --git a/examples/blockStreaming_ringBuffer.c b/examples/blockStreaming_ringBuffer.c index beb5e66..697d342 100644 --- a/examples/blockStreaming_ringBuffer.c +++ b/examples/blockStreaming_ringBuffer.c @@ -64,8 +64,9 @@ void test_compress(FILE* outFp, FILE* inpFp) if (0 == inpBytes) break; { - char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)]; - const int cmpBytes = LZ4_compress_continue(lz4Stream, inpPtr, cmpBuf, inpBytes); +#define CMPBUFSIZE (LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)) + char cmpBuf[CMPBUFSIZE]; + const int cmpBytes = LZ4_compress_fast_continue(lz4Stream, inpPtr, cmpBuf, inpBytes, CMPBUFSIZE, 0); if(cmpBytes <= 0) break; write_int32(outFp, cmpBytes); write_bin(outFp, cmpBuf, cmpBytes); @@ -90,7 +91,7 @@ void test_decompress(FILE* outFp, FILE* inpFp) for(;;) { int cmpBytes = 0; - char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)]; + char cmpBuf[CMPBUFSIZE]; { const size_t r0 = read_int32(inpFp, &cmpBytes); -- cgit v0.12 From 3bde02a059f1fba25be95c31b3e27947d80604f8 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 15:04:58 -0800 Subject: added gcc 4.4 test --- .travis.yml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/.travis.yml b/.travis.yml index 6934175..c127fa5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -130,6 +130,18 @@ matrix: packages: - clang + - env: Ubu=14.04 Cmd='make clean all CC=gcc-4.4 MOREFLAGS=-Werror' COMPILER=gcc-4.4 + dist: trusty + sudo: required + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libc6-dev-i386 + - gcc-multilib + - gcc-4.4 + script: - echo Cmd=$Cmd - $COMPILER -v -- cgit v0.12 From ba7a85b463fe6e6b2a3b9db24277054eb54a42a7 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 15:44:25 -0800 Subject: fixed minor analyzer warning --- examples/frameCompress.c | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/examples/frameCompress.c b/examples/frameCompress.c index b7a3576..df41451 100644 --- a/examples/frameCompress.c +++ b/examples/frameCompress.c @@ -116,6 +116,7 @@ static size_t compress_file(FILE *in, FILE *out, size_t *size_in, size_t *size_o static size_t get_block_size(const LZ4F_frameInfo_t* info) { switch (info->blockSizeID) { + case LZ4F_default: case LZ4F_max64KB: return 1 << 16; case LZ4F_max256KB: return 1 << 18; case LZ4F_max1MB: return 1 << 20; @@ -127,17 +128,14 @@ static size_t get_block_size(const LZ4F_frameInfo_t* info) { } static size_t decompress_file(FILE *in, FILE *out) { - void * const src = malloc(BUF_SIZE); - void *dst = NULL; - void *srcPtr = src; - void *srcEnd = src; - size_t srcSize = 0; - size_t dstSize = 0; + void* const src = malloc(BUF_SIZE); + void* dst = NULL; size_t dstCapacity = 0; LZ4F_dctx *dctx = NULL; size_t ret; /* Initialization */ + if (!src) { perror("decompress_file(src)"); goto cleanup; } ret = LZ4F_createDecompressionContext(&dctx, 100); if (LZ4F_isError(ret)) { printf("LZ4F_dctx creation error: %s\n", LZ4F_getErrorName(ret)); @@ -147,15 +145,14 @@ static size_t decompress_file(FILE *in, FILE *out) { /* Decompression */ ret = 1; while (ret != 0) { - /* INVARIANT: At this point srcPtr == srcEnd */ /* Load more input */ - srcSize = fread(src, 1, BUF_SIZE, in); + size_t srcSize = fread(src, 1, BUF_SIZE, in); + void* srcPtr = src; + void* srcEnd = srcPtr + srcSize; if (srcSize == 0 || ferror(in)) { printf("Decompress: not enough input or error reading file\n"); goto cleanup; } - srcPtr = src; - srcEnd = srcPtr + srcSize; /* Allocate destination buffer if it isn't already */ if (!dst) { LZ4F_frameInfo_t info; @@ -169,6 +166,7 @@ static size_t decompress_file(FILE *in, FILE *out) { */ dstCapacity = get_block_size(&info); dst = malloc(dstCapacity); + if (!dst) { perror("decompress_file(dst)"); goto cleanup; } srcPtr += srcSize; srcSize = srcEnd - srcPtr; } @@ -179,7 +177,7 @@ static size_t decompress_file(FILE *in, FILE *out) { */ while (srcPtr != srcEnd && ret != 0) { /* INVARIANT: Any data left in dst has already been written */ - dstSize = dstCapacity; + size_t dstSize = dstCapacity; ret = LZ4F_decompress(dctx, dst, &dstSize, srcPtr, &srcSize, /* LZ4F_decompressOptions_t */ NULL); if (LZ4F_isError(ret)) { printf("Decompression error: %s\n", LZ4F_getErrorName(ret)); -- cgit v0.12 From 8b233b228dbda484d1d545c5a3ecaf06aef3e930 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 15:51:39 -0800 Subject: added a few dates --- Makefile | 2 +- lib/LICENSE | 2 +- lib/Makefile | 2 +- lib/lz4frame.h | 2 +- lib/lz4frame_static.h | 2 +- lib/lz4hc.c | 2 +- programs/datagen.c | 2 +- programs/datagen.h | 2 +- programs/lz4cli.c | 2 +- programs/lz4io.c | 2 +- programs/lz4io.h | 2 +- tests/datagencli.c | 2 +- 12 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Makefile b/Makefile index 700d772..48e6752 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ # ################################################################ # LZ4 - Makefile -# Copyright (C) Yann Collet 2011-2015 +# Copyright (C) Yann Collet 2011-2016 # All rights reserved. # # BSD license diff --git a/lib/LICENSE b/lib/LICENSE index bd3c80d..74c2cdd 100644 --- a/lib/LICENSE +++ b/lib/LICENSE @@ -1,5 +1,5 @@ LZ4 Library -Copyright (c) 2011-2015, Yann Collet +Copyright (c) 2011-2016, Yann Collet All rights reserved. Redistribution and use in source and binary forms, with or without modification, diff --git a/lib/Makefile b/lib/Makefile index d6e3668..28242cc 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -1,6 +1,6 @@ # ################################################################ # LZ4 library - Makefile -# Copyright (C) Yann Collet 2011-2015 +# Copyright (C) Yann Collet 2011-2016 # All rights reserved. # # BSD license diff --git a/lib/lz4frame.h b/lib/lz4frame.h index 9449e0d..3104d2e 100644 --- a/lib/lz4frame.h +++ b/lib/lz4frame.h @@ -1,7 +1,7 @@ /* LZ4 auto-framing library Header File - Copyright (C) 2011-2015, Yann Collet. + Copyright (C) 2011-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without diff --git a/lib/lz4frame_static.h b/lib/lz4frame_static.h index d922e39..f2228a5 100644 --- a/lib/lz4frame_static.h +++ b/lib/lz4frame_static.h @@ -1,7 +1,7 @@ /* LZ4 auto-framing library Header File for static linking only - Copyright (C) 2011-2015, Yann Collet. + Copyright (C) 2011-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) diff --git a/lib/lz4hc.c b/lib/lz4hc.c index 6de8e8f..298550c 100644 --- a/lib/lz4hc.c +++ b/lib/lz4hc.c @@ -1,6 +1,6 @@ /* LZ4 HC - High Compression Mode of LZ4 - Copyright (C) 2011-2015, Yann Collet. + Copyright (C) 2011-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) diff --git a/programs/datagen.c b/programs/datagen.c index ed37c2a..f97c2d0 100644 --- a/programs/datagen.c +++ b/programs/datagen.c @@ -1,6 +1,6 @@ /* datagen.c - compressible data generator test tool - Copyright (C) Yann Collet 2012-2015 + Copyright (C) Yann Collet 2012-2016 GPL v2 License diff --git a/programs/datagen.h b/programs/datagen.h index 680afa2..91c5b02 100644 --- a/programs/datagen.h +++ b/programs/datagen.h @@ -1,6 +1,6 @@ /* datagen.h - compressible data generator header - Copyright (C) Yann Collet 2012-2015 + Copyright (C) Yann Collet 2012-2016 GPL v2 License diff --git a/programs/lz4cli.c b/programs/lz4cli.c index 297ce6b..71378aa 100644 --- a/programs/lz4cli.c +++ b/programs/lz4cli.c @@ -1,6 +1,6 @@ /* LZ4cli - LZ4 Command Line Interface - Copyright (C) Yann Collet 2011-2015 + Copyright (C) Yann Collet 2011-2016 GPL v2 License diff --git a/programs/lz4io.c b/programs/lz4io.c index 2ffb541..bc2ba95 100644 --- a/programs/lz4io.c +++ b/programs/lz4io.c @@ -1,6 +1,6 @@ /* LZ4io.c - LZ4 File/Stream Interface - Copyright (C) Yann Collet 2011-2015 + Copyright (C) Yann Collet 2011-2016 GPL v2 License diff --git a/programs/lz4io.h b/programs/lz4io.h index e1ab5f3..6190f00 100644 --- a/programs/lz4io.h +++ b/programs/lz4io.h @@ -1,6 +1,6 @@ /* LZ4io.h - LZ4 File/Stream Interface - Copyright (C) Yann Collet 2011-2015 + Copyright (C) Yann Collet 2011-2016 GPL v2 License This program is free software; you can redistribute it and/or modify diff --git a/tests/datagencli.c b/tests/datagencli.c index d74d5dd..0b78d37 100644 --- a/tests/datagencli.c +++ b/tests/datagencli.c @@ -1,7 +1,7 @@ /* datagencli.c compressible data command line generator - Copyright (C) Yann Collet 2012-2015 + Copyright (C) Yann Collet 2012-2016 GPL v2 License -- cgit v0.12 From 8875e7dbb56e16b5bb30de731c87f4e24b6d43ba Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 16:42:23 -0800 Subject: fix minor analyzer warning --- examples/frameCompress.c | 23 +++++++++-------------- tests/fullbench.c | 2 +- 2 files changed, 10 insertions(+), 15 deletions(-) diff --git a/examples/frameCompress.c b/examples/frameCompress.c index df41451..75f1576 100644 --- a/examples/frameCompress.c +++ b/examples/frameCompress.c @@ -189,7 +189,6 @@ static size_t decompress_file(FILE *in, FILE *out) { printf("Writing %zu bytes\n", dstSize); if (written != dstSize) { printf("Decompress: Failed to write to file\n"); - ret = 1; goto cleanup; } } @@ -210,9 +209,8 @@ static size_t decompress_file(FILE *in, FILE *out) { cleanup: free(src); - if (dst) free(dst); - if (dctx) ret = LZ4F_freeDecompressionContext(dctx); - return ret; + free(dst); + return LZ4F_freeDecompressionContext(dctx); /* note : free works on NULL */ } int compare(FILE* fp0, FILE* fp1) @@ -238,7 +236,7 @@ int compare(FILE* fp0, FILE* fp1) return result; } -int main(int argc, char **argv) { +int main(int argc, const char **argv) { char inpFilename[256] = { 0 }; char lz4Filename[256] = { 0 }; char decFilename[256] = { 0 }; @@ -257,9 +255,8 @@ int main(int argc, char **argv) { printf("dec = [%s]\n", decFilename); /* compress */ - { - FILE* inpFp = fopen(inpFilename, "rb"); - FILE* outFp = fopen(lz4Filename, "wb"); + { FILE* const inpFp = fopen(inpFilename, "rb"); + FILE* const outFp = fopen(lz4Filename, "wb"); size_t sizeIn = 0; size_t sizeOut = 0; size_t ret; @@ -280,9 +277,8 @@ int main(int argc, char **argv) { } /* decompress */ - { - FILE* inpFp = fopen(lz4Filename, "rb"); - FILE* outFp = fopen(decFilename, "wb"); + { FILE* const inpFp = fopen(lz4Filename, "rb"); + FILE* const outFp = fopen(decFilename, "wb"); size_t ret; printf("decompress : %s -> %s\n", lz4Filename, decFilename); @@ -298,9 +294,8 @@ int main(int argc, char **argv) { } /* verify */ - { - FILE* inpFp = fopen(inpFilename, "rb"); - FILE* decFp = fopen(decFilename, "rb"); + { FILE* const inpFp = fopen(inpFilename, "rb"); + FILE* const decFp = fopen(decFilename, "rb"); printf("verify : %s <-> %s\n", inpFilename, decFilename); const int cmp = compare(inpFp, decFp); diff --git a/tests/fullbench.c b/tests/fullbench.c index 03dfe19..7d54492 100644 --- a/tests/fullbench.c +++ b/tests/fullbench.c @@ -1,6 +1,6 @@ /* bench.c - Demo program to benchmark open-source compression algorithm - Copyright (C) Yann Collet 2012-2015 + Copyright (C) Yann Collet 2012-2016 GPL v2 License -- cgit v0.12 From cc21115cb4f9ff1f97322104ffb19ca89b5a0eb1 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 21 Nov 2016 19:26:49 -0800 Subject: minor warning fix --- examples/HCStreaming_ringBuffer.c | 49 +++++++++++++++------------------------ 1 file changed, 19 insertions(+), 30 deletions(-) diff --git a/examples/HCStreaming_ringBuffer.c b/examples/HCStreaming_ringBuffer.c index a9c00f4..d49b267 100644 --- a/examples/HCStreaming_ringBuffer.c +++ b/examples/HCStreaming_ringBuffer.c @@ -6,7 +6,7 @@ * Compiler Options **************************************/ #ifdef _MSC_VER /* Visual Studio */ -# define _CRT_SECURE_NO_WARNINGS // for MSVC +# define _CRT_SECURE_NO_WARNINGS /* for MSVC */ # define snprintf sprintf_s #endif @@ -59,17 +59,15 @@ void test_compress(FILE* outFp, FILE* inpFp) static char inpBuf[RING_BUFFER_BYTES]; int inpOffset = 0; - for(;;) - { + for(;;) { // Read random length ([1,MESSAGE_MAX_BYTES]) data to the ring buffer. char* const inpPtr = &inpBuf[inpOffset]; const int randomLength = (rand() % MESSAGE_MAX_BYTES) + 1; const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength); if (0 == inpBytes) break; - { #define CMPBUFSIZE (LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)) - char cmpBuf[CMPBUFSIZE]; + { char cmpBuf[CMPBUFSIZE]; const int cmpBytes = LZ4_compress_HC_continue(lz4Stream, inpPtr, cmpBuf, inpBytes, CMPBUFSIZE); if(cmpBytes <= 0) break; @@ -95,13 +93,11 @@ void test_decompress(FILE* outFp, FILE* inpFp) LZ4_streamDecode_t lz4StreamDecode_body = { 0 }; LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body; - for(;;) - { + for(;;) { int cmpBytes = 0; char cmpBuf[CMPBUFSIZE]; - { - const size_t r0 = read_int32(inpFp, &cmpBytes); + { const size_t r0 = read_int32(inpFp, &cmpBytes); size_t r1; if(r0 != 1 || cmpBytes <= 0) break; @@ -111,8 +107,7 @@ void test_decompress(FILE* outFp, FILE* inpFp) break; } - { - char* const decPtr = &decBuf[decOffset]; + { char* const decPtr = &decBuf[decOffset]; const int decBytes = LZ4_decompress_safe_continue( lz4StreamDecode, cmpBuf, decPtr, cmpBytes, MESSAGE_MAX_BYTES); if(decBytes <= 0) @@ -136,8 +131,7 @@ size_t compare(FILE* f0, FILE* f1) { size_t result = 1; - for (;;) - { + for (;;) { char b0[65536]; char b1[65536]; const size_t r0 = fread(b0, 1, sizeof(b0), f0); @@ -145,16 +139,14 @@ size_t compare(FILE* f0, FILE* f1) if ((r0==0) && (r1==0)) return 0; // success - if (r0 != r1) - { + if (r0 != r1) { size_t smallest = r0; if (r1