Clean up the way externals are picked up.

Same as: root-5.34.02-externals.
Silence roofit banner.

Same as root-5.28-00d-roofit-silence-static-printout.patch
Specify gnu hash style.

Same as root-5.34.00-linker-gnu-hash-style.patch.
Correct platform detection on mac.

Same as root-5.32.00-detect-arch.
Silence warnings.

Same as root-5.32.00-detect-arch.patch.
Use correct isnan.

Same as root-5.30.02-fix-isnan-again.spec.
Fix trampolines for ARM.
Thread-safe determination of TObject::IsOnHeap()

The previous mechanism of determining TObject::IsOnHeap() was found
to be inaccurate and thread unsafe. The new way is to fill the memory
area returned by calls to TObject::new with a special value and
as the first operation in TObject's constructor look to see if the
uninitialized member data have that value set. If they do we assume
the object was made via a call to 'new' and therefore is on the heap.

The interface in TStorage used to implement the old mechanism has
been declared obsolete via the use of ::Obsolete.
Removed use of TStorage::IsOnHeap

This is the only use of TStorage::IsOnHeap outside of TObject constructor.
It appears to be checking to see if the object might not be available anymore
and if so don't talk to it. This test is highly inadequate to answer that
question and since we want to get rid of TStorage::IsOnHeap for other reasons,
it was decided to remove its use here.
Made TClass::fgCallingNew a thread_local file scope static

In order to avoid thread-safety issues, the static class member
TClass::fgCallingNew is no longer a class member and is instead
a file scoped static declared thread_local. It was necessary to
not have it is a class member since CINT could not parse the new
thread_local keyword.
Don't reset global in TClass::New

Helgrind was complaining about a global being written without a lock.
In this case, the global is not actually changed so we do a check
to see if the old value was the same as the value we set and if
so, we don't bother to change it.
Support for C++11 in ARM builds
Fast and dirty version of setting special value in TObject::new

Write special values into memory after TObject::new called in order to
have TObject's constructor determine if the object was made on the heap.
Cleaned up TStorage changes

Removed obsolete static member data and obsolete function bodies.
Added ::Obsolete calls where appropriate.
Encapsulate check on alloc in TStorage::FilledByObjectAlloc

Instead of having TObject's constructors know explicitly about how
TStorage::ObjectAlloc works, we no encapsulate that knowledge into
TStorage::FilledByObjectAlloc.
Additionally, switched from fBits to fUniqueID when checking for
assignment from 'new' in order to more easily create a valgrind
suppression entry.
Added suppression entries for determining if TObject on heap

To determine if TObject is on the heap we read the value of a member
data before it has been set by the constructor. If it was heap
allocated the TObject::operator new will have filled special values
into the memory area. However, for stack allocated it is
unset. This makes valgrind report an error. Given we intend this
behavior, we suppress the message.
Make variable used for GUID of TKeys atomic

Since TKeys can be made by different threads, it is necessary to
protect the global used to assign the GUID of TKeys,  keyAbsNumber
so that we are guaranteed to get a unique value for each request.
C++11 atomics give that guarantee.
Protect Cintex structure with mutex

The caching of TClasses by Cintext could be updated at anytime and
therefore needs to be protected when running multi-threaded.
Make zip globals thread local

The zip functions use globals to hold state while calling from
function to function. Such use is not thread safe. Given the globals
are only used during a function call chain, it is safe to change them
to thread local. Given this is compiled by a C compiler, we must use
the gcc specific __thread keyword.
Protect access to TROOT::GetListOfFiles()

When new files are opened or closed, gROOT->GetListOfFiles() is updated.
If the opening/closing happens on different threads then we need to
serialize all access to that list. This changes uses gROOTMutex to
serialize those accesses.