Same as: root-5.34.02-externals.

Same as root-5.28-00d-roofit-silence-static-printout.patch

Same as root-5.34.00-linker-gnu-hash-style.patch.

Same as root-5.32.00-detect-arch.

Same as root-5.32.00-detect-arch.patch.

Same as root-5.30.02-fix-isnan-again.spec.

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.

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.

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.

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.

Import cms patches

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.

Removed obsolete static member data and obsolete function bodies.
Added ::Obsolete calls where appropriate.

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.

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.

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.

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

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.

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.

The list of TStreamerInfos held by a TClass can change while processing
and therefore access to it must be protected when using multiple threads.
The gCINTMutex is used for this purpose since the TClass is considered
part of the CINT data model.

We now protect all threaded access to TClass::GetStreamerInfos. In addition
this change properly handles updating the TStreamerInfo cache in a
thread safe manner.

When running with multiple threads, we need to avoid unnecessary changes
to TStreamerInfos. Therefore we check to see if the TStreamerInfo is optimized
before setting it as unoptimized and rebuild it.

The following threading issues were corrected
- TROOT::GetListOfClasses was protected via gCINTMutex
- Access to TStreamerInfo lists were protected via gCINTMutex
- Setting of the cache for current TStreamerInfo and for the list of
  conversion TStreamerInfos is protected via std::atomic<>

Several changes were needed to make this thread-safe for the I/O case
1) Protect the list of handlers with its own Mutex
2) Use a thread_local variable to hold the status of reading a directory
3) Use gCINTMutex to protect access to fBasesLoaded. Had to use gCINTMutex
 since we need threads trying to read the same dirs to wait for the first
 reader to finish so the lock has to be held over the whole call. In addition,
 gCINTMutex is sometimes taken before and sometimes during the call so using
 a different mutex would lead to a deadlock situation.
NOTE: fReadingDirs is not used anymore but is still in the code to allow
binary compatibility to easy testing. This should be removed in the future.

The order of locks between gGlobalMutex and gCINTMutex is undefined
and TStorage::ObjectDealloc calls were involved in order reversal
problems. As it turned out, there is no data structure that needs
protecting in TStorage::ObjectDealloc so we do not need the lock.

TUUID used statics that were causing race conditions. The fix
was to change the statics to thread_local.

-There was a potential deadlock situation between gErrorMutex and
 gCINTMutex. The fix was to limit the scope of gErrorMutex locks
-Changed buffers from static to static thread_local. This allowed
 gErrorMutex to be more limited in scope.

This fixed a problem found by helgrind.

Helgrind found a race condition involving TClass::GetBaseClassOffsetRecurse
calling TBaseClass::Property.

Both TList and TObjArray modify gROOT::GetListOfCleanups() as
part of their cleanup methods. This change uses gROOTMutex to
protect that list.

-Made TStreamerInfo::fgElement thread_local
-Added an additional test bit to avoid rerunning TStreamerInfo::BuildOld.
 This avoids many cases of changing a TStreamerInfo once it is already in use.

-Internal cloning of TStreamerInfo resets kBuildOldUsed so BuildOld will run
-BuildOld calls itself recursively so we only set kBuildOldUsed once we
 leave the function
-Avoid repeated calls to Build
These changes are needed to avoid having multiple threads do the same
work on the same TStreamerInfos which can cause interference between threads.

Made use of a thread_local to hold the ReadingObject status since
the status is only meant to apply to a call chain.

To properly handle cases where different TFiles are being used
on different threads, the various global counters in TFile
were converted to std::atomic<>.

fLiveCount and fgCount are now atomic since they can be
read/modified on different threads without a mutex.

Changed fVersionUsed and fgClassCount of TClass to be std::atomic
since both could be read/modified from different threads without
a mutex.
Also put back fgCallingNew as a class member to minimize code
changes with non-thread safe version.

The kBuildOldUsed bit is transient, like kIsCompiled, and therefore
must be reset when a TStreamerInfo is read from a file.

During the call the Cintex::Callback::operator(), several CINT
data structures are modified and therefore we must take the lock.

To avoid lock order problems, we minimize the time spend holding
the Cintex lock by ROOTClassEnhancer. In addition, there was
a race condition in the previous code during the returning of the
value. That race condition is now fixed.

To handle errors occuring on different threads, the caching of the
last error string was changed from being a member data to a class
static thread_local. This meshes well with Unix since errno is a
thread local there.

TSystem changed the last error string to be a class thread_local
so this code matches that change.
Caching of external path is now a thread_local to avoid race conditions.
Caching of initial time is done via an atomic.

TClass.cxx has a file scope global gObjectVersionRepository which
can be modified simultaneously on multiple threads. Therefore it
needed a mutex lock when reading/writing.

Full name and include name were statics which were set the first time
called. This was not thread safe. These were changed to thread_local.
Alternatively, this could be change to use std::call_once.

The stand-alone formating functions return a pointer to a static
buffer. That is not thread-safe since the buffer could be updated
on a different thread while another thread is reading it. This
change makes the static buffer variable thread_local.

Classes which inherit from TObject have a fgIsA class member
defined by the code generator. However, the value for fgIsA is
set lazily and therefor must be protected in a threaded environment.
fgIsA was changed to be std::atomic<> and the setting of the value
was protected by gCINTMutex to avoid having the calculation done
more than once.

When looking up the value of a cache in the map, it was possible
to temporarily have fLastClass and fLastType out of synch and cause
the program to return the wrong TClass.

By having a TObjArray be deleted outside of the gCINTMutex lock
we no longer have both mutexes being held at the same time and therefore
we avoid potential deadlocks.

Fix multithreading issues in ROOT I/O

The code created by genreflex was including the default namespace
qualifyer '::' on all class names. However, this lead to a C++
language ambiguity when parsing
   std::atomic<TClass*> ::Foo::fgIsA = 0
where the parser treats that as being
   std::atomic<TClass*>::Foo::fgIsA = 0
and fails since Foo is not a type defined in std::atomic<>.
The fix was to remove the '::' when generating the code. This then
matches what Cint does when generating the code.

…ithfgIsA

Worked around ambiguity in C++ for fgIsA and std::atomic<>

This reverts commit 1b092e4.

Revert "Fix trampolines for ARM."

In order to avoid deadlocking, the variables gCintMutex and
gROOTMutex now point to the same underlying mutex. The mutex is
also created when TThread::Init() is first called rather than doing
it lazily.