* First step to port ROOT on Windows 64 bit

 - Introduce the Win64 option and flags in the CMake build system
 - Introduce the new `Longptr_t` and `ULongptr_t` types to hold a pointer (4 bytes on Win32 and 8 bytes on Win64), aimed to replace the `Long_t` and `ULong_t` used to cast pointers, and being both 4 bytes on Windows. Their values will not change on other platforms (`Long_t` and `ULong_t`) for backward compatibility
 - Add the 64 bit export symbols in `core/metacling/src/CMakeLists.txt`
 - Add the 64 bit version of lzma (xz-5.2.4-win64.tar.gz)

* Add forgotten semicolons

For some reason llvm/cmake handles cling differently and we should suppress its
installation in ROOTSYS.

The reason is that llvm soon will use new features which are not available
on older versions.

That is a temporary fix to support gcc 4.8 and higher.

This reimplements root-project/root@13e0c197f3

Cling needs to be built and installed as part of llvm/clang and
then we need to specify paths as we do for builtin_clang=Off.

LLVM_DIR cannot be "${CMAKE_BINARY_DIR}/interpreter/llvm/src" in case
of external LLVM, set it to ${LLVM_BINARY_DIR} instead.

ROOT-10812: Fix building clad with external clang

The replacements removes the -Werror option for externals, which is
intended. However, it also replaces e.g. -Werror=format-security with
=format-security, which results in compilation failures due to the
unknown option =format-security.

* Change compiler flags for Visual Studio v16.4.0 & v16.5.0

 - core/base: Since Visual Studio v16.5.0 the /O2 optimization flag makes most of the roofit/roostats tests failing
 - hist/histv7/test: Using /O2 compiler flag prevent the followin error when building in debug mode:
   axis.obj : fatal error LNK1179: invalid or corrupt file: duplicate COMDAT '??$?8DU?$char_traits@D@std@@@__ROOT@experimental@std@@YA_NV?$basic_string_view@DU?$char_traits@D@std@@@012@0@Z'

Reduce build times:
  - use lld or gold or good-old-ld, in that order of preference;
  - split debug info to accelerate rebuilding and relinking;
  - do not rebuild shared libraries just because a shared lib they depend on has changed;
  - generate the gdb-index to accelerate root startup in gdb.
Turn on -Werror to not overlook warnings.

