Signed-off-by: Vassil Vassilev <v.g.vassilev@gmail.com>

This prevents the vector to be reallocated if the size exceeds the capacity of
the vector causing invalid pointer accesses.

Fixes ROOT-7749.

The new release includes some improvements in both Forward and
Reverse mode:
* Extend the way to specify a dependent variables. Consider function,
  `double f(double x, double y, double z) {...}`, `clad::differentiate(f, "z")`
  is equivalent to `clad::differentiate(f, 2)`. `clad::gradient(f, "x, y")`
  differentiates with respect to `x` and `y` but not `z`. The gradient results
  are stored in a `_result` parameter in the same order as `x` and `y` were
  specified. Namely, the result of `x` is stored in `_result[0]` and the result
  of `y` in `_result[1]`. If we invert the arguments specified in the string to
  `clad::gradient(f, "y, x")` the results will be stored inversely.
* Enable recursive differentiation.
* Support single- and multi-dimensional arrays -- works for arrays with constant
  size like `double A[] = {1, 2, 3};`, `double A[3];` or `double A[1][2][3][4];`

See more at: https://github.com/vgvassilev/clad/blob/v0.5/docs/ReleaseNotes.md

From V.Vasilev, it fixes:
[ 72%] Building CXX object interpreter/llvm/src/tools/clang/lib/CodeGen/CMakeFiles/clangCodeGen.dir/CodeGenModule.cpp.o
While building module 'Cling_Interpreter' imported from /.../root/core/clingutils/src/RStl.cxx:25:
In file included from <module-includes>:5:
 /.../root/interpreter/cling/include/cling/Interpreter/RuntimeUniverse.h:13:2: error: "This file must not be included by compiled programs."
 #error "This file must not be included by compiled programs."
 ^

The getNameAsString interface causes a lot of temporary allocations.
The analysis if a decl is a cling-style wrapper can work only on a
simple declarations on the global scope.

This patch filters out complex declarations (eg in namespaces) and
checks only the identifier content.

The patch reduces the memory footprint difference shown in root-project/root#3012.

Duplicating Cling_Runtime and Cling_Runtime_Extra in both module.modulemap
and module.modulemap.build causes redefinition errors if -Dbuiltin_clang=Off.
We should not duplicate the cling runtime modules in both modulemaps.

The user might use utilities which print on cout and expects the output
to be shown immediately.

This patch automatically flushes std::cout after each execution of a wrapper.

This code must be replaced by a HeaderSearch of vector, stdio.h and then
use their DirectoryEntry-s as path for buildModuleMapOverlayEntry().

This patch prepares the infrastructure to be able to work with a
global module index.

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

Make sure hexadecimal pointer values have the correct '0x' prefix (not automatic on Windows)

This patch includes:
- Remove existing modulemap.overlay files
  Cling now can generate virtual overlay files on-demand.
- Implement `-modulemap_overlay` flag to Cling
  This flag is used to tell Cling the location of modulemaps to be
  overlayed. (eg. stl.modulemap, libc.modulemap)
- Generate and load virtual modulemap in Cling
  It is in Interpreter constructor, happens as part of cxxmodules
  initialization step.
- Implement an interface to Clang CompilerInvocation which can take FileSystem pointer
  Previously, Clang only took a "string of filenames" which clearly doesn't
  work for our usecase. We already discussed this new interface at
  modules meeting, so this change will land upstream.
- Add a file existence check in Clang
  When compiling a pcm and when Clang saw the #include with which pcm was available
  (or being generated implicitly), Clang was putting a notation of the full path to this pcm.
  This caused an error when build directory was deleted, because the path didn't exist anymore.

This patch enables modules to be binary distributed, and to make it
work in CMSSW enviroment.

Allows dynamic opt level setting to have an effect on functions!

Fixes: ROOT-9695, ROOT-9805

This patch (also) aims to make runtime module installable.

This part of code in Clang is comparing the location of "modulemap which
is currently loaded and gives a definition of current module (say, stl)
and "the location of the modulemap where the current implicit module (like stl) was built".

This was problematic for CMSSW, as they should install modulemaps
and prebuilt pcms to other directory. stl and libc pcms should be
prebuilt, installed and used from installed directory, so this check is
redundant for that usecase.

This patch contains two functionality:
1. Autoloading of dynamic symbols for system headers
   There is three kind of symbols in shared object file, which is 1
   normal symbols, 2 dynamic symbols, and 3 hidden visibility symbols.
   Linker doesn't care about 3, but should take care (of course) 1 and
   2. For system headers, often symbols are defined in .dynsym section
   which means they are 2 dynamic symbols. This patch adds support of
   autoloading those symbols. We fallback to resolving dynamic symbols
   from system headers only if we couldn't resolve from normal symbol
   table, as the initialization of header search is expensive (iterating
   through all system headers)
2. Register callback from IncrementalExecutor
   Previously, LazyFunctionCreatorAutoload was getting callback only
   from DynamicLibraryManager::loadLibrary. This was enough for fixing
   tests, but is insufficient to handle "symbol <something> unresolved
   while linking function" errors as those errors are emitted from
   IncrementalExecutor. Adding a callback from IncrementalExecutor
   enables us to unresolved symbols.

It fixes these kind of errors:
`IncrementalExecutor::executeFunction: symbol '_ZN7TCanvasC1EPKcS1_iiii' unresolved while linking function '_GLOBAL__sub_I_cling_module_8'!`

When cling is embedded and the plugins are linked statically we can rely
on the initialization of the Preprocessor to register the pragmas.

Currently, due to the current implementation deficiency we cannot rely
on the same mechanism when loading the plugins as shared objects.

This patch fixes the failing cling test.

Optimize clang::ASTReader by using DenseMap instead of vector

This gives ~20 MB memory improvement.

This optimizes the ROOT startup for C++ Modules by avoiding
deserialization of redundant declarations.

See [dcl.inline].4: "A function defined within a class definition is an inline
function."