* [core] Next bunch of changes for Win64

- Replace some more `long` types by `Longptr_t`
- Fix pointer formatting (use `%zx` and `size_t` for architecture dependent format)
- Fix several `warning C4267: 'argument': conversion from 'size_t' to 'Ssiz_t', possible loss of data`

* [skip-ci] Fix compilation warning on i386 platforms

Fix warning: format ‘%zx’ expects argument of type ‘size_t’, but argument 2 has type ‘Long_t’ {aka ‘long int’} [-Wformat=]

* Next bunch of changes for Win64

 - Use different typedefs for (U)Longptr_t to prevent overload errors on Win32
 - First round of replacing (U)Long_t with (U)Longptr_t where applicable (mostly on core) and fix the following kind of warnings (leading to errors when truncating pointers)
   `warning C4311: 'type cast': pointer truncation from 'void *' to 'Long_t'`
   `warning C4312: 'type cast': conversion from 'Long_t' to 'void *' of greater size`

* Better fix for pointer formatting

* Fix compilation warnings

* Apply Philippe's suggestion

* Try to fix 32bit/64bit pointer formatting using %zx

* Try to fix a compilation warning

Try to fix the following warning on `ROOT-debian10-i386/cxx14`:
```
warning: format ‘%zx’ expects argument of type ‘size_t’, but argument 4 has type ‘Longptr_t’ {aka ‘long int’} [-Wformat=]
```

Prior to this patch, we push/pop transaction for each LoadModule call. This is
reasonable if we assume modules are perfectly layered. That is, no eager
module deserialization require definitions from another module. This is hard to
achieve for dependent on ROOT codebases during their incremental migration
process.

The current patch push/pops once per loading of all modules. This should perform
slightly better and allow entangled modules to still load.

This patch should address the CMSSW Modules IB:
Assertion `OldBuilder->DeferredDeclsToEmit.empty() && "Should have emitted all decls deferred to emit."' failed.

0  0x00007ffff6f113d7 in raise () from /lib64/libc.so.6
1  0x00007ffff6f12ac8 in abort () from /lib64/libc.so.6
2  0x00007ffff6f0a1a6 in __assert_fail_base () from /lib64/libc.so.6
3  0x00007ffff6f0a252 in __assert_fail () from /lib64/libc.so.6
4  0x00007fffed24ed82 in clang::CodeGeneratorImpl::StartModule
5  0x00007fffed24d33e in clang::CodeGenerator::StartModule
6  0x00007fffed0664f1 in cling::IncrementalParser::StartModule
7  0x00007fffed066f84 in cling::IncrementalParser::codeGenTransaction
8  0x00007fffed066aec in cling::IncrementalParser::commitTransaction
9  0x00007fffecf1af2c in cling::Interpreter::PushTransactionRAII::pop
10 0x00007fffecf1ae72 in cling::Interpreter::PushTransactionRAII::~PushTransactionRAII
11 0x00007fffece78534 in ClingMemberIterInternal::DCIter::DCIter
12 0x00007fffece7712c in TClingMemberIter::TClingMemberIter
13 0x00007fffece7724c in TClingDataMemberIter::TClingDataMemberIter
14 0x00007fffece750b6 in TClingDataMemberInfo::TClingDataMemberInfo
15 0x00007fffecd25918 in TCling::DataMemberInfo_Factory
16 0x00007ffff6b0e33e in TListOfDataMembers::Load
17 0x00007ffff6ae539d in TClass::CreateListOfDataMembers
18 0x00007ffff6ae54d4 in TClass::GetListOfDataMembers
19 0x00007ffff6ae3dd1 in TClass::GetDataMember
20 0x00007ffff6b259a0 in ROOT::Detail::TSchemaRuleSet::AddRule
21 0x00007ffff6adee6c in TClass::AddRule (rule=0x572670 "HepMC::GenVertex   m_event",
22 0x00007ffff6adead2 in (anonymous namespace)::ReadRulesContent
23 0x00007ffff6adec40 in TClass::ReadRules
24 0x00007fffecd0b3a0 in TCling::Initialize

There are several points to consider:
  * We should understand why there are still DeferredDeclsToEmit;
  * We should remove the `TClingMemberIter` from the init path as it is *very expensive*

* 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

__CINT__ is still defined for backward-compatibility but using
the current interpreter's name is less surprising.

ROOT-10895 suffers from trying to autoload 220 classes, but causing >80k calls to
DeepAutoLoadImpl(). Within one call to AutoLoad(), no new information can arrive that
would allow later recursions of DeepAutoLoadImpl() to now autoload a class successfully.
So whether autoloading a class successfully or not, any class on which DeepAutoLoadImpl()
was called does not need to be re-visited within the same AutoLoad() call.

To achieve that, remember the class names that have been visited already, bringing the
count to (non-early-return) DeepAutoLoadImpl() to the actual number of classes that
we should try to autoload.

And a perf-opt: do not determine type names if the type is fundamental.

And I'm not a big fan of deep code nesting.

Considerably speeds up the deeply nested, hot loops through all members.

Ensure memory managment, silence clang-tidy warnings

When looking up a ctor the modules infrasturcture deserializes more ctor
candidates in the body of the function causing the internal vector implementation
to rellocate and invalidate the pointers.

This patch makes Sema::LookupConstructor void and stabilizes the iteration.

This patch is a previous version of the patch in https://reviews.llvm.org/D91524
and we, after being merged, we should be able to backport it.

TClass::GetBaseClassOffset is a 'often' used routine in the I/O.
In the fast path (looking up in a cache), rather than taking the
global read lock (which is not only global but also 'slower' than
a regular mutex), we are now use a instance specific mutex to
protect the cache.

TObjArray::GetEntries() counts the number of non-zero slots
while TObjArray::GetEntriesFast() return (in most case) the value of a high water mark (the slot over which all remaining slots
are empty).

In one use case (doing read a TTree and do many TTree cloning (via TBufferMerger), TObjArray::GetEntries was taking 8% of the
running time (compression was disabled)

Note: TObjArray::IsEmpty use GetEntriesFast rather than GetEntries.

Don't export (expose) the '?__type_info_root_node@@3U__type_info_node@@A', this leads to the following error in some cases:
MSVCRT.lib(tncleanup.obj) : error LNK2005: "struct __type_info_node __type_info_root_node" (?__type_info_root_node@@3U__type_info_node@@A) already defined in libCling.lib(libCling.dll)

Fixes the following error on Windows with macros containing Windows line endings (CR/LF):
```
Assertion failed: content[posOpenCurly] == '{' && "No curly at claimed position of opening curly!",
file C:\Users\bellenot\git\master\interpreter\cling\lib\MetaProcessor\MetaProcessor.cpp, line 431
```

complex.h causes havoc, e.g.
```
libcomplexDict.rootmap:2:13: error: declaration of anonymous class must be a definition
template <> class complex<float>;
```
running roottest_root_tree_cloning_treeCloneTest, which is caused by `complex` being redefined
to _Complex, which is a kind of type annotation and breaks uses of `std::complex`.

This means we can now remove `#undef I` (which comes from complex.h).
Use cute raw string literals and combine remaining `#undef`s into a single call to `declare()`

