ROOT logo
// @(#)root/base:$Id$
// Author: Fons Rademakers   29/07/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TStorage                                                             //
//                                                                      //
// Storage manager. The storage manager works best in conjunction with  //
// the custom ROOT new and delete operators defined in the file         //
// NewDelete.cxx (libNew.so). Only when using the custom allocation     //
// operators will memory usage statistics be gathered using the         //
// TStorage EnterStat(), RemoveStat(), etc. functions.                  //
// Memory checking is by default enabled (when using libNew.so) and     //
// usage statistics is gathered. Using the resource (in .rootrc):       //
// Root.MemStat one can toggle statistics gathering on or off. More     //
// specifically on can trap the allocation of a block of memory of a    //
// certain size. This can be specified using the resource:              //
// Root.MemStat.size, using the resource Root.MemStat.cnt one can       //
// specify after how many allocations of this size the trap should      //
// occur.                                                               //
// Set the compile option R__NOSTATS to de-activate all memory checking //
// and statistics gathering in the system.                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <stdlib.h>

#include "TROOT.h"
#include "TObjectTable.h"
#include "TError.h"
#include "TString.h"
#include "TVirtualMutex.h"
#include "TInterpreter.h"

#if !defined(R__NOSTATS)
#   define MEM_DEBUG
#   define MEM_STAT
#   define MEM_CHECKOBJECTPOINTERS
#endif

#if defined(MEM_STAT) && !defined(MEM_DEBUG)
#   define MEM_DEBUG
#endif

#ifdef MEM_DEBUG
#   ifdef R__B64
#      define storage_size(p) ((size_t)(((size_t*)p)[-1]))
#   else
#      define storage_size(p) ((size_t)(((int*)p)[-2]))
#   endif
#else
#   define storage_size(p) ((size_t)0)
#endif

#define PVOID (-1)

size_t        TStorage::fgMaxBlockSize;
FreeHookFun_t TStorage::fgFreeHook;
void         *TStorage::fgFreeHookData;
ReAllocFun_t  TStorage::fgReAllocHook;
ReAllocCFun_t TStorage::fgReAllocCHook;
Bool_t        TStorage::fgHasCustomNewDelete;


ClassImp(TStorage)

//------------------------------------------------------------------------------

static const char *gSpaceErr = "storage exhausted";

const size_t kObjMaxSize = 10024;

static Bool_t   gMemStatistics;
static Int_t    gAllocated[kObjMaxSize], gFreed[kObjMaxSize];
static Int_t    gAllocatedTotal, gFreedTotal;
static void   **gTraceArray = 0;
static Int_t    gTraceCapacity = 10, gTraceIndex = 0,
                gMemSize = -1, gMemIndex = -1;


//______________________________________________________________________________
void TStorage::EnterStat(size_t size, void *p)
{
   // Register a memory allocation operation. If desired one can trap an
   // allocation of a certain size in case one tries to find a memory
   // leak of that particular size. This function is only called via
   // the ROOT custom new operators.

   TStorage::SetMaxBlockSize(TMath::Max(TStorage::GetMaxBlockSize(), size));

   if (!gMemStatistics) return;

   if ((Int_t)size == gMemSize) {
      if (gTraceIndex == gMemIndex)
         Fatal("EnterStat", "trapped allocation %d", gMemIndex);

      if (!gTraceArray)
         gTraceArray = (void**) malloc(sizeof(void*)*gTraceCapacity);

      if (gTraceIndex >= gTraceCapacity) {
         gTraceCapacity = gTraceCapacity*2;
         gTraceArray = (void**) realloc(gTraceArray, sizeof(void*)*gTraceCapacity);
      }
      gTraceArray[gTraceIndex++] = p;
   }
   if (size >= kObjMaxSize)
      gAllocated[kObjMaxSize-1]++;
   else
      gAllocated[size]++;
   gAllocatedTotal += size;
}

