feat: Support masquerading as a compiler via copy or hard link

Setting up ccache to masquerade as a compiler has always meant using
symbolic links, but there is no technical reason why that has to be the
case. This commit adds support for masquerading via a copy or hard link
of the ccache executable as well. This is mostly useful on platforms or
file systems where symbolic links are not supported.

feat: Set CCACHE_DISABLE when calling compiler

If ccache for some reason executes a compiler that in turn calls ccache
then ccache will be run twice (and will potentially store two different
result in the cache since the compiler identications differ), which is
not very useful. This could for instance happen if the compiler is a
wrapper script that in turn calls "ccache $compiler ...".

Improve this by setting CCACHE_DISABLE when executing the compiler. Any
subsequent ccache invocations will then fall back to running the real
compiler.

fix: Add and use Util::{get,set}_umask functions

Using

    mode_t mask = umask(0);
    umask(mask);

to retrieve the current umask isn't thread-safe. This messed up file
permissions when recompressing the cache.

Fix this by caching the last set value and always using
Util::{get,set}_umask to get and set the umask.

fix: Retain mtime/atime for recompressed files

enhance: Add util::set_timestamps function for setting mtime/atime

ci: Bump Clang-Tidy job to Clang-Tidy 12

build: Make it possible to opt out of probing for fastest linker

chore: Align arguments in misc/test-all-systems

ci: Use Ubuntu 20.04 for standard jobs

ci: Remove unsupported platforms

ci: Bump CUDA job to Ubuntu 20.04

refactor: Extract option parsing code from process_arg

bump: Upgrade to cpp-httplib 0.10.8

fix: Use correct umask when populating primary cache from secondary

Util::get_umask retrieves the process's umask and caches it to avoid
some system calls. This doesn't interact well now when using UmaskScope
to change umask temporarily since Util::get_umask then only sometimes
returns the correct value. This leads to the incorrect umask being used
when writing cache entries to the primary storage for secondary storage
hits.

Fix this by not caching the umask system call.

Closes #1087.

fix: Create temporary file with cpp extension instead of hard linking

[1] added a suitable file extension to the temporary file used for
capturing the preprocessed output by creating a hard link. This fails
when the temporary directory is on a file system that doesn't support
hard links.

Fix this by making it possible to pass a suffix to TemporaryFile and
passing the proper cpp suffix for the tmp stdout file instead of
creating a hard link as an alias.

[1]: 4da9f2b474b7ee39cd54ab4261f90936f3c944ec

Closes #1079.

Revert "fix: Fall back to copying temporary preprocessed output file"

This reverts commit cbedccc9fa30f8958dc3e7fbdf900a952f63d5ad since the
fix doesn't work.

The hard link in question is used in get_result_key_from_cpp to create
an alias of file that captures stdout from the preprocessor, where the
alias has the correct cpp extension. It can't just be a copy since
do_execute writes to the original name. See #1079.

