C++-ify lockfile routines

Simplify lock breaking

Acquiring a .lock.lock file does not make lock breaking significantly
safer; there is still a race condition. Simplify it by simply deleting
the lockfile when breaking and try to acquire it again.

Rewrite the Windows version of the lockfile routines

Instead of emulating the POSIX version, use the native Windows file API
to create a lockfile. This should mitigate several problems with the old
implementation.

Hopefully fixes #537.

(cherry picked from commit 53b9fdd6272896bb4a2dc42c9680d4030f86b33c)

Cap time to sleep to 10 ms when failing to acquire a lock

(cherry picked from commit 41ffc7ec009237da51040c6059b1bcd7903af30d)

Rewrite absolute input path to relative

This can now be done due to no longer using realpath in
make_relative_path (e8444a38).

Let development version be BRANCH.SHORTHASH

Previously the version of a master-based development build was something
like 3.7.1+NNN_gSHORTHASH which is a bit misleading.

Convert counters to a class (#548)

Also remove file writing logic from `stats_update_size()` and
delete unused declaration of `stats_timestamp()`.

Convert the single ofstream use to fwrite (#552)

Read/write optimizations (#551)

* Avoid one extra read call after the final bytes are read

If read returns less then the requested number of bytes, the file is at
EOF. This can be used in all places where a read is done, but it makes extra
impact in read_file where if the buffer is made one byte bigger than needed,
EOF can be detected before a unnecessary memory reallocation is done.

* Use write instead of fwrite to write the result file

This avoids the caching in stdio where a write is split into two (at least on
my system): first a small 4k one and then one with the remaining 60k.

Avoid duplicate stat calls (#550)

hash_source_code_string will, in read_file, stat the file to get the file
size. But when called from verify_result, the file size is already known so by
using this size the number of stat calls in a normal run can be cut in half.

Fix empty <obj>.ccache-log in debug mode without log_file set

Regression in dcf6ab3f349a33974b31ce2e7c06a2085149ab4a.

Add notes about intentional use of CCACHE_DEBUG in test cases

Restore test suite debug output where needed (#546)

Two fileclone tests rely on the output.

Low hanging fruits of some auto fixable improvements via clang-tidy (#545)

Merge pull request #544 from erijo/out-of-tree-commands

Fix four minor cppcheck warnings

- uninitvar:src/ccache.cpp:3422: Uninitialized variable: ctx
- redundantInitialization:src/legacy_util.cpp:1067: Redundant initialization
  for 'q'. The initialized value is overwritten before it is read.
- constVariable:src/stats.cpp:429: Variable 'ctx' can be declared with const
- variableScope:src/Util.cpp:404: The scope of the variable 'right' can be
  reduced.

Pass std::string instead of .c_str()

to function taking std::string.

Remove unused function stats_get_pending

Make cppcheck, format and check_format work in out-of-tree build

Remove leftover debug settings in test suites

Don’t use realpath(3) for normalization when computing relative paths

The current working directory (CWD) can come from two sources: Either
the return value of getcwd(3) (“actual CWD” below) or the environment
variable $PWD (“apparent CWD” below). The former is returned by e.g.
$(CURDIR) in Makefiles and by “pwd -P” and is always in normalized form
(no “.” or “..” parts or extra slashes). The latter is returned by “echo
$PWD” or “pwd” and can potentially be in unnormalized form on some
systems.

The actual CWD and apparent CWD may also differ if there are symlinks in
the path. Absolute paths to files given to ccache can therefore be based
on either of these CWD forms. When computing relative paths under the
base directory the CWD needs be in normalized form for the algorithm to
be reasonably simple.

2df269a3 solved a bug with an unnormalized apparent CWD by using
realpath(3) for normalization. Using realpath also makes the algorithm
correct in the presence of symlinks. It however also means that all
symlinks (both in CWD and in command line arguments) are dereferenced.
The downside of this is that if either of the symlink targets contain
specific names (such as build ID, date, username or similar) then the
relative paths will also contain those specific path names, leading to
cache misses.

Solve this by:

- Performing normalization without using realpath, i.e. without
  expanding symlinks.
- Computing a relative path based on normalized CWD and normalized path.
- Checking whether the relative path resolves to the same i-node as the
  original path. If it does, use it, otherwise just use the original
  path (and take a potential cache miss).
- Doing the above calculation both for the actual and the apparent CWD
  and choose the best one.

This solves the problem that PR #491 intended to address in a better
way.

Improve basedir calculation on Windows

Now basedir with backslashes or forward slashes should work.

Let Util::get_apparent_cwd return a normalized CWD

Add Stat::same_inode_as method

Add default Stat constructor

C++-ify make_relative_path

C++-ify get_relative_path

C++-ify common_dir_prefix_length

Implement Util::normalize_absolute_path

Normalization here means syntactically removing redundant slashes and
resolving "." and ".." parts. The algorithm does however *not* follow
symlinks, so the result may not actually resolve to `path`.

Make Util::is_absolute_path work with MSYS/Cygwin/POSIX win32 paths

C++-ify is_absolute_path

Sort test cases

Move basedir tests to the basedir test suite

Add pch test suite probe for seemingly broken compiler support

This fixes a problem mentioned by Orion Poplawski in a comment to PR #217.

Const-ify Context& parameters where possible

Simplify setting of ctx.args_info.profile_dir default value

Convert stats_update(x) + failed() to failed(x) in hash_*command*()

Use find_executable_in_path to find executable in hash_command_output

This makes the Windows version behave similar to the non-Windows
version: just search in $PATH, not potentially in the path specified by
the “path” configuration setting.

Make failure to run compiler_check command a soft error

No need to make a failure when running the compiler check fatal since
other misconfigured settings can have a similar effect without resulting
in fatal errors.

Rename cc_process_args to process_args

Convert stats_update(x) + failed() to failed(x) in cc_process_args

Convert most stats_update(x) + failed() to failed(x)

Don’t increment STATS_COMPILER on fatal error

Statistics counters are otherwise never incremented on fatal errors.

Make it possible to run failed() and not execute the real compiler

This removes one of the last x_exit calls deeper into the main ccache
code paths.

Remove leftover cc_reset declaration

Merge pull request #543 from totph/ctx5

Final Globals -> Context moves

Turn lock_staleness_limit into a constant

Remove now-empty legacy_globals.cpp/hpp.

Context: move counters

Context: move ignore_headers_len, remove cc_reset()

Context: move included_pch_file and convert to std::string

Context: move guessed_compiler

Convert guessed_compiler into an enum class

Context: move manifest_stats_file and convert to std::string

Context: move cpp_stderr and convert to std::string

Context: move i_tmpfile and converted to std::string

Context: move has_absolute_include_headers

Context: move g_included_files

Context: move time_of_compilation, adapt manifest

Context: move manifest_path and converted to std::string

Context: move (cached_)result_name/result_path

Also convert result_path to std::string.

Context: move arch_args

Context: move output_is_precompiled_header

Partially revert const-ification of context parameters

Improve functions related to CWD

The different functions related to current working directory (CWD) have
become messy during the years:

- gnu_getcwd is a simple wrapper around getcwd(3), thus returning the
  actual canonical path.
- get_cwd returns $PWD, falling back to getcwd(3) if $PWD is not sane.
- get_current_working_dir (local function in ccache.cpp) memoizes
  x_realpath(get_cwd()) (i.e., getcwd(3) in essence...) in the global
  current_working_dir variable. Unit tests may manipulate
  current_working_dir.

Improve this by:

- Replacing gnu_getcwd with Util::get_actual_cwd.
- Replacing get_cwd with Util::get_apparent_cwd.
- Removing get_current_working_dir and placing both actual and apparent
  CWD in the context object.

Simplify (non-)freeing of orig_args on failure

Simplify string creation from string_view

Remove now redundant resetting of config

Since the configuation no longer is global there is no need to reset the
unmodified Config object passed by cct_test_begin to cc_reset.

Const-ify context parameters where appropriate

Merge pull request #542 from totph/ctx4

Context: g_config, stats_file and orig_args moved

Context: move orig_args

Context: convert stats_file to an std::string

Also adapted downstream stats functions.

Context: move stats_file

Context: move g_config

Implement Util::read_link, replacing legacy x_readlink

Implement Util::real_path, replacing legacy x_realpath

Merge pull request #541 from totph/ctx3

Context: move 9 more globals

Context: move using_precompiled_header

Context: move profile_use/profile_generate

Context: move direct_i_file

Context: move profile_dir

Context: move profile_arcs

Context: move seen_split_dwarf

Context: move generating_diagnostics

Context: move generating_stackusage

Context: move generating_coverage

Rename clang-format.sh to run-clang-format

This avoids exposing implementation details.

Build static Windows executables

This makes it possible to run e.g. the unittest binary in Wine.

Simplify result_name_from_depfile signature

Simplify Util::{base,dir}_name

This also fixes a bug in the Windows versions.

Added 'make check_format' to makefile rules (#525)

'make format' formats all source files with clang-format, and
'make check_format' only checks and on failure prints a diff,
then exits with the appropriate status.

Because quick interactive formatting is one use case, xargs is
used for parallelism. Proper make-parallelism would require
-k and -j arguments to work.

Merge pull request #538 from totph/ctx2

Context: move 7 more globals

Context: move generating_dependencies

Context: move actual_language

Context: move output_dwo

Context: move output_dia

Context: move output_cu

Context: move output_cov

Context: move output_dep

Test out-of-tree build in Travis-CI

Fix out of tree build (#540)

The CPPFLAGS contain "-I.", but not "-I$(srcdir)", which means "src/ScopeGuard.hpp" was only
found when building from the source root.