fix: Use -P -Fi for saving MSVC preprocessor output

Even though MSVC supports "-E" and "-c -o" it apparently doesn't support
"-E -o", so [1] broke MSVC.

[1]: 64fc42ca2c5c9fe60ef4f1dc3882edb5f35579d6

Fixes #1146.

fix: Fix build with musl when using GCC 12 (#1145)

fix: Detect PCH for concatenated -include option

Fixes #1143.

fix: Avoid narrowing warning for struct statfs f_type field

As noted in #1142.

doc: Touch up config file and cache directory documentation

chore: Tweak formatting

chore: Touch up documentation of Util::make_path

build: Improve descriptions of installation variables

refactor: Use FMT macro to format exception messages

Using the FMT macro explicitly makes invalid format message
constructions compile-time errors instead of run-time errors.

chore: Update NEWS

(cherry picked from commit ee6ea5f33dd18710730d22416a91ea1e0178bef2)

chore: Update authors

(cherry picked from commit b4f0a18f30ba65b9f291fdc820955189b895c896)

fix: Add missing format argument to error message

fix: Don't crash in race between file read and cleanup

As mentioned in discussion #1102.

Regression in 02dac1f18084c0931aa6b8c1a07e9aedfadb5642.

fix: Strip .exe from executable name on version output (#1135)

test: Add version output on failure (#1134)

fix: Fix Clang/Windows build (#1132)

chore: Remove now unused Util::{read_fd,read_file,write_file} functions

refactor: Use util::{read_fd,read_file,write_file} functions

refactor: Use new util::Blob typedef

refactor: Use util::Blob for binary data in storage API

enhance: Add util::{read_fd,read_file,write_file} functions

chore: Improve log message about too many raw file entries

chore: Touch up {download,upload}-redis scripts

bump: Upgrade to nonstd::expected 0.6.2

feat: Enable inode cache by default

See discussion #1086.

feat: Improve inode cache robustness

- Only enable the inode cache at compile-time if it's possible to
  determine filesystem type.
- Only use the inode cache at run-time if the filesystem type is known
  to work with the inode cache instead of refusing just on NFS.

test: Refactor InodeCache unit tests

enhance: Add Config::set_temporary_dir

For usage by unit tests.

fix: Only enable inode cache if subsecond stat timestamps are available

If such fields are not available we risk false positive inode cache
hits.

chore: Remove unused InodeCache::Key::sloppy_time_macros field

enhance: Support Stat::{atim,ctim,mtim} on macOS

bump: Upgrade to cpp-httplib 0.11.1

fix: Hash time information on inode cache hit

As mentioned in discussion #1086: If the inode cache is enabled,
hash_source_code_file will on an inode cache hit fail to hash time
information if there are temporal macros in the code. This is because
hash_source_code_string (called from hash_source_code_file via
hash_source_code_file_nocache) on an inode cache miss adds time
information to the hash in case one of those macros were found. However,
on an inode cache hit the return value of hash_source_code_file will be
correctly fetched from the cache, but the hash sum will only be updated
with (the hash of) the include file and not the time information.

The fix is to let the inode cache only cache the effects of hashing the
file and checking for macros, not the hashing of time information since
that's volatile.

After the fix:

- The new do_hash_file function performs file hashing and macro
  checking. The inode cache caches this step.
- hash_source_code_file returns a Digest instead of adding data to a
  Hash.
- hash_source_code_file calls do_hash_file and then potentially hashes
  time information. If there are no temporal macros the returned digest
  will be identical to the file hash, otherwise the returned digest will
  be of a hash of file content hash + time information.

This also improves hashes that are stored in the direct mode manifest:
Previously they were always the hash of the file content hash but now
they are just the file content hash in the common case when there is no
__DATE__ or __TIMESTAMP__ macro in the file.

fix: Hash sanitizeblacklist delimiter correctly

Regression in a502145296044ea32b24e329d75122e777c598e6.

test: Ignore clang warning from -fdebug-prefix-map test

test: Only run -ftest-coverage + -fprofile-dir tests for GCC

Clang complains with "warning: argument unused during compilation:
'-fprofile-dir=dir'".

enhance: Make Hash::add_debug_text public

fix: Always rewrite dependency file if base_dir is used

[1] added the has_absolute_include_headers variable as a performance
optimization for base_dir/CCACHE_BASEDIR so that the dependency file
only has to be parsed/rewritten when necessary. This is based on the
assumption that if no include file has an absolute path then no rewrite
is needed, but apparently Clang can insert other paths into the
dependency file as well, for instance the asan_blacklist.txt file when
using -fsanitize=address.

Fix this by simply always parsing the dependency file when base_dir is
active.

Fixes #1128.

[1]: 60178b7a8eb8d03b364afb2fb8bd6753924cd9b7

fix: Handle --hash-file/--checksum-file error properly

feat: Move Windows config and cache to LOCALAPPDATA (#1124)

feat: Log configuration file locations

See #1127.

chore: Remove redundant include of algorithm header

Closes #1126.

chore: Remove unused CMake code

feat: Improve handling of dependency files

- Cache entries are now shared for different -MT/-MQ options. This is
  implemented by (on a cache hit) rewriting the stored dependency file
  data to have the correct dependency target before writing it to the
  destination. Closes #359.
- An intentional side effect of the above is that the correct dependency
  target will be produced even when base_dir/CCACHE_BASEDIR is used -
  the dependency target will still be an absolute path. Fixes #1042.
- Buggy support for GCC-specific environment variables
  DEPENDENCIES_OUTPUT and SUNPRO_DEPENDENCIES has been removed. When one
  of those variables was set, ccache used to store and fetch the content
  just as if -MMD or -MD were used. This is however incorrect since GCC
  *appends* to the destination file instead of (like -MMD/-MD)
  *rewriting* it. Since there is no way for ccache to know what the
  compiler appended to the dependency file, we simply can't support it.
  Reverts #349.

chore: Improve comment

test: Add support for negative content pattern matching

fix: Restore order of cpp and cppstderr sections in input hash

This retains input hash compatibility with revisions before
64fc42ca2c5c9fe60ef4f1dc3882edb5f35579d6.

ci: Bump to macOS 11

The macOS 10.15 runners are being deprecated.

fix: Work around Clang bug when outputting to full NFS disk

See <https://github.com/llvm/llvm-project/issues/56499>.

Fixes #1115.

test: Remove superfluous period from error message

test: Fix printing of error messages with embedded newlines

feat: Don't remove inode cache file on -C/--clear

-C/--clear is tied to the cache directory while the inode cache file is
a temporary file. I think it makes more sense to not consider the inode
cache part of the main cache directory.

fix: Log "bad output file" instead of "cache miss" on output file error

doc: Tweak install guide

doc: Improve install guide (#1121)

feat: Download dependencies from the Internet when unavailable (#1112)

Change the behavior of ZSTD_FROM_INTERNET and HIREDIS_FROM_INTERNET to
always be on and only come into affect when the package is not found on
the system by normal means.

Also use the cmake standard module FetchContent for the
download/checksum/unpack logic.

Signed-off-by: Rafael Kitover <rkitover@gmail.com>

fix: Avoid false positive cache hits for __asm__(".incbin" " \"file\"")

Regression in #983.

Fixes #1120.

feat: Add download-redis script matching the upload-redis (#1111)

fix(file-storage): Remove duplicate backslash from directory

ci: Add VS2022 and MSBuild to Windows CI runners (#1108)

feat(file-storage): Support server name in URL on Windows

fix: Avoid false success for -fcolor-diagnostics probe with GCC

Ccache will produce a false hit in the following scenario, if "cc" is
GCC without being a symlink to "gcc":

  1. ccache cc -c example.c                      # adds a cache entry
  2. ccache cc -c example.c -fcolor-diagnostics  # unexpectedly succeeds

(Most major Linux distributions install cc as a symlink to gcc, and then
the problem doesn't show up since ccache then is able to guess that the
compiler is GCC.)

This bug was introduced by [1] which tried to make yet another tweak of
the color diagnostics guessing/probing by no longer rejecting
-fcolor-diagnostics for an unknown compiler, based on the assumption
that the probing call (speculatively adding -fdiagnostics-color) is only
made when we have guessed a GCC compiler. Unfortunately, this broke the
fix in [2] when the compiler is unknown.

All of this is inherently brittle and I don't see any good way to make
it better with the current compiler guessing approach and adding options
speculatively. The cure is to start doing proper compiler identification
instead (#958). Until that is done, the only reasonable fix is to avoid
doing anything related to color diagnostics flags when the compiler is
unknown. This means that an unknown compiler from now on won't produce
colors when used via ccache even if the compiler actually is GCC or
Clang.

[1]: 97a40af49f56e4be2db5e4318d8131e937bd5598
[2]: 61ce8c44c5b1da0be7a8d10c014f1a85b7967433

Closes #1116.

feat: Add support for GCC -fprofile-abs-path option

Note: -fprofile-abs-path makes the compiler include absolute paths based
on actual CWD in the .gcno file. We therefore need to include the actual
CWD in the hash in order not to get false positive cache hits. To opt
out of this, set "gcno_cwd" sloppiness.

Closes #1060.

refactor: Improve formatting of test_lockfile.cpp

test: Simplify secondary_redis_unix tests

chore: Improve Redis log and exception message

refactor: Simplify Redis URL parameter parsing

doc: Improve description of Redis URLs

fix: Handle more cases of invalid secondary storage URLs

feat: Support Redis over unix socket (#1064)

build: Fix FTBFS with not yet released GCC 13

Reference: https://gcc.gnu.org/gcc-13/porting_to.html#header-dep-changes

Fixes #1105.

fix: Don't display max size in ccache -s if it's 0 (= unlimited)

enhance: Improve lock file implementation

This commit improves brings two improvements to the lock file
implementation:

1. Support for long-lived locks.
2. Support for non-blocking lock acquisition.

There are now two types of lock file classes: ShortLivedLockFile and
LongLivedLockFile. On Windows the implementations are identical. On
other systems, LongLivedLockFile creates a separate "alive file" whose
mtime will be updated regularly by a helper thread until the lock is
released. This makes it possible for another process to wait for the
lock indefinitely but also to know then a lock is stale and can be
broken. The ShortLivedLockFile class works like the lock file class used
to work before: it considers a lock stale after waiting for two seconds
and noticing that the symlink target has not changed during that time.
ShortLivedLockFile is to be used when the lock is expected to be held
for a very short time so that it's a waste of resources to start a
helper thread to keep the lock alive.

On some systems it would be possible to update mtime of the symlink
itself instead of a separate file, but that does not seem to be portable
enough.

Also worth mentioning is that the reason to not use proper fcntl/flock
locks on non-Windows systems is to continue supporting a cache directory
on NFS since file locks on NFS don't have a good track record.

test: Add program for manually testing the lock file implementation

enhance: Fall back to utimes(2) if utimensat(2) is unavailable

fix: Remove AsciiDoc markup from help text of --trim-dir

feat: Let -s/--show-stats show cleanups counter with verbosity 2

bump: Upgrade to nonstd::expected 0.6.1

feat: Add support for Intel compiler on Windows (#1100)

refactor: Remove now unneeded defines of nodiscard and maybe_unused

refactor: Use [[fallthrough]] attribute

refactor: Use structured binding declarations

refactor: Use uppercase literal suffixes

Clang-Analyzer prefers it that way.

refactor: Remove some now unnecessary static_assert messages

refactor: Use std::clamp

ci: Run CodeQL on Ubuntu 20.04

fix: Use a cleanup stamp instead of directory timestamp for cleanup

In order to know when to clean up the temporary directory, ccache checks
mtime of $CCACHE_DIR and updates it to "now" on cleanup. This doesn't
work well when the configuration file is modified often since that also
updates the same mtime.

Fix this by using a separate cleanup stamp file instead.

fix: Clean up temporary dir if it's left the default

Cleanup of the temporary directory is done if it is $CCACHE_DIR/tmp,
which used to be the default until [1] where the default was changed to
/run/user/$UID/ccache-tmp. Improve this so that cleanup happens if the
temporary directory is equal to the default regardless of the default.

[1]: 213d9883a0c3944749f8512eeb784d8572ad8d91

bump: Upgrade to doctest 2.4.9

docs: Mention that mtime is used for LRU cleanup

Closes #1095.

chore: Fix typo in comment about MSVC object files

build: Fix build with newer MSVC 2022 versions (#1093)

feat: Include timestamp in per-object debug filenames

Including a timestamp in the filenames makes it easier to compare two
builds without having to save previous debug files before the second
build. It also makes sure debug files won't be overwritten if an object
file is compiled several times during one build.

test: Avoid warning when running inode_cache in isolation

chore: Fix spelling

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