After the update to Visual Studio v16.4.0, the /O2 optimization flag in the interpreter make many (25%) of the tests failing.
Try to re-enable /O2 after the upgrade of llvm & clang, or after updating Visual Studio (v16.5.0 beta 2 still doesn't work)

We had symbols exposed, which in turn meant symbols were resolved by the dynamic loader,
which in turn meant another libllvm.so could interfere with those of cling. By hiding these
symbols, all symbols are self-contained and not external symbols leak into libCling.
cling needs to resolve its own symbols, so unhide those.

We print a message when we configure ROOT in Debug mode that LLVM is still
in release. This is only relevant when -Dbuiltin_(llvm/clang)=On.

Reword the message and add another message displaying the build mode of external
llvm if builtin llvm is off.

Usually the system packages have the version as a suffix,
whereas if one builds clang by hand the name is llvm-config.

[ROOT-9924] Installing headers for clad

Fixes: ROOT-9695, ROOT-9805

XCode 10 comes with -fmodules-local-submodule-visibility aware toolchain.

This patch adjusts a few flags to enable a cxxmodules=On builds for this
platform. This patch will pave our way for enabling runtime_cxxmodules on OSX.

clad is a C++ plugin for clang and cling that implements automatic
differentiation of user-defined functions by employing the chain rule in
forward and reverse mode, coupled with source code transformation and AST
constant fold.

In mathematics and computer algebra, automatic differentiation (AD) is a
set of techniques to numerically evaluate the derivative of a function
specified by a computer program. AD exploits the fact that every computer
program, no matter how complicated, executes a sequence of elementary
arithmetic operations (addition, subtraction, multiplication, division, etc.)
and elementary functions (exp, log, sin, cos, etc.). By applying the chain
rule repeatedly to these operations, derivatives of arbitrary order can
be computed automatically, accurately to working precision, and using at
most a small constant factor more arithmetic operations than the original
program.

AD is an alternative technique to symbolic and numerical differentiation.
These classical methods run into problems: symbolic differentiation leads
to inefficient code (unless done carefully) and faces the difficulty of
converting a computer program into a single expression, while numerical
differentiation can introduce round-off errors in the discretization
process and cancellation. Both classical methods have problems with
calculating higher derivatives, where the complexity and errors increase.
Finally, both classical methods are slow at computing the partial
derivatives of a function with respect to many inputs, as is needed for
gradient-based optimization algorithms. Automatic differentiation solves
all of these problems, at the expense of introducing more software
dependencies.

This patch allows ROOT to interoperate with clad. Namely, users can ask
the interpreter to produce a derivative or a gradient to a known function.

An illustrative example code for first order derivative:

root [0] #include "Math/CladDerivator.h"
root [1] double my_pow2(double x) { return x*x; }
root [2] auto meta_obj = clad::differentiate(my_pow2, /*wrt 1-st argument*/0);
root [3] meta_obj.dump();
The code is: double my_pow2_darg0(double x) {
    return (1. * x + x * 1.);
}
root [5] meta_obj.execute(1) // no iterations, at the cost of function call.
(double) 2.0000000

Learn more about clad at https://github.com/vgvassilev/clad

Patch by Aleksandr Efremov and me!

To do so one needs to pass -Dbuiltin_llvm=Off -Dbuiltin_clang=Off and the
PATH should contain the path to llvm-config.

Note this is not enabling ROOT to work with vanilla clang!

This patch allows ROOT to be built against a prebuilt clang and llvm from
https://root.cern.ch/git/{llvm.git,clang.git}. It allows to reduce ROOT's
build times (in cases when cmake decides to rebuild the in-tree llvm for
no good reason). It moves the common denominator of different ROOT builds
in one place to save space. It also allows easy switch between LLVM in
debug and release mode.

To build the external clang and llvm exactly in the same way as the
in-tree builds use:

CMAKE_FLAGS="\
            -DLLVM_ENABLE_WARNINGS=OFF                   \
            -DLLVM_INCLUDE_TESTS=OFF                     \
            -DCLANG_INCLUDE_TESTS=OFF                    \
            -DLLVM_INCLUDE_EXAMPLES=OFF                  \
            -DCLANG_BUILD_TOOLS=OFF                      \
            -DCLANG_TOOL_ARCMT_TEST_BUILD=OFF            \
            -DCLANG_TOOL_CLANG_CHECK_BUILD=OFF           \
            -DCLANG_TOOL_CLANG_FORMAT_BUILD=OFF          \
            -DCLANG_TOOL_CLANG_FORMAT_VS_BUILD=OFF       \
            -DCLANG_TOOL_CLANG_FUZZER_BUILD=OFF          \
            -DCLANG_TOOL_CLANG_IMPORT_TEST_BUILD=OFF     \
            -DCLANG_TOOL_CLANG_OFFLOAD_BUNDLER_BUILD=OFF \
            -DCLANG_TOOL_CLANG_RENAME_BUILD=OFF          \
            -DCLANG_TOOL_C_ARCMT_TEST_BUILD=OFF          \
            -DCLANG_TOOL_C_INDEX_TEST_BUILD=OFF          \
            -DCLANG_TOOL_DIAGTOOL_BUILD=OFF              \
            -DCLANG_TOOL_LIBCLANG_BUILD=OFF              \
            -DCLANG_TOOL_SCAN_BUILD_BUILD=OFF            \
            -DCLANG_TOOL_SCAN_VIEW_BUILD=OFF             \
            -DLLVM_BUILD_TOOLS=OFF                       \
            -DLLVM_TOOL_LLVM_AR_BUILD=OFF                \
            -DCLANG_TOOL_CLANG_OFFLOAD_BUNDLER_BUILD=OFF \
            -DLLVM_FORCE_USE_OLD_TOOLCHAIN=ON            \
            -DCLANG_ENABLE_STATIC_ANALYZER=OFF           \
            -DCLANG_ENABLE_ARCMT=OFF                     \
            -DCLANG_ENABLE_FORMAT=OFF                    \
            -DLLVM_TARGETS_TO_BUILD=host                 \
            -DLLVM_ABI_BREAKING_CHECKS=FORCE_OFF         \
            -DLLVM_ENABLE_ABI_BREAKING_CHECKS=OFF        \
            -DCMAKE_INSTALL_PREFIX=..                    \
            -DCMAKE_BUILD_TYPE=Debug"

cmake "$CMAKE_FLAGS"   ../../../sources/root-llvm/

This option uses ExternalProject_Add() to clone and build the clad
plugin. However, things that assume a network connection have to be
disabled by default in order not to break builds on machines without
a network connection or inside a sandbox environment.

The directory is hard-coded without suffix in other places, so
necessary headers for clang are not installed if the suffix is
kept.

This patch allows ROOT to be built against compatible external llvm (5.0
or 5.0.1). Note that we still need to build clang (eg. we require
builtin_clang=On) due to the ROOT-specific patches which are not yet
upstream.

Since we have externally installed llvm, we configure and build clang as
a standalone project. The configuration relies on finding llvm-config-5.0
and uses an adapted version of the standard clang standalone build
procedure.

Clang provides dependencies such as FileCheck and not which are used by
cling's testsuite and are not being installed with the standard llvm
package.

Cling (which depends on llvm and clang) is built as a clang tool to avoid
unresolved dependencies to clang and complicating further the already
complicated cmake setup.

This patch intends a minimal change and follows the initial (suboptimal)
design to configure and build llvm, clang and cling as part of ROOT. An
ultimate solution would be to have llvm, clang and cling built as separate
standalone projects (following the recommended way by the LLVM cmake
developers).