xpcom/base/nsTraceRefcntImpl.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Communicator client code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   L. David Baron <dbaron@dbaron.org>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsTraceRefcntImpl.h"
  40 #include "nscore.h"
  41 #include "nsISupports.h"
  42 #include "nsVoidArray.h"
  43 #include "prprf.h"
  44 #include "prlog.h"
  45 #include "plstr.h"
  46 #include "prlink.h"
  47 #include <stdlib.h>
  48 #include "nsCOMPtr.h"
  49 #include "nsCRT.h"
  50 #include <math.h>
  51 #include "nsStackWalk.h"
  52
  53 #ifdef HAVE_LIBDL
  54 #include <dlfcn.h>
  55 #endif
  56
  57 ////////////////////////////////////////////////////////////////////////////////
  58
  59 NS_COM void
  60 NS_MeanAndStdDev(double n, double sumOfValues, double sumOfSquaredValues,
  61                  double *meanResult, double *stdDevResult)
  62 {
  63   double mean = 0.0, var = 0.0, stdDev = 0.0;
  64   if (n > 0.0 && sumOfValues >= 0) {
  65     mean = sumOfValues / n;
  66     double temp = (n * sumOfSquaredValues) - (sumOfValues * sumOfValues);
  67     if (temp < 0.0 || n <= 1)
  68       var = 0.0;
  69     else
  70       var = temp / (n * (n - 1));
  71     // for some reason, Windows says sqrt(0.0) is "-1.#J" (?!) so do this:
  72     stdDev = var != 0.0 ? sqrt(var) : 0.0;
  73   }
  74   *meanResult = mean;
  75   *stdDevResult = stdDev;
  76 }
  77
  78 ////////////////////////////////////////////////////////////////////////////////
  79
  80 #define NS_IMPL_REFCNT_LOGGING
  81
  82 #ifdef NS_IMPL_REFCNT_LOGGING
  83 #include "plhash.h"
  84 #include "prmem.h"
  85
  86 #include "prlock.h"
  87
  88 static PRLock* gTraceLock;
  89
  90 #define LOCK_TRACELOG()   PR_Lock(gTraceLock)
  91 #define UNLOCK_TRACELOG() PR_Unlock(gTraceLock)
  92
  93 static PLHashTable* gBloatView;
  94 static PLHashTable* gTypesToLog;
  95 static PLHashTable* gObjectsToLog;
  96 static PLHashTable* gSerialNumbers;
  97 static PRInt32 gNextSerialNumber;
  98
  99 static PRBool gLogging;
 100 static PRBool gLogToLeaky;
 101 static PRBool gLogLeaksOnly;
 102
 103 static void (*leakyLogAddRef)(void* p, int oldrc, int newrc);
 104 static void (*leakyLogRelease)(void* p, int oldrc, int newrc);
 105
 106 #define BAD_TLS_INDEX ((PRUintn) -1)
 107
 108 // if gActivityTLS == BAD_TLS_INDEX, then we're
 109 // unitialized... otherwise this points to a NSPR TLS thread index
 110 // indicating whether addref activity is legal. If the PTR_TO_INT32 is 0 then
 111 // activity is ok, otherwise not!
 112 static PRUintn gActivityTLS = BAD_TLS_INDEX;
 113
 114 static PRBool gInitialized;
 115 static nsrefcnt gInitCount;
 116
 117 static FILE *gBloatLog = nsnull;
 118 static FILE *gRefcntsLog = nsnull;
 119 static FILE *gAllocLog = nsnull;
 120 static FILE *gLeakyLog = nsnull;
 121 static FILE *gCOMPtrLog = nsnull;
 122
 123 struct serialNumberRecord {
 124   PRInt32 serialNumber;
 125   PRInt32 refCount;
 126   PRInt32 COMPtrCount;
 127 };
 128
 129 struct nsTraceRefcntStats {
 130   nsrefcnt mAddRefs;
 131   nsrefcnt mReleases;
 132   nsrefcnt mCreates;
 133   nsrefcnt mDestroys;
 134   double mRefsOutstandingTotal;
 135   double mRefsOutstandingSquared;
 136   double mObjsOutstandingTotal;
 137   double mObjsOutstandingSquared;
 138 };
 139
 140   // I hope to turn this on for everybody once we hit it a little less.
 141 #define ASSERT_ACTIVITY_IS_LEGAL                                             \
 142   NS_WARN_IF_FALSE(gActivityTLS != BAD_TLS_INDEX &&                          \
 143              NS_PTR_TO_INT32(PR_GetThreadPrivate(gActivityTLS)) == 0,        \
 144              "XPCOM objects created/destroyed from static ctor/dtor");
 145
 146 // These functions are copied from nsprpub/lib/ds/plhash.c, with changes
 147 // to the functions not called Default* to free the serialNumberRecord or
 148 // the BloatEntry.
 149
 150 static void * PR_CALLBACK
 151 DefaultAllocTable(void *pool, PRSize size)
 152 {
 153     return PR_MALLOC(size);
 154 }
 155
 156 static void PR_CALLBACK
 157 DefaultFreeTable(void *pool, void *item)
 158 {
 159     PR_Free(item);
 160 }
 161
 162 static PLHashEntry * PR_CALLBACK
 163 DefaultAllocEntry(void *pool, const void *key)
 164 {
 165     return PR_NEW(PLHashEntry);
 166 }
 167
 168 static void PR_CALLBACK
 169 SerialNumberFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
 170 {
 171     if (flag == HT_FREE_ENTRY) {
 172         PR_Free(reinterpret_cast<serialNumberRecord*>(he->value));
 173         PR_Free(he);
 174     }
 175 }
 176
 177 static void PR_CALLBACK
 178 TypesToLogFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
 179 {
 180     if (flag == HT_FREE_ENTRY) {
 181         nsCRT::free(const_cast<char*>
 182                               (reinterpret_cast<const char*>(he->key)));
 183         PR_Free(he);
 184     }
 185 }
 186
 187 static const PLHashAllocOps serialNumberHashAllocOps = {
 188     DefaultAllocTable, DefaultFreeTable,
 189     DefaultAllocEntry, SerialNumberFreeEntry
 190 };
 191
 192 static const PLHashAllocOps typesToLogHashAllocOps = {
 193     DefaultAllocTable, DefaultFreeTable,
 194     DefaultAllocEntry, TypesToLogFreeEntry
 195 };
 196
 197 ////////////////////////////////////////////////////////////////////////////////
 198
 199 class BloatEntry {
 200 public:
 201   BloatEntry(const char* className, PRUint32 classSize)
 202     : mClassSize(classSize) {
 203     mClassName = PL_strdup(className);
 204     Clear(&mNewStats);
 205     Clear(&mAllStats);
 206     mTotalLeaked = 0;
 207   }
 208
 209   ~BloatEntry() {
 210     PL_strfree(mClassName);
 211   }
 212
 213   PRUint32 GetClassSize() { return (PRUint32)mClassSize; }
 214   const char* GetClassName() { return mClassName; }
 215
 216   static void Clear(nsTraceRefcntStats* stats) {
 217     stats->mAddRefs = 0;
 218     stats->mReleases = 0;
 219     stats->mCreates = 0;
 220     stats->mDestroys = 0;
 221     stats->mRefsOutstandingTotal = 0;
 222     stats->mRefsOutstandingSquared = 0;
 223     stats->mObjsOutstandingTotal = 0;
 224     stats->mObjsOutstandingSquared = 0;
 225   }
 226
 227   void Accumulate() {
 228       mAllStats.mAddRefs += mNewStats.mAddRefs;
 229       mAllStats.mReleases += mNewStats.mReleases;
 230       mAllStats.mCreates += mNewStats.mCreates;
 231       mAllStats.mDestroys += mNewStats.mDestroys;
 232       mAllStats.mRefsOutstandingTotal += mNewStats.mRefsOutstandingTotal;
 233       mAllStats.mRefsOutstandingSquared += mNewStats.mRefsOutstandingSquared;
 234       mAllStats.mObjsOutstandingTotal += mNewStats.mObjsOutstandingTotal;
 235       mAllStats.mObjsOutstandingSquared += mNewStats.mObjsOutstandingSquared;
 236       Clear(&mNewStats);
 237   }
 238
 239   void AddRef(nsrefcnt refcnt) {
 240     mNewStats.mAddRefs++;
 241     if (refcnt == 1) {
 242       Ctor();
 243     }
 244     AccountRefs();
 245   }
 246
 247   void Release(nsrefcnt refcnt) {
 248     mNewStats.mReleases++;
 249     if (refcnt == 0) {
 250       Dtor();
 251     }
 252     AccountRefs();
 253   }
 254
 255   void Ctor() {
 256     mNewStats.mCreates++;
 257     AccountObjs();
 258   }
 259
 260   void Dtor() {
 261     mNewStats.mDestroys++;
 262     AccountObjs();
 263   }
 264
 265   void AccountRefs() {
 266     PRInt32 cnt = (mNewStats.mAddRefs - mNewStats.mReleases);
 267     mNewStats.mRefsOutstandingTotal += cnt;
 268     mNewStats.mRefsOutstandingSquared += cnt * cnt;
 269   }
 270
 271   void AccountObjs() {
 272     PRInt32 cnt = (mNewStats.mCreates - mNewStats.mDestroys);
 273     mNewStats.mObjsOutstandingTotal += cnt;
 274     mNewStats.mObjsOutstandingSquared += cnt * cnt;
 275   }
 276
 277   static PRIntn PR_CALLBACK DumpEntry(PLHashEntry *he, PRIntn i, void *arg) {
 278     BloatEntry* entry = (BloatEntry*)he->value;
 279     if (entry) {
 280       entry->Accumulate();
 281       static_cast<nsVoidArray*>(arg)->AppendElement(entry);
 282     }
 283     return HT_ENUMERATE_NEXT;
 284   }
 285
 286   static PRIntn PR_CALLBACK TotalEntries(PLHashEntry *he, PRIntn i, void *arg) {
 287     BloatEntry* entry = (BloatEntry*)he->value;
 288     if (entry && nsCRT::strcmp(entry->mClassName, "TOTAL") != 0) {
 289       entry->Total((BloatEntry*)arg);
 290     }
 291     return HT_ENUMERATE_NEXT;
 292   }
 293
 294   void Total(BloatEntry* total) {
 295     total->mAllStats.mAddRefs += mNewStats.mAddRefs + mAllStats.mAddRefs;
 296     total->mAllStats.mReleases += mNewStats.mReleases + mAllStats.mReleases;
 297     total->mAllStats.mCreates += mNewStats.mCreates + mAllStats.mCreates;
 298     total->mAllStats.mDestroys += mNewStats.mDestroys + mAllStats.mDestroys;
 299     total->mAllStats.mRefsOutstandingTotal += mNewStats.mRefsOutstandingTotal + mAllStats.mRefsOutstandingTotal;
 300     total->mAllStats.mRefsOutstandingSquared += mNewStats.mRefsOutstandingSquared + mAllStats.mRefsOutstandingSquared;
 301     total->mAllStats.mObjsOutstandingTotal += mNewStats.mObjsOutstandingTotal + mAllStats.mObjsOutstandingTotal;
 302     total->mAllStats.mObjsOutstandingSquared += mNewStats.mObjsOutstandingSquared + mAllStats.mObjsOutstandingSquared;
 303     PRInt32 count = (mNewStats.mCreates + mAllStats.mCreates);
 304     total->mClassSize += mClassSize * count;    // adjust for average in DumpTotal
 305     total->mTotalLeaked += (PRInt32)(mClassSize *
 306                                      ((mNewStats.mCreates + mAllStats.mCreates)
 307                                       -(mNewStats.mDestroys + mAllStats.mDestroys)));
 308   }
 309
 310   nsresult DumpTotal(PRUint32 nClasses, FILE* out) {
 311     mClassSize /= mAllStats.mCreates;
 312     return Dump(-1, out, nsTraceRefcntImpl::ALL_STATS);
 313   }
 314
 315   static PRBool HaveLeaks(nsTraceRefcntStats* stats) {
 316     return ((stats->mAddRefs != stats->mReleases) ||
 317             (stats->mCreates != stats->mDestroys));
 318   }
 319
 320   static nsresult PrintDumpHeader(FILE* out, const char* msg) {
 321     fprintf(out, "\n== BloatView: %s\n\n", msg);
 322     fprintf(out,
 323         "     |<----------------Class--------------->|<-----Bytes------>|<----------------Objects---------------->|<--------------References-------------->|\n");
 324     fprintf(out,
 325         "                                              Per-Inst   Leaked    Total      Rem      Mean       StdDev     Total      Rem      Mean       StdDev\n");
 326     return NS_OK;
 327   }
 328
 329   nsresult Dump(PRIntn i, FILE* out, nsTraceRefcntImpl::StatisticsType type) {
 330     nsTraceRefcntStats* stats = (type == nsTraceRefcntImpl::NEW_STATS) ? &mNewStats : &mAllStats;
 331     if (gLogLeaksOnly && !HaveLeaks(stats)) {
 332       return NS_OK;
 333     }
 334
 335     double meanRefs, stddevRefs;
 336     NS_MeanAndStdDev(stats->mAddRefs + stats->mReleases,
 337                      stats->mRefsOutstandingTotal,
 338                      stats->mRefsOutstandingSquared,
 339                      &meanRefs, &stddevRefs);
 340
 341     double meanObjs, stddevObjs;
 342     NS_MeanAndStdDev(stats->mCreates + stats->mDestroys,
 343                      stats->mObjsOutstandingTotal,
 344                      stats->mObjsOutstandingSquared,
 345                      &meanObjs, &stddevObjs);
 346
 347     if ((stats->mAddRefs - stats->mReleases) != 0 ||
 348         stats->mAddRefs != 0 ||
 349         meanRefs != 0 ||
 350         stddevRefs != 0 ||
 351         (stats->mCreates - stats->mDestroys) != 0 ||
 352         stats->mCreates != 0 ||
 353         meanObjs != 0 ||
 354         stddevObjs != 0) {
 355       fprintf(out, "%4d %-40.40s %8d %8d %8d %8d (%8.2f +/- %8.2f) %8d %8d (%8.2f +/- %8.2f)\n",
 356               i+1, mClassName,
 357               (PRInt32)mClassSize,
 358               (nsCRT::strcmp(mClassName, "TOTAL"))
 359                   ?(PRInt32)((stats->mCreates - stats->mDestroys) * mClassSize)
 360                   :mTotalLeaked,
 361               stats->mCreates,
 362               (stats->mCreates - stats->mDestroys),
 363               meanObjs,
 364               stddevObjs,
 365               stats->mAddRefs,
 366               (stats->mAddRefs - stats->mReleases),
 367               meanRefs,
 368               stddevRefs);
 369     }
 370     return NS_OK;
 371   }
 372
 373 protected:
 374   char*         mClassName;
 375   double        mClassSize;     // this is stored as a double because of the way we compute the avg class size for total bloat
 376   PRInt32       mTotalLeaked; // used only for TOTAL entry
 377   nsTraceRefcntStats mNewStats;
 378   nsTraceRefcntStats mAllStats;
 379 };
 380
 381 static void PR_CALLBACK
 382 BloatViewFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
 383 {
 384     if (flag == HT_FREE_ENTRY) {
 385         BloatEntry* entry = reinterpret_cast<BloatEntry*>(he->value);
 386         delete entry;
 387         PR_Free(he);
 388     }
 389 }
 390
 391 const static PLHashAllocOps bloatViewHashAllocOps = {
 392     DefaultAllocTable, DefaultFreeTable,
 393     DefaultAllocEntry, BloatViewFreeEntry
 394 };
 395
 396 static void
 397 RecreateBloatView()
 398 {
 399   gBloatView = PL_NewHashTable(256,
 400                                PL_HashString,
 401                                PL_CompareStrings,
 402                                PL_CompareValues,
 403                                &bloatViewHashAllocOps, NULL);
 404 }
 405
 406 static BloatEntry*
 407 GetBloatEntry(const char* aTypeName, PRUint32 aInstanceSize)
 408 {
 409   if (!gBloatView) {
 410     RecreateBloatView();
 411   }
 412   BloatEntry* entry = NULL;
 413   if (gBloatView) {
 414     entry = (BloatEntry*)PL_HashTableLookup(gBloatView, aTypeName);
 415     if (entry == NULL && aInstanceSize > 0) {
 416
 417       entry = new BloatEntry(aTypeName, aInstanceSize);
 418       PLHashEntry* e = PL_HashTableAdd(gBloatView, aTypeName, entry);
 419       if (e == NULL) {
 420         delete entry;
 421         entry = NULL;
 422       }
 423     } else {
 424       NS_ASSERTION(aInstanceSize == 0 ||
 425                    entry->GetClassSize() == aInstanceSize,
 426                    "bad size recorded");
 427     }
 428   }
 429   return entry;
 430 }
 431
 432 static PRIntn PR_CALLBACK DumpSerialNumbers(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure)
 433 {
 434   serialNumberRecord* record = reinterpret_cast<serialNumberRecord *>(aHashEntry->value);
 435 #ifdef HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR
 436   fprintf((FILE*) aClosure, "%d @%p (%d references; %d from COMPtrs)\n",
 437                             record->serialNumber,
 438                             NS_INT32_TO_PTR(aHashEntry->key),
 439                             record->refCount,
 440                             record->COMPtrCount);
 441 #else
 442   fprintf((FILE*) aClosure, "%d @%p (%d references)\n",
 443                             record->serialNumber,
 444                             NS_INT32_TO_PTR(aHashEntry->key),
 445                             record->refCount);
 446 #endif
 447   return HT_ENUMERATE_NEXT;
 448 }
 449
 450
 451 #endif /* NS_IMPL_REFCNT_LOGGING */
 452
 453 NS_COM nsresult
 454 nsTraceRefcntImpl::DumpStatistics(StatisticsType type, FILE* out)
 455 {
 456   nsresult rv = NS_OK;
 457 #ifdef NS_IMPL_REFCNT_LOGGING
 458   if (gBloatLog == nsnull || gBloatView == nsnull) {
 459     return NS_ERROR_FAILURE;
 460   }
 461   if (out == nsnull) {
 462     out = gBloatLog;
 463   }
 464
 465   LOCK_TRACELOG();
 466
 467   PRBool wasLogging = gLogging;
 468   gLogging = PR_FALSE;  // turn off logging for this method
 469
 470   const char* msg;
 471   if (type == NEW_STATS) {
 472     if (gLogLeaksOnly)
 473       msg = "NEW (incremental) LEAK STATISTICS";
 474     else
 475       msg = "NEW (incremental) LEAK AND BLOAT STATISTICS";
 476   }
 477   else {
 478     if (gLogLeaksOnly)
 479       msg = "ALL (cumulative) LEAK STATISTICS";
 480     else
 481       msg = "ALL (cumulative) LEAK AND BLOAT STATISTICS";
 482   }
 483   rv = BloatEntry::PrintDumpHeader(out, msg);
 484   if (NS_FAILED(rv)) goto done;
 485
 486   {
 487     BloatEntry total("TOTAL", 0);
 488     PL_HashTableEnumerateEntries(gBloatView, BloatEntry::TotalEntries, &total);
 489     total.DumpTotal(gBloatView->nentries, out);
 490
 491     nsVoidArray entries;
 492     PL_HashTableEnumerateEntries(gBloatView, BloatEntry::DumpEntry, &entries);
 493
 494     fprintf(stdout, "nsTraceRefcntImpl::DumpStatistics: %d entries\n",
 495            entries.Count());
 496
 497     // Sort the entries alphabetically by classname.
 498     PRInt32 i, j;
 499     for (i = entries.Count() - 1; i >= 1; --i) {
 500       for (j = i - 1; j >= 0; --j) {
 501         BloatEntry* left  = static_cast<BloatEntry*>(entries[i]);
 502         BloatEntry* right = static_cast<BloatEntry*>(entries[j]);
 503
 504         if (PL_strcmp(left->GetClassName(), right->GetClassName()) < 0) {
 505           entries.ReplaceElementAt(right, i);
 506           entries.ReplaceElementAt(left, j);
 507         }
 508       }
 509     }
 510
 511     // Enumerate from back-to-front, so things come out in alpha order
 512     for (i = 0; i < entries.Count(); ++i) {
 513       BloatEntry* entry = static_cast<BloatEntry*>(entries[i]);
 514       entry->Dump(i, out, type);
 515     }
 516   }
 517
 518   if (gSerialNumbers) {
 519     fprintf(out, "\n\nSerial Numbers of Leaked Objects:\n");
 520     PL_HashTableEnumerateEntries(gSerialNumbers, DumpSerialNumbers, out);
 521   }
 522
 523 done:
 524   gLogging = wasLogging;
 525   UNLOCK_TRACELOG();
 526 #endif
 527   return rv;
 528 }
 529
 530 NS_COM void
 531 nsTraceRefcntImpl::ResetStatistics()
 532 {
 533 #ifdef NS_IMPL_REFCNT_LOGGING
 534   LOCK_TRACELOG();
 535   if (gBloatView) {
 536     PL_HashTableDestroy(gBloatView);
 537     gBloatView = nsnull;
 538   }
 539   UNLOCK_TRACELOG();
 540 #endif
 541 }
 542
 543 #ifdef NS_IMPL_REFCNT_LOGGING
 544 static PRBool LogThisType(const char* aTypeName)
 545 {
 546   void* he = PL_HashTableLookup(gTypesToLog, aTypeName);
 547   return nsnull != he;
 548 }
 549
 550 static PRInt32 GetSerialNumber(void* aPtr, PRBool aCreate)
 551 {
 552 #ifdef GC_LEAK_DETECTOR
 553   // need to disguise this pointer, so the table won't keep the object alive.
 554   aPtr = (void*) ~PLHashNumber(aPtr);
 555 #endif
 556   PLHashEntry** hep = PL_HashTableRawLookup(gSerialNumbers, PLHashNumber(NS_PTR_TO_INT32(aPtr)), aPtr);
 557   if (hep && *hep) {
 558     return PRInt32((reinterpret_cast<serialNumberRecord*>((*hep)->value))->serialNumber);
 559   }
 560   else if (aCreate) {
 561     serialNumberRecord *record = PR_NEW(serialNumberRecord);
 562     record->serialNumber = ++gNextSerialNumber;
 563     record->refCount = 0;
 564     record->COMPtrCount = 0;
 565     PL_HashTableRawAdd(gSerialNumbers, hep, PLHashNumber(NS_PTR_TO_INT32(aPtr)), aPtr, reinterpret_cast<void*>(record));
 566     return gNextSerialNumber;
 567   }
 568   else {
 569     return 0;
 570   }
 571 }
 572
 573 static PRInt32* GetRefCount(void* aPtr)
 574 {
 575 #ifdef GC_LEAK_DETECTOR
 576   // need to disguise this pointer, so the table won't keep the object alive.
 577   aPtr = (void*) ~PLHashNumber(aPtr);
 578 #endif
 579   PLHashEntry** hep = PL_HashTableRawLookup(gSerialNumbers, PLHashNumber(NS_PTR_TO_INT32(aPtr)), aPtr);
 580   if (hep && *hep) {
 581     return &((reinterpret_cast<serialNumberRecord*>((*hep)->value))->refCount);
 582   } else {
 583     return nsnull;
 584   }
 585 }
 586
 587 static PRInt32* GetCOMPtrCount(void* aPtr)
 588 {
 589 #ifdef GC_LEAK_DETECTOR
 590   // need to disguise this pointer, so the table won't keep the object alive.
 591   aPtr = (void*) ~PLHashNumber(aPtr);
 592 #endif
 593   PLHashEntry** hep = PL_HashTableRawLookup(gSerialNumbers, PLHashNumber(NS_PTR_TO_INT32(aPtr)), aPtr);
 594   if (hep && *hep) {
 595     return &((reinterpret_cast<serialNumberRecord*>((*hep)->value))->COMPtrCount);
 596   } else {
 597     return nsnull;
 598   }
 599 }
 600
 601 static void RecycleSerialNumberPtr(void* aPtr)
 602 {
 603 #ifdef GC_LEAK_DETECTOR
 604   // need to disguise this pointer, so the table won't keep the object alive.
 605   aPtr = (void*) ~PLHashNumber(aPtr);
 606 #endif
 607   PL_HashTableRemove(gSerialNumbers, aPtr);
 608 }
 609
 610 static PRBool LogThisObj(PRInt32 aSerialNumber)
 611 {
 612   return nsnull != PL_HashTableLookup(gObjectsToLog, (const void*)(aSerialNumber));
 613 }
 614
 615 static PRBool InitLog(const char* envVar, const char* msg, FILE* *result)
 616 {
 617   const char* value = getenv(envVar);
 618   if (value) {
 619     if (nsCRT::strcmp(value, "1") == 0) {
 620       *result = stdout;
 621       fprintf(stdout, "### %s defined -- logging %s to stdout\n",
 622               envVar, msg);
 623       return PR_TRUE;
 624     }
 625     else if (nsCRT::strcmp(value, "2") == 0) {
 626       *result = stderr;
 627       fprintf(stdout, "### %s defined -- logging %s to stderr\n",
 628               envVar, msg);
 629       return PR_TRUE;
 630     }
 631     else {
 632       FILE *stream = ::fopen(value, "w");
 633       if (stream != NULL) {
 634         *result = stream;
 635         fprintf(stdout, "### %s defined -- logging %s to %s\n",
 636                 envVar, msg, value);
 637         return PR_TRUE;
 638       }
 639       else {
 640         fprintf(stdout, "### %s defined -- unable to log %s to %s\n",
 641                 envVar, msg, value);
 642         return PR_FALSE;
 643       }
 644     }
 645   }
 646   return PR_FALSE;
 647 }
 648
 649
 650 static PLHashNumber PR_CALLBACK HashNumber(const void* aKey)
 651 {
 652   return PLHashNumber(NS_PTR_TO_INT32(aKey));
 653 }
 654
 655 static void InitTraceLog(void)
 656 {
 657   if (gInitialized) return;
 658   gInitialized = PR_TRUE;
 659
 660   PRBool defined;
 661   defined = InitLog("XPCOM_MEM_BLOAT_LOG", "bloat/leaks", &gBloatLog);
 662   if (!defined)
 663     gLogLeaksOnly = InitLog("XPCOM_MEM_LEAK_LOG", "leaks", &gBloatLog);
 664   if (defined || gLogLeaksOnly) {
 665     RecreateBloatView();
 666     if (!gBloatView) {
 667       NS_WARNING("out of memory");
 668       gBloatLog = nsnull;
 669       gLogLeaksOnly = PR_FALSE;
 670     }
 671   }
 672
 673   (void)InitLog("XPCOM_MEM_REFCNT_LOG", "refcounts", &gRefcntsLog);
 674
 675   (void)InitLog("XPCOM_MEM_ALLOC_LOG", "new/delete", &gAllocLog);
 676
 677   defined = InitLog("XPCOM_MEM_LEAKY_LOG", "for leaky", &gLeakyLog);
 678   if (defined) {
 679     gLogToLeaky = PR_TRUE;
 680     PRFuncPtr p = nsnull, q = nsnull;
 681 #ifdef HAVE_LIBDL
 682     {
 683       PRLibrary *lib = nsnull;
 684       p = PR_FindFunctionSymbolAndLibrary("__log_addref", &lib);
 685       if (lib) {
 686         PR_UnloadLibrary(lib);
 687         lib = nsnull;
 688       }
 689       q = PR_FindFunctionSymbolAndLibrary("__log_release", &lib);
 690       if (lib) {
 691         PR_UnloadLibrary(lib);
 692       }
 693     }
 694 #endif
 695     if (p && q) {
 696       leakyLogAddRef = (void (*)(void*,int,int)) p;
 697       leakyLogRelease = (void (*)(void*,int,int)) q;
 698     }
 699     else {
 700       gLogToLeaky = PR_FALSE;
 701       fprintf(stdout, "### ERROR: XPCOM_MEM_LEAKY_LOG defined, but can't locate __log_addref and __log_release symbols\n");
 702       fflush(stdout);
 703     }
 704   }
 705
 706   const char* classes = getenv("XPCOM_MEM_LOG_CLASSES");
 707
 708 #ifdef HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR
 709   if (classes) {
 710     (void)InitLog("XPCOM_MEM_COMPTR_LOG", "nsCOMPtr", &gCOMPtrLog);
 711   } else {
 712     if (getenv("XPCOM_MEM_COMPTR_LOG")) {
 713       fprintf(stdout, "### XPCOM_MEM_COMPTR_LOG defined -- but XPCOM_MEM_LOG_CLASSES is not defined\n");
 714     }
 715   }
 716 #else
 717   const char* comptr_log = getenv("XPCOM_MEM_COMPTR_LOG");
 718   if (comptr_log) {
 719     fprintf(stdout, "### XPCOM_MEM_COMPTR_LOG defined -- but it will not work without dynamic_cast\n");
 720   }
 721 #endif
 722
 723   if (classes) {
 724     // if XPCOM_MEM_LOG_CLASSES was set to some value, the value is interpreted
 725     // as a list of class names to track
 726     gTypesToLog = PL_NewHashTable(256,
 727                                   PL_HashString,
 728                                   PL_CompareStrings,
 729                                   PL_CompareValues,
 730                                   &typesToLogHashAllocOps, NULL);
 731     if (!gTypesToLog) {
 732       NS_WARNING("out of memory");
 733       fprintf(stdout, "### XPCOM_MEM_LOG_CLASSES defined -- unable to log specific classes\n");
 734     }
 735     else {
 736       fprintf(stdout, "### XPCOM_MEM_LOG_CLASSES defined -- only logging these classes: ");
 737       const char* cp = classes;
 738       for (;;) {
 739         char* cm = (char*) strchr(cp, ',');
 740         if (cm) {
 741           *cm = '\0';
 742         }
 743         PL_HashTableAdd(gTypesToLog, nsCRT::strdup(cp), (void*)1);
 744         fprintf(stdout, "%s ", cp);
 745         if (!cm) break;
 746         *cm = ',';
 747         cp = cm + 1;
 748       }
 749       fprintf(stdout, "\n");
 750     }
 751
 752     gSerialNumbers = PL_NewHashTable(256,
 753                                      HashNumber,
 754                                      PL_CompareValues,
 755                                      PL_CompareValues,
 756                                      &serialNumberHashAllocOps, NULL);
 757
 758
 759   }
 760
 761   const char* objects = getenv("XPCOM_MEM_LOG_OBJECTS");
 762   if (objects) {
 763     gObjectsToLog = PL_NewHashTable(256,
 764                                     HashNumber,
 765                                     PL_CompareValues,
 766                                     PL_CompareValues,
 767                                     NULL, NULL);
 768
 769     if (!gObjectsToLog) {
 770       NS_WARNING("out of memory");
 771       fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- unable to log specific objects\n");
 772     }
 773     else if (! (gRefcntsLog || gAllocLog || gCOMPtrLog)) {
 774       fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- but none of XPCOM_MEM_(REFCNT|ALLOC|COMPTR)_LOG is defined\n");
 775     }
 776     else {
 777       fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- only logging these objects: ");
 778       const char* cp = objects;
 779       for (;;) {
 780         char* cm = (char*) strchr(cp, ',');
 781         if (cm) {
 782           *cm = '\0';
 783         }
 784         PRInt32 top = 0;
 785         PRInt32 bottom = 0;
 786         while (*cp) {
 787           if (*cp == '-') {
 788             bottom = top;
 789             top = 0;
 790             ++cp;
 791           }
 792           top *= 10;
 793           top += *cp - '0';
 794           ++cp;
 795         }
 796         if (!bottom) {
 797           bottom = top;
 798         }
 799         for(PRInt32 serialno = bottom; serialno <= top; serialno++) {
 800           PL_HashTableAdd(gObjectsToLog, (const void*)serialno, (void*)1);
 801           fprintf(stdout, "%d ", serialno);
 802         }
 803         if (!cm) break;
 804         *cm = ',';
 805         cp = cm + 1;
 806       }
 807       fprintf(stdout, "\n");
 808     }
 809   }
 810
 811
 812   if (gBloatLog || gRefcntsLog || gAllocLog || gLeakyLog || gCOMPtrLog) {
 813     gLogging = PR_TRUE;
 814   }
 815
 816   gTraceLock = PR_NewLock();
 817 }
 818
 819 #endif
 820
 821 extern "C" {
 822
 823 PR_STATIC_CALLBACK(void) PrintStackFrame(void *aPC, void *aClosure)
 824 {
 825   FILE *stream = (FILE*)aClosure;
 826   nsCodeAddressDetails details;
 827   char buf[1024];
 828
 829   NS_DescribeCodeAddress(aPC, &details);
 830   NS_FormatCodeAddressDetails(aPC, &details, buf, sizeof(buf));
 831   fprintf(stream, buf);
 832 }
 833
 834 }
 835
 836 NS_COM void
 837 nsTraceRefcntImpl::WalkTheStack(FILE* aStream)
 838 {
 839   NS_StackWalk(PrintStackFrame, 2, aStream);
 840 }
 841
 842 //----------------------------------------------------------------------
 843
 844 // This thing is exported by libstdc++
 845 // Yes, this is a gcc only hack
 846 #if defined(MOZ_DEMANGLE_SYMBOLS)
 847 #include <cxxabi.h>
 848 #include <stdlib.h> // for free()
 849 #endif // MOZ_DEMANGLE_SYMBOLS
 850
 851 NS_COM void
 852 nsTraceRefcntImpl::DemangleSymbol(const char * aSymbol,
 853                               char * aBuffer,
 854                               int aBufLen)
 855 {
 856   NS_ASSERTION(nsnull != aSymbol,"null symbol");
 857   NS_ASSERTION(nsnull != aBuffer,"null buffer");
 858   NS_ASSERTION(aBufLen >= 32 ,"pulled 32 out of you know where");
 859
 860   aBuffer[0] = '\0';
 861
 862 #if defined(MOZ_DEMANGLE_SYMBOLS)
 863  /* See demangle.h in the gcc source for the voodoo */
 864   char * demangled = abi::__cxa_demangle(aSymbol,0,0,0);
 865
 866   if (demangled)
 867   {
 868     strncpy(aBuffer,demangled,aBufLen);
 869     free(demangled);
 870   }
 871 #endif // MOZ_DEMANGLE_SYMBOLS
 872 }
 873
 874
 875 //----------------------------------------------------------------------
 876
 877 EXPORT_XPCOM_API(void)
 878 NS_LogInit()
 879 {
 880 #ifdef NS_IMPL_REFCNT_LOGGING
 881   if (++gInitCount)
 882     nsTraceRefcntImpl::SetActivityIsLegal(PR_TRUE);
 883 #endif
 884 }
 885
 886 EXPORT_XPCOM_API(void)
 887 NS_LogTerm()
 888 {
 889   NS_ASSERTION(gInitCount > 0,
 890                "NS_LogTerm without matching NS_LogInit");
 891
 892   if (--gInitCount == 0) {
 893     if (gInitialized) {
 894       nsTraceRefcntImpl::DumpStatistics();
 895       nsTraceRefcntImpl::ResetStatistics();
 896     }
 897     nsTraceRefcntImpl::Shutdown();
 898 #ifdef NS_IMPL_REFCNT_LOGGING
 899     nsTraceRefcntImpl::SetActivityIsLegal(PR_FALSE);
 900     gActivityTLS = BAD_TLS_INDEX;
 901 #endif
 902   }
 903 }
 904
 905 EXPORT_XPCOM_API(void)
 906 NS_LogAddRef(void* aPtr, nsrefcnt aRefcnt,
 907              const char* aClazz, PRUint32 classSize)
 908 {
 909 #ifdef NS_IMPL_REFCNT_LOGGING
 910   ASSERT_ACTIVITY_IS_LEGAL;
 911   if (!gInitialized)
 912     InitTraceLog();
 913   if (gLogging) {
 914     LOCK_TRACELOG();
 915
 916     if (gBloatLog) {
 917       BloatEntry* entry = GetBloatEntry(aClazz, classSize);
 918       if (entry) {
 919         entry->AddRef(aRefcnt);
 920       }
 921     }
 922
 923     // Here's the case where neither NS_NEWXPCOM nor MOZ_COUNT_CTOR were used,
 924     // yet we still want to see creation information:
 925
 926     PRBool loggingThisType = (!gTypesToLog || LogThisType(aClazz));
 927     PRInt32 serialno = 0;
 928     if (gSerialNumbers && loggingThisType) {
 929       serialno = GetSerialNumber(aPtr, aRefcnt == 1);
 930       PRInt32* count = GetRefCount(aPtr);
 931       if(count)
 932         (*count)++;
 933
 934     }
 935
 936     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
 937     if (aRefcnt == 1 && gAllocLog && loggingThisType && loggingThisObject) {
 938       fprintf(gAllocLog, "\n<%s> 0x%08X %d Create\n",
 939               aClazz, NS_PTR_TO_INT32(aPtr), serialno);
 940       nsTraceRefcntImpl::WalkTheStack(gAllocLog);
 941     }
 942
 943     if (gRefcntsLog && loggingThisType && loggingThisObject) {
 944       if (gLogToLeaky) {
 945         (*leakyLogAddRef)(aPtr, aRefcnt - 1, aRefcnt);
 946       }
 947       else {
 948           // Can't use PR_LOG(), b/c it truncates the line
 949           fprintf(gRefcntsLog,
 950                   "\n<%s> 0x%08X %d AddRef %d\n", aClazz, NS_PTR_TO_INT32(aPtr), serialno, aRefcnt);
 951           nsTraceRefcntImpl::WalkTheStack(gRefcntsLog);
 952           fflush(gRefcntsLog);
 953       }
 954     }
 955     UNLOCK_TRACELOG();
 956   }
 957 #endif
 958 }
 959
 960 EXPORT_XPCOM_API(void)
 961 NS_LogRelease(void* aPtr, nsrefcnt aRefcnt, const char* aClazz)
 962 {
 963 #ifdef NS_IMPL_REFCNT_LOGGING
 964   ASSERT_ACTIVITY_IS_LEGAL;
 965   if (!gInitialized)
 966     InitTraceLog();
 967   if (gLogging) {
 968     LOCK_TRACELOG();
 969
 970     if (gBloatLog) {
 971       BloatEntry* entry = GetBloatEntry(aClazz, 0);
 972       if (entry) {
 973         entry->Release(aRefcnt);
 974       }
 975     }
 976
 977     PRBool loggingThisType = (!gTypesToLog || LogThisType(aClazz));
 978     PRInt32 serialno = 0;
 979     if (gSerialNumbers && loggingThisType) {
 980       serialno = GetSerialNumber(aPtr, PR_FALSE);
 981       PRInt32* count = GetRefCount(aPtr);
 982       if(count)
 983         (*count)--;
 984
 985     }
 986
 987     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
 988     if (gRefcntsLog && loggingThisType && loggingThisObject) {
 989       if (gLogToLeaky) {
 990         (*leakyLogRelease)(aPtr, aRefcnt + 1, aRefcnt);
 991       }
 992       else {
 993           // Can't use PR_LOG(), b/c it truncates the line
 994           fprintf(gRefcntsLog,
 995                   "\n<%s> 0x%08X %d Release %d\n", aClazz, NS_PTR_TO_INT32(aPtr), serialno, aRefcnt);
 996           nsTraceRefcntImpl::WalkTheStack(gRefcntsLog);
 997           fflush(gRefcntsLog);
 998       }
 999     }
1000
1001     // Here's the case where neither NS_DELETEXPCOM nor MOZ_COUNT_DTOR were used,
1002     // yet we still want to see deletion information:
1003
1004     if (aRefcnt == 0 && gAllocLog && loggingThisType && loggingThisObject) {
1005       fprintf(gAllocLog,
1006               "\n<%s> 0x%08X %d Destroy\n",
1007               aClazz, NS_PTR_TO_INT32(aPtr), serialno);
1008       nsTraceRefcntImpl::WalkTheStack(gAllocLog);
1009     }
1010
1011     if (aRefcnt == 0 && gSerialNumbers && loggingThisType) {
1012       RecycleSerialNumberPtr(aPtr);
1013     }
1014
1015     UNLOCK_TRACELOG();
1016   }
1017 #endif
1018 }
1019
1020 EXPORT_XPCOM_API(void)
1021 NS_LogCtor(void* aPtr, const char* aType, PRUint32 aInstanceSize)
1022 {
1023 #ifdef NS_IMPL_REFCNT_LOGGING
1024   ASSERT_ACTIVITY_IS_LEGAL;
1025   if (!gInitialized)
1026     InitTraceLog();
1027
1028   if (gLogging) {
1029     LOCK_TRACELOG();
1030
1031     if (gBloatLog) {
1032       BloatEntry* entry = GetBloatEntry(aType, aInstanceSize);
1033       if (entry) {
1034         entry->Ctor();
1035       }
1036     }
1037
1038     PRBool loggingThisType = (!gTypesToLog || LogThisType(aType));
1039     PRInt32 serialno = 0;
1040     if (gSerialNumbers && loggingThisType) {
1041       serialno = GetSerialNumber(aPtr, PR_TRUE);
1042     }
1043
1044     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
1045     if (gAllocLog && loggingThisType && loggingThisObject) {
1046       fprintf(gAllocLog, "\n<%s> 0x%08X %d Ctor (%d)\n",
1047              aType, NS_PTR_TO_INT32(aPtr), serialno, aInstanceSize);
1048       nsTraceRefcntImpl::WalkTheStack(gAllocLog);
1049     }
1050
1051     UNLOCK_TRACELOG();
1052   }
1053 #endif
1054 }
1055
1056
1057 EXPORT_XPCOM_API(void)
1058 NS_LogDtor(void* aPtr, const char* aType, PRUint32 aInstanceSize)
1059 {
1060 #ifdef NS_IMPL_REFCNT_LOGGING
1061   ASSERT_ACTIVITY_IS_LEGAL;
1062   if (!gInitialized)
1063     InitTraceLog();
1064
1065   if (gLogging) {
1066     LOCK_TRACELOG();
1067
1068     if (gBloatLog) {
1069       BloatEntry* entry = GetBloatEntry(aType, aInstanceSize);
1070       if (entry) {
1071         entry->Dtor();
1072       }
1073     }
1074
1075     PRBool loggingThisType = (!gTypesToLog || LogThisType(aType));
1076     PRInt32 serialno = 0;
1077     if (gSerialNumbers && loggingThisType) {
1078       serialno = GetSerialNumber(aPtr, PR_FALSE);
1079       RecycleSerialNumberPtr(aPtr);
1080     }
1081
1082     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
1083
1084     // (If we're on a losing architecture, don't do this because we'll be
1085     // using LogDeleteXPCOM instead to get file and line numbers.)
1086     if (gAllocLog && loggingThisType && loggingThisObject) {
1087       fprintf(gAllocLog, "\n<%s> 0x%08X %d Dtor (%d)\n",
1088              aType, NS_PTR_TO_INT32(aPtr), serialno, aInstanceSize);
1089       nsTraceRefcntImpl::WalkTheStack(gAllocLog);
1090     }
1091
1092     UNLOCK_TRACELOG();
1093   }
1094 #endif
1095 }
1096
1097
1098 EXPORT_XPCOM_API(void)
1099 NS_LogCOMPtrAddRef(void* aCOMPtr, nsISupports* aObject)
1100 {
1101 #if defined(NS_IMPL_REFCNT_LOGGING) && defined(HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR)
1102   // Get the most-derived object.
1103   void *object = dynamic_cast<void *>(aObject);
1104
1105   // This is a very indirect way of finding out what the class is
1106   // of the object being logged.  If we're logging a specific type,
1107   // then
1108   if (!gTypesToLog || !gSerialNumbers) {
1109     return;
1110   }
1111   PRInt32 serialno = GetSerialNumber(object, PR_FALSE);
1112   if (serialno == 0) {
1113     return;
1114   }
1115
1116   if (!gInitialized)
1117     InitTraceLog();
1118   if (gLogging) {
1119     LOCK_TRACELOG();
1120
1121     PRInt32* count = GetCOMPtrCount(object);
1122     if(count)
1123       (*count)++;
1124
1125     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
1126
1127     if (gCOMPtrLog && loggingThisObject) {
1128       fprintf(gCOMPtrLog, "\n<?> 0x%08X %d nsCOMPtrAddRef %d 0x%08X\n",
1129               NS_PTR_TO_INT32(object), serialno, count?(*count):-1, NS_PTR_TO_INT32(aCOMPtr));
1130       nsTraceRefcntImpl::WalkTheStack(gCOMPtrLog);
1131     }
1132
1133     UNLOCK_TRACELOG();
1134   }
1135 #endif
1136 }
1137
1138
1139 EXPORT_XPCOM_API(void)
1140 NS_LogCOMPtrRelease(void* aCOMPtr, nsISupports* aObject)
1141 {
1142 #if defined(NS_IMPL_REFCNT_LOGGING) && defined(HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR)
1143   // Get the most-derived object.
1144   void *object = dynamic_cast<void *>(aObject);
1145
1146   // This is a very indirect way of finding out what the class is
1147   // of the object being logged.  If we're logging a specific type,
1148   // then
1149   if (!gTypesToLog || !gSerialNumbers) {
1150     return;
1151   }
1152   PRInt32 serialno = GetSerialNumber(object, PR_FALSE);
1153   if (serialno == 0) {
1154     return;
1155   }
1156
1157   if (!gInitialized)
1158     InitTraceLog();
1159   if (gLogging) {
1160     LOCK_TRACELOG();
1161
1162     PRInt32* count = GetCOMPtrCount(object);
1163     if(count)
1164       (*count)--;
1165
1166     PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
1167
1168     if (gCOMPtrLog && loggingThisObject) {
1169       fprintf(gCOMPtrLog, "\n<?> 0x%08X %d nsCOMPtrRelease %d 0x%08X\n",
1170               NS_PTR_TO_INT32(object), serialno, count?(*count):-1, NS_PTR_TO_INT32(aCOMPtr));
1171       nsTraceRefcntImpl::WalkTheStack(gCOMPtrLog);
1172     }
1173
1174     UNLOCK_TRACELOG();
1175   }
1176 #endif
1177 }
1178
1179 NS_COM void
1180 nsTraceRefcntImpl::Startup()
1181 {
1182 }
1183
1184 NS_COM void
1185 nsTraceRefcntImpl::Shutdown()
1186 {
1187 #ifdef NS_IMPL_REFCNT_LOGGING
1188
1189   if (gBloatView) {
1190     PL_HashTableDestroy(gBloatView);
1191     gBloatView = nsnull;
1192   }
1193   if (gTypesToLog) {
1194     PL_HashTableDestroy(gTypesToLog);
1195     gTypesToLog = nsnull;
1196   }
1197   if (gObjectsToLog) {
1198     PL_HashTableDestroy(gObjectsToLog);
1199     gObjectsToLog = nsnull;
1200   }
1201   if (gSerialNumbers) {
1202     PL_HashTableDestroy(gSerialNumbers);
1203     gSerialNumbers = nsnull;
1204   }
1205 #endif
1206 }
1207
1208 NS_COM void
1209 nsTraceRefcntImpl::SetActivityIsLegal(PRBool aLegal)
1210 {
1211 #ifdef NS_IMPL_REFCNT_LOGGING
1212   if (gActivityTLS == BAD_TLS_INDEX)
1213     PR_NewThreadPrivateIndex(&gActivityTLS, nsnull);
1214
1215   PR_SetThreadPrivate(gActivityTLS, NS_INT32_TO_PTR(!aLegal));
1216 #endif
1217 }
1218
1219 NS_IMPL_QUERY_INTERFACE1(nsTraceRefcntImpl, nsITraceRefcnt)
1220
1221 NS_IMETHODIMP_(nsrefcnt) nsTraceRefcntImpl::AddRef(void)
1222 {
1223   return 2;
1224 }
1225
1226 NS_IMETHODIMP_(nsrefcnt) nsTraceRefcntImpl::Release(void)
1227 {
1228   return 1;
1229 }
1230
1231 NS_IMETHODIMP
1232 nsTraceRefcntImpl::LogAddRef(void *aPtr, nsrefcnt aNewRefcnt,
1233                              const char *aTypeName, PRUint32 aSize)
1234 {
1235   NS_LogAddRef(aPtr, aNewRefcnt, aTypeName, aSize);
1236   return NS_OK;
1237 }
1238
1239 NS_IMETHODIMP
1240 nsTraceRefcntImpl::LogRelease(void *aPtr, nsrefcnt aNewRefcnt,
1241                               const char *aTypeName)
1242 {
1243   NS_LogRelease(aPtr, aNewRefcnt, aTypeName);
1244   return NS_OK;
1245 }
1246
1247 NS_IMETHODIMP
1248 nsTraceRefcntImpl::LogCtor(void *aPtr, const char *aTypeName, PRUint32 aSize)
1249 {
1250   NS_LogCtor(aPtr, aTypeName, aSize);
1251   return NS_OK;
1252 }
1253
1254 NS_IMETHODIMP
1255 nsTraceRefcntImpl::LogDtor(void *aPtr, const char *aTypeName, PRUint32 aSize)
1256 {
1257   NS_LogDtor(aPtr, aTypeName, aSize);
1258   return NS_OK;
1259 }
1260
1261 NS_IMETHODIMP
1262 nsTraceRefcntImpl::LogAddCOMPtr(void *aCOMPtr, nsISupports* aObject)
1263 {
1264   NS_LogCOMPtrAddRef(aCOMPtr, aObject);
1265   return NS_OK;
1266 }
1267
1268 NS_IMETHODIMP
1269 nsTraceRefcntImpl::LogReleaseCOMPtr(void *aCOMPtr, nsISupports* aObject)
1270 {
1271   NS_LogCOMPtrRelease(aCOMPtr, aObject);
1272   return NS_OK;
1273 }
1274
1275 static const nsTraceRefcntImpl kTraceRefcntImpl;
1276
1277 NS_METHOD
1278 nsTraceRefcntImpl::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
1279 {
1280   return const_cast<nsTraceRefcntImpl*>(&kTraceRefcntImpl)->
1281     QueryInterface(aIID, aInstancePtr);
1282 }