//______________________________________________________________________________
void TStorage::RemoveStat(void *vp)
{
   // Register a memory free operation. This function is only called via
   // the custom ROOT delete operator.

   if (!gMemStatistics) return;

   size_t size = storage_size(vp);
   if ((Int_t)size == gMemSize) {
      for (int i = 0; i < gTraceIndex; i++)
         if (gTraceArray[i] == vp) {
            gTraceArray[i] = 0;
            break;
         }
   }
   if (size >= kObjMaxSize)
      gFreed[kObjMaxSize-1]++;
   else
      gFreed[size]++;
   gFreedTotal += size;
}

//______________________________________________________________________________
void *TStorage::Alloc(size_t size)
{
   // Allocate a block of memory, that later can be resized using
   // TStorage::ReAlloc().

   static const char *where = "TStorage::Alloc";

#ifndef WIN32
   void *vp = ::operator new[](size);
#else
   void *vp = ::operator new(size);
#endif
   if (vp == 0)
      Fatal(where, "%s", gSpaceErr);

   return vp;
}

//______________________________________________________________________________
void TStorage::Dealloc(void *ptr)
{
   // De-allocate block of memory, that was allocated via TStorage::Alloc().

#ifndef WIN32
   ::operator delete[](ptr);
#else
   ::operator delete(ptr);
#endif
}

//______________________________________________________________________________
void *TStorage::ReAlloc(void *ovp, size_t size)
{
   // Reallocate (i.e. resize) block of memory. Don't use if size is larger
   // than old size, use ReAlloc(void *, size_t, size_t) instead.

   ::Obsolete("ReAlloc(void*,size_t)", "v5-34-00", "v6-02-00");
   ::Info("ReAlloc(void*,size_t)", "please use ReAlloc(void*,size_t,size_t)");

   {
      // Needs to be protected by global mutex
      R__LOCKGUARD(gGlobalMutex);

      if (fgReAllocHook && fgHasCustomNewDelete && !TROOT::MemCheck())
         return (*fgReAllocHook)(ovp, size);
   }

   static const char *where = "TStorage::ReAlloc";

#ifndef WIN32
   void *vp = ::operator new[](size);
#else
   void *vp = ::operator new(size);
#endif
   if (vp == 0)
      Fatal(where, "%s", gSpaceErr);

   if (ovp == 0)
      return vp;

   memmove(vp, ovp, size);
#ifndef WIN32
   ::operator delete[](ovp);
#else
   ::operator delete(ovp);
#endif
   return vp;
}

//______________________________________________________________________________
void *TStorage::ReAlloc(void *ovp, size_t size, size_t oldsize)
{
   // Reallocate (i.e. resize) block of memory. Checks if current size is
   // equal to oldsize. If not memory was overwritten.

   // Needs to be protected by global mutex
   {
      R__LOCKGUARD(gGlobalMutex);

      if (fgReAllocCHook && fgHasCustomNewDelete && !TROOT::MemCheck())
         return (*fgReAllocCHook)(ovp, size, oldsize);
   }

   static const char *where = "TStorage::ReAlloc";

   if (oldsize == size)
      return ovp;

#ifndef WIN32
   void *vp = ::operator new[](size);
#else
   void *vp = ::operator new(size);
#endif
   if (vp == 0)
      Fatal(where, "%s", gSpaceErr);

   if (ovp == 0)
      return vp;

   if (size > oldsize) {
      memcpy(vp, ovp, oldsize);
      memset((char*)vp+oldsize, 0, size-oldsize);
   } else
      memcpy(vp, ovp, size);
#ifndef WIN32
   ::operator delete[](ovp);
#else
   ::operator delete(ovp);
#endif
   return vp;
}