With llvm9, the external AST source will only be asked to provide the
definition of an explicit specialization if the forward declaration of
the explicit specialization is flagged as hasExternalLexicalStorage().

In roottest/root/meta/runtemplateAutoload*, the external AST source
is the autoloading; the fwd decl comes from the rootmap file: the
specialization "resides" in a library that needs to be loaded, instead
of instantiating the template from the default definition.

Walk the declarations parsed by the rootmap reader, and flag all
explicit specializations as "has more info". For that to work, explicit
specializations must show up in the declarations section of the rootmap
files.

The start count was off; first fwd decl is at line 2.
Subsequent lines were all appendedn to first one: missing newline.
Only emit the line directive if decls follow; shortens code to be declared.

This solves an issue discovered by llvm9 where we call HandleIncludeDirective
which calls FileNotFound callback which calls TClingCallbacks::FileNotFound
which then triggers a recursive parsing.

The inner parsing changes the current token and when we return the control back
to the original function it dereferences a nullptr in
IncludeTok.getIdentifierInfo (because the current token is eof).

This reverts root-project/root@044b267

See llvm-mirror/clang@aa528ab

See llvm-mirror/clang@90051f7

See llvm-mirror/clang@ef699b2.

ForVisibleRedeclaration does not try to deserialize content from module files.
It should be used for efficiency and when we are sure that what we look up is
in the present TU and it does not make sense to ask the module files.

See llvm-mirror/clang@6bbe311

Declare non-implemented methods as deleted

This put libMultiProc on par with libImt (which now uses/depends on libMultiProc) and allow to delay creation
of the StreamerInfo needed for reading rootpcm.  Both libImt and libMultiProc contains classes not intended
for I/O anyway and not expected to be instropected (so no strong benefit to having a rootpcm).

g++: error: linux-vdso64.so.1: No such file or directory

The list of names filtered out by TCling is incomplete.
The vdso(7) man page gives the following list:

       user ABI   vDSO name
       ─────────────────────────────
       aarch64    linux-vdso.so.1
       arm        linux-vdso.so.1
       ia64       linux-gate.so.1
       mips       linux-vdso.so.1
       ppc/32     linux-vdso32.so.1
       ppc/64     linux-vdso64.so.1
       riscv      linux-vdso.so.1
       s390       linux-vdso32.so.1
       s390x      linux-vdso64.so.1
       sh         linux-gate.so.1
       i386       linux-gate.so.1
       x86-64     linux-vdso.so.1
       x86/x32    linux-vdso.so.1

This commit allows the user to enable/disable specific interpreter capabilities
without requiring to `#include` the heavier weight `Interpreter.h` (that also
has dependencies on llvm).

The only feature covered at the moment is definition shadowing.

Closes cling issue #360.

Walking the dyld map manually is missing the libc lock. Instead, use the
official interface for this. Make sure that any call to UpdateListOfLoadedSharedLibraries
is actually locked by gInterpreterMutex.