The underlying issue is the setSeverity method compares if the given
source location was before or after a push diagnostic mappings (pragma push).
The problem is that we 'give' a wannabe source location, because the
memory buffer (which will expand it to a real source location) is not
parsed yet. Thus the pseudo-valid source location looks like a location
came from a pch, which causes a misbehavior in the logic of comparer.

Ensure that -DNDEBUG is defined for all build types except "Debug". This is assumed in LLVM to disable asserts.

Added TGeoElementTable::AddElement(TGeoElement *elem) interface to add user elements to the element table. Added TGeoElement::Print(option) to allow printing the element table. Several options available

(cherry picked from commit dda50a55)

In commit 73449447, the enabling of the autoloading was moved from TROOT to
TApplication to delay it until after main starts (i.e. "after TROOT has been
fully created and all linked libraries have been initialized.").

This had the somewhat unintentional side-effect of disabling the autoloading
if the user's executable did not have a TApplication.

Now that the initialization of the interpreter must also be delayed after the
start of main (see commit 73449447 and de8922d1 and TROOT.cxx comments) we
can move the enabling of the autoloading back to TROOT (but this time in
TROOT::InitInterpreter rather than the constructor).

Also prevent any enable of the interpreter autoloading when library loading is
not allowed.

Add TCling::fAllowLibLoad (false in rootcling, true otherwise).  This re-enable
TCling::AutoLoad by default and repairs ROOT-6580.

Historical notes:

There is two distinct part of the autoloading.

(a) The autoloading callback that is triggered during parsing by the interpreter
of user code or header files (This can also be triggered by lookup in the
type database, for example by ResolveTypedef).

(b) The function TInterpreter::AutoLoad which is explicitly called when the
library for a TClass is needed, for example from the I/O or from the code
implementing the callbacks for (a).

(a) was enabled only when we have a TApplication (See commit 73449447).
It was also enabled in rootcint when called by ACLiC but with a different
implementation of the autoload callback.   In rootcling, the same behavior
has been implementated using a different callback in ROOT::Scanner rather
than in the interpreter.

(b) was never disabled and the calling code was the only decider of
whether to execute it or not.

Once we connected libRIO to rootcling, we need a way to avoid the library
loading; we found it easiest to re-use the disabling of the autoloading (a) to
also cancel the side effect of (b) [For example the inadvertent loading of the
actual libRIO.so eventhough the .o are already linked in.]

However disabling (b) when (a) is disabled (or not yet enabled) changes the
behavior of executables (for example 'hadd') that do not have a TApplication.

The two functionalities are really semantically distinct:

(a) load library when the interpreter receive a request for the type
(b) load the library when the calling code 'knows' it needs the TClass.

As the rest of the code currently stand, allowing the execution of
TCling::AutoLoad does *not* lead to any visible problem during the build of
ROOT or the execution of roottest.

However there is never any good reason to have rootcling load any libraries,
so we must keep TCling::AutoLoad disabled during rootcling execution.

(cherry picked from commit 4218ec06)

Adding cling as llvm external project is done implicitly already when placing cling (soft link) in llvm/src/tools

and eliminate the duplication of code.

(cherry picked from commit 975a940d)

Copy from 5.34 patches: Copy now in the TFitResult the TF1 function pointer, which will be managed by the class. This fixes the bug ROOT-6582