//______________________________________________________________________________
char *TStorage::ReAllocChar(char *ovp, size_t size, size_t oldsize)
{
   // Reallocate (i.e. resize) array of chars. Size and oldsize are
   // in number of chars.

   static const char *where = "TStorage::ReAllocChar";

   char *vp;
   if (ovp == 0) {
      vp = new char[size];
      if (vp == 0)
         Fatal(where, "%s", gSpaceErr);
      return vp;
   }
   if (oldsize == size)
      return ovp;

   vp = new char[size];
   if (vp == 0)
      Fatal(where, "%s", gSpaceErr);
   if (size > oldsize) {
      memcpy(vp, ovp, oldsize);
      memset((char*)vp+oldsize, 0, size-oldsize);
   } else
      memcpy(vp, ovp, size);
   delete [] ovp;
   return vp;
}

//______________________________________________________________________________
Int_t *TStorage::ReAllocInt(Int_t *ovp, size_t size, size_t oldsize)
{
   // Reallocate (i.e. resize) array of integers. Size and oldsize are
   // number of integers (not number of bytes).

   static const char *where = "TStorage::ReAllocInt";

   Int_t *vp;
   if (ovp == 0) {
      vp = new Int_t[size];
      if (vp == 0)
         Fatal(where, "%s", gSpaceErr);
      return vp;
   }
   if (oldsize == size)
      return ovp;

   vp = new Int_t[size];
   if (vp == 0)
      Fatal(where, "%s", gSpaceErr);
   if (size > oldsize) {
      memcpy(vp, ovp, oldsize*sizeof(Int_t));
      memset((Int_t*)vp+oldsize, 0, (size-oldsize)*sizeof(Int_t));
   } else
      memcpy(vp, ovp, size*sizeof(Int_t));
   delete [] ovp;
   return vp;
}

//______________________________________________________________________________
void *TStorage::ObjectAlloc(size_t sz)
{
   // Used to allocate a TObject on the heap (via TObject::operator new()).
   // Directly after this routine one can call (in the TObject ctor)
   // TStorage::FilledByObjectAlloc() to find out if the just created object is on
   // the heap.

   void* space =  ::operator new(sz);
   memset(space, kObjectAllocMemValue, sz);
   return space;
}

//______________________________________________________________________________
void *TStorage::ObjectAlloc(size_t , void *vp)
{
   // Used to allocate a TObject on the heap (via TObject::operator new(size_t,void*))
   // in position vp. vp is already allocated (maybe on heap, maybe on
   // stack) so just return.

   return vp;
}

//______________________________________________________________________________
void TStorage::ObjectDealloc(void *vp)
{
   // Used to deallocate a TObject on the heap (via TObject::operator delete()).

#ifndef NOCINT
   // to handle delete with placement called via CINT
   Long_t gvp = 0;
   if (gCint) gvp = gCint->Getgvp();
   if ((Long_t)vp == gvp && gvp != (Long_t)PVOID)
      return;
#endif
   ::operator delete(vp);
}

//______________________________________________________________________________
void TStorage::ObjectDealloc(void *vp, void *ptr)
{
   // Used to deallocate a TObject on the heap (via TObject::operator delete(void*,void*)).

   if (vp && ptr) { }
}

//______________________________________________________________________________
void TStorage::SetFreeHook(FreeHookFun_t fh, void *data)
{
   // Set a free handler.

   fgFreeHook     = fh;
   fgFreeHookData = data;
}

//______________________________________________________________________________
void TStorage::SetReAllocHooks(ReAllocFun_t rh1, ReAllocCFun_t rh2)
{
   // Set a custom ReAlloc handlers. This function is typically
   // called via a static object in the ROOT libNew.so shared library.

   fgReAllocHook  = rh1;
   fgReAllocCHook = rh2;
}

