Conflicts:
	core/base/src/TPluginManager.cxx
	core/clib/inc/mmprivate.h
	core/meta/src/TCintWithCling.cxx
	core/utils/src/LinkdefReader.cxx
	core/utils/src/SelectionRules.cxx
	core/utils/src/rootcling.cxx
	tree/tree/src/TBranchSTL.cxx

Conflicts:
	core/meta/inc/TClass.h
	core/meta/src/TClass.cxx
	core/meta/src/TStreamerElement.cxx

Conflicts:
	cint/ROOT/CMakeLists.txt

Fix many compilation errors on Windows, following the latest "Thread Safety Improvements"

Conflicts:
	cint/cintex/src/ROOTClassEnhancer.cxx
	core/meta/src/TClass.cxx

This is ‘instead’ of re-compiling the StreamerInfo to force the optimized
list to be of the type (optimized/non-optimized) the calling code needed.

Add to TVirtualStreamerInfo the routines:

    TStreamerElement *GetElement(Int_t id) const;
    Int_t  GetElementOffset(Int_t id) const;

respectively as a convenience accessor and as a performance accessor
to the StreamerElement information based on ‘id’ being the index
in the full list of StreamerElement (in contrast GetElem and GetOffset
take an id which is the index in the shorter list of optimized elements).

Add TStreamerInfo::GetNelement() as a short cut to  fElements->GetEntries();

Conflicts:
	io/io/src/TStreamerInfoActions.cxx

SetStreamerElementNumber nows received the StreamerElement and actually 'Type' used
for I/O.

Update the code of TBufferXML, TBufferSQL2 and TBufferJSON accordingly.

Mark GetStreamerElementReal as obsolete.

Gather all the 'compilation' information in TCompInfo such that we can later
have a set of TCompInfo (pointers) for the non-optimized and a different set
for the optimized version (for object-wise streaming).

Note the following interface changes in TVirtualStreamerInfo

-   virtual ULong_t          *GetElems()   const = 0;
+   virtual TStreamerElement *GetElem(Int_t id) const = 0;

-   virtual Int_t      *GetOffsets() const = 0;
+   virtual Int_t       GetOffset(Int_t id) const = 0;

and the following changes in TStreamerInfo:

-   Int_t              *GetLengths() const {return fLength;}
+   Int_t               GetLength(Int_t id) const {return fComp[id].fLength;}

-   ULong_t            *GetMethods() const {return fMethod;}
+   ULong_t             GetMethod(Int_t id) const {return fComp[id].fMethod;}

-   Int_t              *GetNewTypes() const {return fNewType;}
+   Int_t               GetNewType(Int_t id) const {return fComp[id].fNewType;}

-   Int_t              *GetTypes()   const {return fType;}
+   Int_t               GetType(Int_t id)   const {return fComp[id].fType;}

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.

Conflicts:
	core/thread/src/TThread.cxx

Conflicts:
	core/base/src/TStorage.cxx

Conflicts:
	core/meta/src/TCint.cxx

TBaseClass' property and offset are used 'often', using a CINT
lock while grabbing it increase noticably the serialization.

Conflicts:
	core/meta/inc/TBaseClass.h
	core/meta/src/TBaseClass.cxx
	core/meta/src/TClass.cxx

Conflicts:
	core/meta/src/TClass.cxx

TClass objects can be created as a result of opening a TFile (in which
they are in emulated mode) or as a result of loading the dictionary for
the corresponding class.   When a dictionary is loaded any pre-existing
emulated TClass is replaced by the one created/coming from the dictionary.
To have a reference that always point to the 'current' TClass object for
a given class, one should use a TClassRef.
TClassRef works by holding on to the fPersistentRef which is updated
atomically whenever a TClass is replaced.  During the replacement the
value of fPersistentRef is set to zero, leading the TClassRef to call
TClass::GetClass which is also locked by the replacement.   At the end
of the replacement, fPersistentRef points to the new TClass object.

Conflicts:
	bindings/pyroot/src/FunctionHolder.cxx
	core/meta/inc/TClass.h
	core/meta/src/TClass.cxx

Use local thread storage to avoid having
to search through the whole list of TThread object.

Cache (using an atomic) the last used StreamerInfo for each TClass,
so that in the usual case we can find the StreamerInfo we are looking for
without taking any locks (and even avoiding serialization of the case
with many objects with small data size each).

Conflicts:
	core/meta/inc/TClass.h
	core/meta/src/TClass.cxx
	io/io/src/TBufferFile.cxx

Conflicts:
	cint/cintex/src/ROOTClassEnhancer.cxx
	core/base/inc/Rtypes.h
	core/meta/inc/TClass.h
	core/unix/src/TUnixSystem.cxx

Replace thread_local by TTHREAD_TLS.
Hide from c++03 the atomiticity of keyAbsNumber.

Conflicts:
	core/base/src/TROOT.cxx

That makes it much easier to use/make transparent with  C++11

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.

Conflicts:
	core/base/src/TPluginManager.cxx