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."

The clang::Preprocessor::RegisterBuiltinPragmas already registered them

This patch avoids an assertion when re-adding the same pragma twice.

The new release includes some improvements in both Forward and
Reverse mode:
  * Support `x += y`, `x -= y`, `x *= y`, `x /= y`, `x++`, `x--`, `++x`, `--x`
    in forward mode.
  * Reduce emission of unused expressions
  * Add a special `#pragma clad ON/OFF/DEFAULT` to annotate regions which
    contain derivatives
  * Various small optimizations

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

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.

(cherry picked from commit 1dd7ac75cf5ecc1ef91c5aa1cc2ba65c46e8d585)

This reverts commit 0f583c7e.

We need this change because whoever uses MetaParser.h will not be
able to compile their program. MetaParser.h includes MetaLexer.h.