//______________________________________________________________________________
void TStorage::PrintStatistics()
{
   // Print memory usage statistics.

   // Needs to be protected by global mutex
   R__LOCKGUARD(gGlobalMutex);

#if defined(MEM_DEBUG) && defined(MEM_STAT)

   if (!gMemStatistics || !HasCustomNewDelete())
      return;

   //Printf("");
   Printf("Heap statistics");
   Printf("%12s%12s%12s%12s", "size", "alloc", "free", "diff");
   Printf("================================================");

   int i;
   for (i = 0; i < (int)kObjMaxSize; i++)
      if (gAllocated[i] != gFreed[i])
      //if (gAllocated[i])
         Printf("%12d%12d%12d%12d", i, gAllocated[i], gFreed[i],
                gAllocated[i]-gFreed[i]);

   if (gAllocatedTotal != gFreedTotal) {
      Printf("------------------------------------------------");
      Printf("Total:      %12d%12d%12d", gAllocatedTotal, gFreedTotal,
              gAllocatedTotal-gFreedTotal);
   }

   if (gMemSize != -1) {
      Printf("------------------------------------------------");
      for (i= 0; i < gTraceIndex; i++)
         if (gTraceArray[i])
            Printf("block %d of size %d not freed", i, gMemSize);
   }
   Printf("================================================");
   Printf(" ");
#endif
}

//______________________________________________________________________________
void TStorage::EnableStatistics(int size, int ix)
{
   // Enable memory usage statistics gathering. Size is the size of the memory
   // block that should be trapped and ix is after how many such allocations
   // the trap should happen.

#ifdef MEM_STAT
   gMemSize       = size;
   gMemIndex      = ix;
   gMemStatistics = kTRUE;
#else
   int idum = size; int iidum = ix;
#endif
}

//______________________________________________________________________________
ULong_t TStorage::GetHeapBegin()
{
   ::Obsolete("GetHeapBegin()", "v5-34-00", "v6-02-00");
   //return begin of heap
   return 0;
}

//______________________________________________________________________________
ULong_t TStorage::GetHeapEnd()
{
   ::Obsolete("GetHeapBegin()", "v5-34-00", "v6-02-00");
   //return end of heap
   return 0;
}

//______________________________________________________________________________
void *TStorage::GetFreeHookData()
{
   //return static free hook data
   return fgFreeHookData;
}

//______________________________________________________________________________
Bool_t TStorage::HasCustomNewDelete()
{
   //return the has custom delete flag
   return fgHasCustomNewDelete;
}

//______________________________________________________________________________
void TStorage::SetCustomNewDelete()
{
   //set the has custom delete flag
   fgHasCustomNewDelete = kTRUE;
}


//______________________________________________________________________________
void TStorage::AddToHeap(ULong_t, ULong_t)
{
   //add a range to the heap
   ::Obsolete("AddToHeap(ULong_t,ULong_t)", "v5-34-00", "v6-02-00");
}

//______________________________________________________________________________
Bool_t TStorage::IsOnHeap(void *)
{
   //is object at p in the heap?
   ::Obsolete("IsOnHeap(void*)", "v5-34-00", "v6-02-00");
   return false;
}

#ifdef WIN32
//______________________________________________________________________________
Bool_t TStorage::FilledByObjectAlloc(UInt_t *member)
{
   //called by TObject's constructor to determine if object was created by call to new
   return *member == kObjectAllocMemValue;
}

//______________________________________________________________________________
size_t TStorage::GetMaxBlockSize()
{
   //return max block size
   return fgMaxBlockSize;
}

//______________________________________________________________________________
void TStorage::SetMaxBlockSize(size_t size)
{
   //set max block size
   fgMaxBlockSize = size;
}

//______________________________________________________________________________
FreeHookFun_t TStorage::GetFreeHook()
{
   //return free hook
   return fgFreeHook;
}

