Mention libb2 dependency in installation instructions

Document BLAKE2b and clean up after #445

Closes #412.

Only set flags for cross, breaks native build

Need all the auto-detected CPU flags to be set

Make sure to pass flags to travis shell commands

Enable building static local libb2 for non-native

Generated files are in builddir, not srcdir

Upgrade travis docker to xenial, add libb2-dev

Also upgrade clang from 5 to 7, to match travis

Add new deb requirements from libzstd and libb2

Move libb2 source code to src/third_party

Only disable optimizations when cross-compiling

Fix travis build by helping clang and cross

Add option to build static libb2 from source

Add libb2-dev to Travis linux dependencies

Use BLAKE2b checksum instead of bundled MD4

Bump to zstd 1.4.1

Move third party source code to src/third_party

Fix CCACHE_MAXSIZE with filesystem compression (#444)

Prepare for v3.7.2

(cherry picked from commit 41ce399ce1a33fd7211754e77fb4a5ddcb1d9eea)

Update NEWS

(cherry picked from commit 4e9b1c1b8e1c98081f284beb2f5766f452fd04fe)

Don’t pass -Werror and compilation-only options to the preprocessor

Clang emits warnings when it sees unused options, so when ccache runs
the Clang preprocessor separately, options that are not used by the
preprocessor will produce warnings. This means that the user may get
warnings which would not be present when not using ccache. And if
-Werror is present then the preprocessing step fails, which needless to
say is not optimal.

To work around this:

* Options known to have the above mentioned problem are not passed to
  the preprocessor.
* In addition, -Werror is also not passed to the preprocessor so that
  options not properly marked as “compiler only” will only trigger
  warnings, not errors.

Fixes #312.

(cherry picked from commit 5d8585b588fb9f81e741b765603053e4cadcf1ac)

Rename stripped_args to common_args

(cherry picked from commit bdf4c6b635789e37412fd0b393c637d91ce9cd7b)

Fix out-of-source build when using --with-libzstd-from-internet

Add missing headers to release archive list

Don’t build tar.bz2 release archive

bz2 seems more or less obsolete since xz compresses better (and
decompresses faster), and gz is more ubiquitous.

Add missing license blurbs to header files

Add “and other contributors” to copyright notices

Add 64-bit MinGW build

Improve -x/--show-compression

- Ignore *.tmp.* files.
- Mention on-disk size (adjusted for disk block size) to make it match
  the cache size reported by “ccache --show-stats”.
- Introduced “space savings” and “of original” percentages.
- Calculate compression ratio only for compressed files.
- Include “incompressible files” size, i.e. total size of .raw files and
  files produced by previous ccache versions.
- Removed file counts since I don’t think that they are of much
  interest.
- Handle unparsable manifest files from previous ccache versions
  gracefully.

Remove the kB case from format_*_size* functions

Nobody will ever use or see non-zero kB sizes anyway, and this makes the
zero case for sizes in --show-compression nicer.

Add .editorconfig

This makes GitHub show tabs as 2 spaces wide, which is what I like (and
also what the code style assumes when counting characters for line
widths).

Refactor code for getting manifest/result content size

Document -x/--show-compression

Add gitter.im link and badge

Never store stderr output or .d files separately

Add support for file cloning on Mac OS X (APFS)

Implement support for file cloning on Linux (Btrfs/XFS)

- Added a new file_clone (CCACHE_FILECLONE) configuration setting. If
  set, ccache uses the FICLONE ioctl if available to clone files to/from
  the cache. If file cloning is not supported by the file system, ccache
  will silently fall back to copying (or hard linking if hard_link is
  enabled).
- Compression will be disabled if file_clone is enabled, just like for
  hard_link.
- file_clone has priority over hard_link.
- Tested on Btrfs and XFS on Linux 5.0.0.

Closes #213.

Sort envtoconfitems.gperf list

Add command to show compression statistics (#440)

This will only show information about the files that is knows about
(right magic bytes). So the file count might differ from what is shown
with the regular statistics (which shows all files, including old ones).

The terminology used here is a bit confused, the compression ratio is
supposed to grow upwards. Sometimes known as "space savings" instead,
so list both values (ratio and savings) to make the output more obvious.

Reimplement the hard link mode

- Files stored by hard linking are saved as _N.raw files next to their
  .result file, where N is the 0-based index of the entry in the .result
  file.
- The .result file stores expected file sizes for the .raw files and the
  code verifies that they are correct before retrieving the files from
  the cache.
- The manual has been updated to mention the new file size check and
  also some other caveats.

The previous hard link mode implementation was removed in
3999a9ca67e2eabb8457920108b546713f200161 and
a1dbb8a15e034e5a63eb6b4407c9e3ccac469162. The latter commit lists three
points:

1. Hard links are error prone.
2. Compression will make hard links obsolete as a means of saving cache
   space.
3. A future backend storage API will be easier to write.

Point 1 is still true, but since the result file now stores expected
file sizes, many inadvertent modifications of files will be detected.

Point 2 is also still true, but you might want to trade cache size for
speed in cases where increased speed actually is measurable, like with
very large object files.

Point 3 does not quite hold after thinking some more about future APIs.
I think that it will be relatively straight-forward to add operations
like supports_raw_files, get_raw_file and put_raw_file to the API.

Let stderr content have an even more special name in result files

Refactor result_get code into functions per marker type

In preparation for reimplementing the hard link mode.

Allow NULL checksum parameter for common_header_initialize_for_reading

Remove now redundant check for existing result file

Avoid logging uninteresting message for deletion of .dwo file

Simplify compression_type_from_config

Refactor common_header_initialize_*

In preparation for adding cache compression statistics and cache
recompression functionality.

Avoid letting “-gdwarf*” force “run_second_cpp = true”

Fixes #394.

Improve error handling and logging of result files copying

Probe whether the compiler produces a .dwo

GCC and Clang behave differently when given e.g. “-gsplit-dwarf -g1”:
GCC produces a .dwo file but Clang doesn’t. Trying to guess how the
different options behave for each compiler is complex and error prone.

Instead, Ccache now probes whether the compiler produced a .dwo and only
stores it if it was produced. On a cache hit, the .dwo is restored if it
exists in the previous result – if it doesn’t exist in the result, it
means that the compilation didn’t produce a .dwo.

Fixes #393.

Extract objdump_cmd to test/run where it belongs

Remove obsolete conditionals in the split_dwarf test suite

Add --no-compression and --compression-level to misc/performance

Use Ubuntu 16.04 for Travis CI

Quote CC setting when calling into libzstd’s makefile

Extract code for reading uint64_t in result.c to a macro

Extract common header setup code to functions

Add checksumming of cached content

Both compressed and uncompressed content are checksummed and verified.
The chosen checksum algorithm is XXH64, which is the same that the zstd
frame format uses (but ccache stores all 64 bits instead of only 32,
because why not?).

Require libzstd and remove zlib support

* zlib has been removed. Good riddance!
* libzstd is now required for building ccache. However, it’s not bundled
  like zlib was.
* To make it easier to build ccache on systems that lack an easily
  installable libzstd, the configure script now offers a
  --with-libzstd-from-internet option, which downloads a zstd source
  release archive, unpacks it in the tree and sets up the Makefile to
  build the library and link ccache (statically) with it.
* Enabled compression by default.
* Made compression level 0 mean “use a default level suitable for the
  current compression algorithm”. For zstd, that’s initially level -1,
  but that could change in the future. The reason for using 0 as a
  special marker is that a future alternative compression algorithm
  could have another reasonable default than zstd. (Let’s hope that
  future algorithms don’t use level 0 for something.)
* Changed default compression level to 0.

Closes #413.

Enable build command verbosity in Travis builds

This makes it much easier to understand build failures.

Restructure Travis configuration

In preparation for switching from zlib to zstd. I find it easier to use
a flat job list instead of a matrix and state settings explicitly for
the different jobs.

Don’t enable unit test verbosity in Travis

It’s way too spammy.

Refactor functions for reading/writing common header

The functions now work on bytes instead of FILEs, allowing for the
caller to optionally peek at read/written bytes.

Replace murmurhashneutral2 with xxHash (XXH64)

XXH64 is significantly faster than murmurhashneutral2 (on 64-bit
systems, which one can assume ccache almost always is running on these
days). This of course doesn’t matter for keys in hash tables, but it
opens up for using it as a checksumming algorithm for cached data as
well.

Don’t try a higher zstd level than supported

If the user tries a higher level than supported by libzstd,
initialization will fail. Instead, let’s clamp the level to the highest
supported value.

Regarding negative levels: They are supported from libzstd 1.3.4, but
the query function ZSTD_minCLevel is only supported from 1.4.0 (from
1.3.6 with ZSTD_STATIC_LINKING_ONLY), so let’s not use it for
verification of the level. In libzstd 1.3.3 and older, negative levels
are silently converted to the zstd’s default level (3), so there’s no
major harm done if a user uses a negative level with older libzstd
versions.

Allow for negative compression level

Use the compression API for reading and writing manifests

* Manifest and result files now share the same common header (sans the
  magic bytes) and will be compressed using the common compression
  settings.
* Removed the legacy “hash size” and “reserved” fields.

Tweak code style

Extract and implement more bytes from/to int macros

Improve order of parameters to common_header_*_file

Extract header code common to result and manifest files

Allow using zstd compresssion instead of zlib (#437)

Verify value in “ccache -o key=value”

Based on a suggestion by Henri Houder.

const-ify parameters to confitem verifier/formatter

Change to looser compression_type data type

This avoids a Clang analyzer warning.

Rename “filelist” to “result_files”

Refactor compression type/level calculation

In preparation for introducing a new manifest format.

Add a content size field to the result file header

The content size field says how much uncompressed data is stored in the
file. This can be used to relatively quickly determine the compression
rate for the whole cache by only inspecting each file’s header insted of
having to read and decompress all files.

Since the content size needs to be calculated before actually adding the
content to the result file, I’ve reverted back to let the format use a
“number of entries” field instead of an EOF marker (similar to Anders
Björklund’s original work in 0399be2d) since the information about the
number of files now has to be known beforehand.

Another subtle change is that the compression level field now is int8_t
instead of uint8_t to make it possible to record negative levels.

Don’t try to parse unimplemented reference entries in result files

Remove now unused x_fstat function

Fix check of destination fd in copy_file

Fix possible NULL pointer dereference (#433)

cppcheck:
  [src/manifest.c:270] -> [src/manifest.c:269]: (warning)
  Either the condition '!errmsg' is redundant or there is possible null pointer
  dereference: errmsg.

Improve naming of things

Some words are being used to mean several things in the code base:

* “object” can mean both “the object file (.o) produced by the compiler”
  and “the result stored in the cache, including e.g. the .o file and .d
  file”.
* “hash” can mean both “the state that the hash_* functions operate on”,
  “the output of a hash function” and “the key used to index results
  and manifests in the cache”.

This commits tries to make the naming more consistent:

* “object” means “the object file (.o) produced by the compiler”
* “result” means “the result stored in the cache, including e.g. the .o
  file and .d file”.
* “struct hash” means “the state that the hash_* functions operate on”.
* “digest” means “the output of a hash function”. However, “hash” is
  still used in documentation and command line output since I think that
  “hash” is easier to understand for most people, especially since
  that’s the term used by Git.
* “name” means “the key used to index results and manifests in the
  cache”.

Improve how <MD4, number of hashed bytes> is represented

Internally, the tuple <MD4 hash, number of hashed bytes>,which is the
key used for cached results and manifests, was represented as 16 bytes +
1 uint32_t. Externally, i.e. in file names, it was represented as
<MD4>-<size>, with <MD4> being 32 hex digits and <size> being the number
of hashed bytes in human-readable form.

This commits changes the internal representation to 20 bytes, where the
last 4 bytes are the number of hashed bytes in big-endian order. The
external representation has been changed to match this, i.e. to be 40
hex digits. This makes the code slightly less complex and more
consistent. Also, the code that converts the key into string form has
been rewritten to not allocate on the heap but to just write the output
into a buffer owned by the caller.

struct file_hash (16 bytes + 1 uint32_t) has been renamed to struct
digest (20 bytes) in order to emphasize that it represents the output of
a hash algorithm that not necessarily gets file content as its input.

The documentation of the manifest format has been updated to reflect the
logical change of keys, even though the actual serialized content of
manifest files hasn’t changed. While at it, reading of the obsolete
“hash_size” and “reserved” fields has been removed. (Future changes in
the manifest format will be handled by just stepping the version.)

Add binary representation of hash-size (#399)

* Add binary representation of hash-size

Fixed size efficient binary representation data,
instead of the variable size hexadecimal string.

This is suitable for machine use, while the other
is more suitable for human readability as string.

* Promote hex format as a global function

* Add unittest for the format_hex function

Make sure that output is NUL-terminated

Remove the hard link mode

Rationale:

* The hard link feature is prone to errors: a) changes to files outside
  the cache will corrupt the cache, and b) the mtime field in the file's
  i-node is used for different purposes by ccache and build tools like
  make.
* The upcoming enabling of LZ4 compression by default will make the hard
  link mode obsolete as a means of saving cache space.
* Not supporting hard links will make a future backend storage API
  simpler.

Move mtime update into result_get/manifest_get

Housekeeping of cached files belongs to the backend code, not the
frontend.

Remove now superfluous test of empty result file

Empty files are detected as corrupted by result_get.

Improve error reporting from read_result

“ccache --dump-result” now prints the actual error.

Improve names of result functions and variables

Improve error handling of (de)compressors

Previously, some kinds of corruption were not detected by the zlib
decompressor since it didn’t check that it had reached the end of the
stream and therefore didn’t verify the Adler-32 checksum.

Remove redundant cc_log

Clean up internal trace code

Remove obsolete decompression code

* Remove obsolete decompression functionality from copy_file.
* Removed obsolete move_uncompressed_file.
* Improved return values of copy_file/move_file.

Remove obsolete file_is_compressed function

Uncrustify code

Use the compression API for results

It didn’t feel right to use zlib’s gzip format for the embedded content,
especially since other compression libraries don’t support a similar
interface. Therefore, use the standard low-level zlib API instead.

Add compression interface and none/zlib implementations

Revise disk format for results

* Removed unused hash_size and reserved fields. Since there are no
  hashes stored in in the result metadata, hash size is superfluous. The
  reserved bits field is also unnecessary; if we need to change the
  format, we can just step RESULT_VERSION and be done with it.
* Instead of storing file count in the header, store an EOF marker after
  the file entries. The main reason for this is that files then can be
  appended to the result file without having to precalculate how many
  files the result will contain.
* Don’t include trailing NUL in suffix strings since the length is known.
* Instead of potentially compressing the whole file, added an
  uncompressed header telling how/if the rest of the file is
  compressed (which algorithm and level). This makes it possible to more
  efficiently recompress files in a batch job since it’s possible to
  reasonably efficiently check if a cached file should be repacked. The
  reason for not having compression info in each subfile
  header (supporting different compression algorithms/levels per
  subfile) is to make the repacking scenario simpler.
* Prepared for adding support for “reference entries”, which refer to
  other results. There are two potential use cases for reference
  entries: a) deduplication and b) storing partial results with a
  different compression algorithm/level. It’s probably only the
  deduplication use case that is interesting, though. It can be done
  either at cache miss time or later as a batch job. If we really want
  to, we can in the future add similar “raw reference entries” that
  refer to files stored verbatim in the storage, thus re-enabling hard
  link functionality.
* Changed to cCrS as the magic bytes for result files. This is analogous
  to the magic bytes used for manifest files.
* Added documentation of the format.

Remove --enabled-aggregated feature toggle

Fix temp file leak in --enabled-aggregated mode

Check and act on return value from cache_get

Otherwise corrupted result files won’t get detected.