fix: Fix build for MSVC (#1078)

For Windows the order of the includes is important in wincompat.hpp.

feat: Fetch/update secondary storage manifest on primary miss (#1065)

feat: Generalize STATIC_LINK option + fixes (#1058)

fix: Fall back to compiler when producing assembler listing file

Ccache currently doesn't store the listing produced by -Wa,...=file, so
fall back to running the real compiler.

See #1083.

chore: Add debug log for -P + other preprocessor option

test(test-all-systems): Enable ccache if available in Docker image

test: Add Ubuntu 22.04 Dockerfile

docs: Fix typo in help text

ci: Add GCC 11 build on Ubuntu 22.04

fix: Work around problem with GCC in util::ends_with

The util::ends_with implementation is taken directly from the
implementation suggestion in the C++20 standard, but it produces a
stringop-overread warning with GCC 11.2. There's either some subtle
aspect to this that I don't understand or a compiler bug, but let's work
around it by tweaking the implementation.

Closes #1082.

bump: Upgrade xxh_x86dispatch.c to xxHash 0.8.1

xxh_x86dispatch.c was by mistake not included in
6eb7eb340bf163b807cb9267935e39fa619dde0b. See #1078.

feat: Improve --show-stats

- Added percentage for most values.
- All indented values now have their total count equal to the parent
  value.
- Moved presentation of {direct,preprocessed}_cache_{hit,miss}
  counters to a separate "Successful lookups" section.
- Removed "Use the -v/--verbose option for more details." from
  --show-stats output since it's a bit wordy.

bump: Upgrade to nonstd::expected 0.6.0

fix(win32execute): Handle space in paths when using response file (#1080)

fix: Fall back to copying temporary preprocessed output file

[1] added a suitable file extension to the temporary file used for
capturing the preprocessed output by creating a hard link. This fails
when the temporary directory is on a file system that doesn't support
hard links.

Fix this by falling back to copying when hard-linking fails.

Closes #1079.

[1]: 4da9f2b474b7ee39cd54ab4261f90936f3c944ec

Revert "build: Bump required compiler versions"

This reverts commit 077e2a6c279755f6521ab78f4a1a049ae6a93990.

Not needed yet.

fix: Fix and optimize Redis upload script (#1081)

build: Bump required compiler versions

build: Remove now superfluous cmake policy setting

CMP0091 defaults to NEW with cmake_minimum_required 3.15 and later.

test: Fix test failure when compiler is masquerading old ccache

chore: Remove no longer needed workaround for older GCCs

build: Enable Clang-Tidy modernize-concat-nested-namespaces check

build: Enable Clang-Tidy performance-no-automatic-move check

chore: Replace nonstd::string_view with std::string_view

chore: Replace nonstd::optional with std::optional

build: Require C++17 compiler and CMake 3.15

A C++17-compatible compiler is now readily available on all systems we
target primarily, so it's time to bump to C++17.

Also, we want to use features in CMake 3.15 (see #1069), so bump that
too.

build: Enable static runtime linking for MSVC (#1069)

fix: Fix crash with empty include filename in preprocessor output (#1075)

chore: Update NEWS

chore: Update authors

style: Improve names of Args::AtFileFormat values

ci: Bump to CodeQL action v2

fix: Support Redis URL without host

chore: Don’t store unused return value

chore: Constify core::Manifest::add_result parameter

chore: Set version “unknown” instead of empty string if unknown

fix: Support Git 1.x when determining ccache version

chore: Prepare for binary patching SYSCONFDIR

chore: Add Jacob Young to .mailmap

fix: Avoid incorrect error log for Redis write in reshare mode

chore: Remove anonymous users from AUTHORS

fix: Correctly represent statistics counters > 1 in log and stats log

fix: Fix parsing of MSVC response files (#1071)

docs: Add warning about base_dir

See #1042.

chore: Update license for nonstd::expected

See #1053.

refactor: Simplify Reader::read_int

std::string::operator[](0) is well-defined for empty strings.

fix: Log expanded secondary storage URL in put/remove

fix: Fix miscompile of nonstd::expected on MSVC v19.22 (#1053)

fix: Check for short reads in Reader::read_str (#1068)

fix: Fix "Multiple precompiled headers used" error if /Yu option is used after /Fp (#1059)

feat: Make upload-redis output more like other tools (#1070)

fix: Improve MSVC /Fp and /Yu options further

Improve 09dea223466e to also handle relative paths to -Fp/-Yu.

chore: Add knowledge of linker option -z to avoid note in debug log

Closes #1061.

fix: Handle MSVC /Fp and /Yu options with concatenated path again

Regression in c8fb539523c801bf15591c395c3029b4530a7a2f.

See #1063.

feat: Handle -imsvc compiler option (#1055)

build: Fix build arguments to clang-cl (#1054)

fix: Fix sporadic test.profiling failures (#1056)

Using cut, which is always line-based, to remove bytes from a binary file can
cause problems if the binary timestamp field happens to contain a newline
character, which causes test.profiling to fail <1% of the time. Instead use tail
which has a character mode that ignores newlines.

fix: Isolate inode cache file in tests

All test suites use the default temporary directory location
/run/user/<UID>/ccache-tmp when possible, which means that the inode
cache file is shared between all test suites. This is problematic when
running test suites in parallel since one test suite may run “ccache -C”
(which removes the inode cache file) between two compilations in the
inode_cache suite, thus making the second compilation not behave as
expected, failing the test.

Fix this by putting the temporary directory inside the test-specific
ccache directory instead of using the default global location.

Fixes #1045.

feat: Improve inode cache logging

ci: Fix CUDA installation

fix: Normalize paths to fix basedir option on Windows (#1033)

Co-authored-by: Joel Rosdahl <joel@rosdahl.net>

refactor: Improve absolute path normalization functions

The Util::normalize_absolute_path function only works on the syntactic
level, i.e. the result may not actually resolve to the same filesystem
entry (nor to any file system entry for that matter). It was meant to be
used for paths that don’t necessarily exist yet, such as a future
directory in which to write debug files. It may fail in edge cases with
symlinks in the path in combination with .. segments. If the caller
wants to ensure that the resulting path actually makes sense, it needs
to check if the resulting path points to the same file entry as the
original.

To improve on this, Util::normalize_absolute_path has now been renamed
to Util::normalize_abstract_absolute_path and there is a new
Util::normalize_concrete_absolute_path function which returns the
original path if the normalized result doesn't resolve to the same file
system entry as the original path.

fix: Make Stat::same_inode_as consider error code

docs: Mention default cache locations for Windows and macOS

fix: Fix static linkage with hiredis on Windows (#1041)

fix: Replace skip_last_empty with IncludeDelimiter (#1046)

fix: Fix code restructuring mistake in 5a55014f

fix: Fix process_preprocessed_file bug for distcc marker

2044fea84b86001b2976ecde946d3d6d0e88ec0a (included in ccache 4.6)
removed the special-casing of distcc’s pump in
process_preprocessed_file. That in turn revealed a bug that has been
present since 432d1ca6a6aa51f708124172169073c399fb68d2 (included in
ccache 3.4) but previously only affected compilations with distcc-pump
as the “compiler”: the detection and handling of distcc-pump’s
“__________” messages is broken in two ways:

1. It throws away everything between the last preprocessor directive and
   the “__________” marker. Thus, changes to such sections will not be
   included in the hash.
2. It detects “__________” markers in the middle of lines, not only at
   the beginning of lines.

style: Tweak code style to match conventions

style: Enable some clang-tidy readability checks for unit tests

Merge pull request #1037 from orgads/cl-strip-lf

fix: Do not add redundant newlines for stdout

Tokenizer is used with include_empty, and the output typically ends with
\n.

For each line, tokenizer returns it without the \n, and the function
appends
it. But if the output ends with \n, the tokenizer returns an additional
empty string, and a redundant LF is written to stdout.

Another issue can be if the last line of the original output doesn't end
with \n at all, ccache added it anyway.

It was probably unnoticed until now since gcc has no output at all, while
cl outputs the source file name.

feat: Support preserving the delimiters on tokenizer

test: Simplify tokenizer tests

fix: Only use /run/user/<UID>/ccache-tmp if writable

The fix for #984 addressed a problem when /run/user/0 already exists and
ccache is run with fakeroot. However, it didn’t handle the case when
/run/user/0/ccache-tmp already exists, which will happen for instance if
the real root user has run ccache at least once.

Fix this by using access(2) to verify that the ccache-tmp directory is
writable. Note: Can’t just check the mode bits of the directory since
they appear OK since fakeroot fakes the UID.

Fixes #1044.

fix: Add ASM and ASM_MASM to project() languages (#1043)

fix: Improve handling of .gcno files

When support for caching a compilation with coverage (producing a .gcno
file), the commit[1] made sure to avoid rewriting the input path to
relative with the motivation “also make sure to use the source file
path, since this is in the notes”. However, this seems to be unnecessary
since a relative input file path will be written as is to the .gcno, not
the absolute path. This is the case for at least GCC 4.7+ and Clang
3.6+. Fix this by potentially converting the input path to relative even
when generating coverage.

When investigating the above issue, I noticed that GCC 9+ includes the
current working directory (CWD) in the .gcno file. This means that we
have include the CWD in the hash when compiling with
-ftest-coverage/--coverage in order to replicate what the compiler would
produce. Since this makes it impossible get cache hits when compiling in
different directories, a new gcno_cwd sloppiness has been added for
opting out of hashing the CWD, with the tradeoff of potentially getting
an incorrect directory in the .gcno file.

[1]: 02d3f078bd2495b8db2264ae0b2c692b4c5ba1bd

Fixes #1032.

refactor: Sort sloppiness parsing/generation

chore: Disable some clang-tidy checks that don’t contribute much

docs: Add reference to reference build configs (#1031)

fix: Bail out on too hard MSVC environment variables CL and _CL_

To handle the CL and _CL_ variables properly, ccache needs to parse them
according to [1] and then include the compiler options as part of
regular argument processing. Until that is done we have to bail out and
just run the original compiler.

[1]: https://docs.microsoft.com/en-us/cpp/build/reference/cl-environment-variables?view=msvc-170

Fixes #1022.

fix: Prefer CMake find module for hiredis package

refactor: Simplify string append in process_arg

chore: Improve error message for read error in from_cache