#endif
 TStorage.cxx:1
 TStorage.cxx:2
 TStorage.cxx:3
 TStorage.cxx:4
 TStorage.cxx:5
 TStorage.cxx:6
 TStorage.cxx:7
 TStorage.cxx:8
 TStorage.cxx:9
 TStorage.cxx:10
 TStorage.cxx:11
 TStorage.cxx:12
 TStorage.cxx:13
 TStorage.cxx:14
 TStorage.cxx:15
 TStorage.cxx:16
 TStorage.cxx:17
 TStorage.cxx:18
 TStorage.cxx:19
 TStorage.cxx:20
 TStorage.cxx:21
 TStorage.cxx:22
 TStorage.cxx:23
 TStorage.cxx:24
 TStorage.cxx:25
 TStorage.cxx:26
 TStorage.cxx:27
 TStorage.cxx:28
 TStorage.cxx:29
 TStorage.cxx:30
 TStorage.cxx:31
 TStorage.cxx:32
 TStorage.cxx:33
 TStorage.cxx:34
 TStorage.cxx:35
 TStorage.cxx:36
 TStorage.cxx:37
 TStorage.cxx:38
 TStorage.cxx:39
 TStorage.cxx:40
 TStorage.cxx:41
 TStorage.cxx:42
 TStorage.cxx:43
 TStorage.cxx:44
 TStorage.cxx:45
 TStorage.cxx:46
 TStorage.cxx:47
 TStorage.cxx:48
 TStorage.cxx:49
 TStorage.cxx:50
 TStorage.cxx:51
 TStorage.cxx:52
 TStorage.cxx:53
 TStorage.cxx:54
 TStorage.cxx:55
 TStorage.cxx:56
 TStorage.cxx:57
 TStorage.cxx:58
 TStorage.cxx:59
 TStorage.cxx:60
 TStorage.cxx:61
 TStorage.cxx:62
 TStorage.cxx:63
 TStorage.cxx:64
 TStorage.cxx:65
 TStorage.cxx:66
 TStorage.cxx:67
 TStorage.cxx:68
 TStorage.cxx:69
 TStorage.cxx:70
 TStorage.cxx:71
 TStorage.cxx:72
 TStorage.cxx:73
 TStorage.cxx:74
 TStorage.cxx:75
 TStorage.cxx:76
 TStorage.cxx:77
 TStorage.cxx:78
 TStorage.cxx:79
 TStorage.cxx:80
 TStorage.cxx:81
 TStorage.cxx:82
 TStorage.cxx:83
 TStorage.cxx:84
 TStorage.cxx:85
 TStorage.cxx:86
 TStorage.cxx:87
 TStorage.cxx:88
 TStorage.cxx:89
 TStorage.cxx:90
 TStorage.cxx:91
 TStorage.cxx:92
 TStorage.cxx:93
 TStorage.cxx:94
 TStorage.cxx:95
 TStorage.cxx:96
 TStorage.cxx:97
 TStorage.cxx:98
 TStorage.cxx:99
 TStorage.cxx:100
 TStorage.cxx:101
 TStorage.cxx:102
 TStorage.cxx:103
 TStorage.cxx:104
 TStorage.cxx:105
 TStorage.cxx:106
 TStorage.cxx:107
 TStorage.cxx:108
 TStorage.cxx:109
 TStorage.cxx:110
 TStorage.cxx:111
 TStorage.cxx:112
 TStorage.cxx:113
 TStorage.cxx:114
 TStorage.cxx:115
 TStorage.cxx:116
 TStorage.cxx:117
 TStorage.cxx:118
 TStorage.cxx:119
 TStorage.cxx:120
 TStorage.cxx:121
 TStorage.cxx:122
 TStorage.cxx:123
 TStorage.cxx:124
 TStorage.cxx:125
 TStorage.cxx:126
 TStorage.cxx:127
 TStorage.cxx:128
 TStorage.cxx:129
 TStorage.cxx:130
 TStorage.cxx:131
 TStorage.cxx:132
 TStorage.cxx:133
 TStorage.cxx:134
 TStorage.cxx:135
 TStorage.cxx:136
 TStorage.cxx:137
 TStorage.cxx:138
 TStorage.cxx:139
 TStorage.cxx:140
 TStorage.cxx:141
 TStorage.cxx:142
 TStorage.cxx:143
 TStorage.cxx:144
 TStorage.cxx:145
 TStorage.cxx:146
 TStorage.cxx:147
 TStorage.cxx:148
 TStorage.cxx:149
 TStorage.cxx:150
 TStorage.cxx:151
 TStorage.cxx:152
 TStorage.cxx:153
 TStorage.cxx:154
 TStorage.cxx:155
 TStorage.cxx:156
 TStorage.cxx:157
 TStorage.cxx:158
 TStorage.cxx:159
 TStorage.cxx:160
 TStorage.cxx:161
 TStorage.cxx:162
 TStorage.cxx:163
 TStorage.cxx:164
 TStorage.cxx:165
 TStorage.cxx:166
 TStorage.cxx:167
 TStorage.cxx:168
 TStorage.cxx:169
 TStorage.cxx:170
 TStorage.cxx:171
 TStorage.cxx:172
 TStorage.cxx:173
 TStorage.cxx:174
 TStorage.cxx:175
 TStorage.cxx:176
 TStorage.cxx:177
 TStorage.cxx:178
 TStorage.cxx:179
 TStorage.cxx:180
 TStorage.cxx:181
 TStorage.cxx:182
 TStorage.cxx:183
 TStorage.cxx:184
 TStorage.cxx:185
 TStorage.cxx:186
 TStorage.cxx:187
 TStorage.cxx:188
 TStorage.cxx:189
 TStorage.cxx:190
 TStorage.cxx:191
 TStorage.cxx:192
 TStorage.cxx:193
 TStorage.cxx:194
 TStorage.cxx:195
 TStorage.cxx:196
 TStorage.cxx:197
 TStorage.cxx:198
 TStorage.cxx:199
 TStorage.cxx:200
 TStorage.cxx:201
 TStorage.cxx:202
 TStorage.cxx:203
 TStorage.cxx:204
 TStorage.cxx:205
 TStorage.cxx:206
 TStorage.cxx:207
 TStorage.cxx:208
 TStorage.cxx:209
 TStorage.cxx:210
 TStorage.cxx:211
 TStorage.cxx:212
 TStorage.cxx:213
 TStorage.cxx:214
 TStorage.cxx:215
 TStorage.cxx:216
 TStorage.cxx:217
 TStorage.cxx:218
 TStorage.cxx:219
 TStorage.cxx:220
 TStorage.cxx:221
 TStorage.cxx:222
 TStorage.cxx:223
 TStorage.cxx:224
 TStorage.cxx:225
 TStorage.cxx:226
 TStorage.cxx:227
 TStorage.cxx:228
 TStorage.cxx:229
 TStorage.cxx:230
 TStorage.cxx:231
 TStorage.cxx:232
 TStorage.cxx:233
 TStorage.cxx:234
 TStorage.cxx:235
 TStorage.cxx:236
 TStorage.cxx:237
 TStorage.cxx:238
 TStorage.cxx:239
 TStorage.cxx:240
 TStorage.cxx:241
 TStorage.cxx:242
 TStorage.cxx:243
 TStorage.cxx:244
 TStorage.cxx:245
 TStorage.cxx:246
 TStorage.cxx:247
 TStorage.cxx:248
 TStorage.cxx:249
 TStorage.cxx:250
 TStorage.cxx:251
 TStorage.cxx:252
 TStorage.cxx:253
 TStorage.cxx:254
 TStorage.cxx:255
 TStorage.cxx:256
 TStorage.cxx:257
 TStorage.cxx:258
 TStorage.cxx:259
 TStorage.cxx:260
 TStorage.cxx:261
 TStorage.cxx:262
 TStorage.cxx:263
 TStorage.cxx:264
 TStorage.cxx:265
 TStorage.cxx:266
 TStorage.cxx:267
 TStorage.cxx:268
 TStorage.cxx:269
 TStorage.cxx:270
 TStorage.cxx:271
 TStorage.cxx:272
 TStorage.cxx:273
 TStorage.cxx:274
 TStorage.cxx:275
 TStorage.cxx:276
 TStorage.cxx:277
 TStorage.cxx:278
 TStorage.cxx:279
 TStorage.cxx:280
 TStorage.cxx:281
 TStorage.cxx:282
 TStorage.cxx:283
 TStorage.cxx:284
 TStorage.cxx:285
 TStorage.cxx:286
 TStorage.cxx:287
 TStorage.cxx:288
 TStorage.cxx:289
 TStorage.cxx:290
 TStorage.cxx:291
 TStorage.cxx:292
 TStorage.cxx:293
 TStorage.cxx:294
 TStorage.cxx:295
 TStorage.cxx:296
 TStorage.cxx:297
 TStorage.cxx:298
 TStorage.cxx:299
 TStorage.cxx:300
 TStorage.cxx:301
 TStorage.cxx:302
 TStorage.cxx:303
 TStorage.cxx:304
 TStorage.cxx:305
 TStorage.cxx:306
 TStorage.cxx:307
 TStorage.cxx:308
 TStorage.cxx:309
 TStorage.cxx:310
 TStorage.cxx:311
 TStorage.cxx:312
 TStorage.cxx:313
 TStorage.cxx:314
 TStorage.cxx:315
 TStorage.cxx:316
 TStorage.cxx:317
 TStorage.cxx:318
 TStorage.cxx:319
 TStorage.cxx:320
 TStorage.cxx:321
 TStorage.cxx:322
 TStorage.cxx:323
 TStorage.cxx:324
 TStorage.cxx:325
 TStorage.cxx:326
 TStorage.cxx:327
 TStorage.cxx:328
 TStorage.cxx:329
 TStorage.cxx:330
 TStorage.cxx:331
 TStorage.cxx:332
 TStorage.cxx:333
 TStorage.cxx:334
 TStorage.cxx:335
 TStorage.cxx:336
 TStorage.cxx:337
 TStorage.cxx:338
 TStorage.cxx:339
 TStorage.cxx:340
 TStorage.cxx:341
 TStorage.cxx:342
 TStorage.cxx:343
 TStorage.cxx:344
 TStorage.cxx:345
 TStorage.cxx:346
 TStorage.cxx:347
 TStorage.cxx:348
 TStorage.cxx:349
 TStorage.cxx:350
 TStorage.cxx:351
 TStorage.cxx:352
 TStorage.cxx:353
 TStorage.cxx:354
 TStorage.cxx:355
 TStorage.cxx:356
 TStorage.cxx:357
 TStorage.cxx:358
 TStorage.cxx:359
 TStorage.cxx:360
 TStorage.cxx:361
 TStorage.cxx:362
 TStorage.cxx:363
 TStorage.cxx:364
 TStorage.cxx:365
 TStorage.cxx:366
 TStorage.cxx:367
 TStorage.cxx:368
 TStorage.cxx:369
 TStorage.cxx:370
 TStorage.cxx:371
 TStorage.cxx:372
 TStorage.cxx:373
 TStorage.cxx:374
 TStorage.cxx:375
 TStorage.cxx:376
 TStorage.cxx:377
 TStorage.cxx:378
 TStorage.cxx:379
 TStorage.cxx:380
 TStorage.cxx:381
 TStorage.cxx:382
 TStorage.cxx:383
 TStorage.cxx:384
 TStorage.cxx:385
 TStorage.cxx:386
 TStorage.cxx:387
 TStorage.cxx:388
 TStorage.cxx:389
 TStorage.cxx:390
 TStorage.cxx:391
 TStorage.cxx:392
 TStorage.cxx:393
 TStorage.cxx:394
 TStorage.cxx:395
 TStorage.cxx:396
 TStorage.cxx:397
 TStorage.cxx:398
 TStorage.cxx:399
 TStorage.cxx:400
 TStorage.cxx:401
 TStorage.cxx:402
 TStorage.cxx:403
 TStorage.cxx:404
 TStorage.cxx:405
 TStorage.cxx:406
 TStorage.cxx:407
 TStorage.cxx:408
 TStorage.cxx:409
 TStorage.cxx:410
 TStorage.cxx:411
 TStorage.cxx:412
 TStorage.cxx:413
 TStorage.cxx:414
 TStorage.cxx:415
 TStorage.cxx:416
 TStorage.cxx:417
 TStorage.cxx:418
 TStorage.cxx:419
 TStorage.cxx:420
 TStorage.cxx:421
 TStorage.cxx:422
 TStorage.cxx:423
 TStorage.cxx:424
 TStorage.cxx:425
 TStorage.cxx:426
 TStorage.cxx:427
 TStorage.cxx:428
 TStorage.cxx:429
 TStorage.cxx:430
 TStorage.cxx:431
 TStorage.cxx:432
 TStorage.cxx:433
 TStorage.cxx:434
 TStorage.cxx:435
 TStorage.cxx:436
 TStorage.cxx:437
 TStorage.cxx:438
 TStorage.cxx:439
 TStorage.cxx:440
 TStorage.cxx:441
 TStorage.cxx:442
 TStorage.cxx:443
 TStorage.cxx:444
 TStorage.cxx:445
 TStorage.cxx:446
 TStorage.cxx:447
 TStorage.cxx:448
 TStorage.cxx:449
 TStorage.cxx:450
 TStorage.cxx:451
 TStorage.cxx:452
 TStorage.cxx:453
 TStorage.cxx:454
 TStorage.cxx:455
 TStorage.cxx:456
 TStorage.cxx:457
 TStorage.cxx:458
 TStorage.cxx:459
 TStorage.cxx:460
 TStorage.cxx:461
 TStorage.cxx:462
 TStorage.cxx:463
 TStorage.cxx:464
 TStorage.cxx:465
 TStorage.cxx:466
 TStorage.cxx:467
 TStorage.cxx:468
 TStorage.cxx:469
 TStorage.cxx:470
 TStorage.cxx:471
 TStorage.cxx:472
 TStorage.cxx:473
 TStorage.cxx:474
 TStorage.cxx:475
 TStorage.cxx:476
 TStorage.cxx:477
 TStorage.cxx:478
 TStorage.cxx:479
 TStorage.cxx:480
 TStorage.cxx:481
 TStorage.cxx:482
 TStorage.cxx:483
 TStorage.cxx:484
 TStorage.cxx:485
 TStorage.cxx:486
 TStorage.cxx:487
 TStorage.cxx:488
 TStorage.cxx:489
 TStorage.cxx:490
 TStorage.cxx:491
 TStorage.cxx:492
 TStorage.cxx:493
 TStorage.cxx:494
 TStorage.cxx:495
 TStorage.cxx:496
 TStorage.cxx:497
 TStorage.cxx:498
 TStorage.cxx:499
 TStorage.cxx:500
 TStorage.cxx:501
 TStorage.cxx:502
 TStorage.cxx:503
 TStorage.cxx:504
 TStorage.cxx:505
 TStorage.cxx:506
 TStorage.cxx:507
 TStorage.cxx:508
 TStorage.cxx:509
 TStorage.cxx:510
 TStorage.cxx:511
 TStorage.cxx:512
 TStorage.cxx:513
 TStorage.cxx:514
 TStorage.cxx:515
 TStorage.cxx:516
 TStorage.cxx:517
 TStorage.cxx:518
 TStorage.cxx:519
 TStorage.cxx:520
 TStorage.cxx:521
 TStorage.cxx:522