1998-09-12 23:25:06 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The contents of this file are subject to the Netscape Public
|
|
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
|
|
* except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at http://www.mozilla.org/NPL/
|
1998-09-12 23:25:06 +04:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
1998-09-12 23:25:06 +04:00
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape Communications
|
1999-11-06 06:43:54 +03:00
|
|
|
* Corporation. Portions created by Netscape are
|
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
1998-09-12 23:25:06 +04:00
|
|
|
*/
|
1999-10-08 01:50:20 +04:00
|
|
|
|
1998-09-12 23:25:06 +04:00
|
|
|
#include "nsISupports.h"
|
1999-10-05 03:36:18 +04:00
|
|
|
#include "nsVoidArray.h"
|
1998-09-12 23:25:06 +04:00
|
|
|
#include "prprf.h"
|
|
|
|
#include "prlog.h"
|
1999-10-05 03:36:18 +04:00
|
|
|
#include "plstr.h"
|
1999-10-09 00:29:47 +04:00
|
|
|
#include <stdlib.h>
|
1999-10-12 13:30:12 +04:00
|
|
|
#include "nsCOMPtr.h"
|
1999-10-14 08:37:13 +04:00
|
|
|
#include "nsCRT.h"
|
2000-02-24 08:40:40 +03:00
|
|
|
#include <math.h>
|
1998-09-12 23:25:06 +04:00
|
|
|
|
|
|
|
#if defined(_WIN32)
|
|
|
|
#include <windows.h>
|
2000-03-24 02:39:25 +03:00
|
|
|
#elif defined(linux) && defined(__GLIBC__) && (defined(__i386) || defined(PPC))
|
1999-06-16 06:05:32 +04:00
|
|
|
#include <setjmp.h>
|
1999-06-16 08:55:36 +04:00
|
|
|
|
|
|
|
//
|
|
|
|
// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed
|
|
|
|
// if __USE_GNU is defined. I suppose its some kind of standards
|
|
|
|
// adherence thing.
|
|
|
|
//
|
1999-06-21 06:29:17 +04:00
|
|
|
#if (__GLIBC_MINOR__ >= 1)
|
1999-06-16 08:55:36 +04:00
|
|
|
#define __USE_GNU
|
|
|
|
#endif
|
|
|
|
|
1999-06-16 06:05:32 +04:00
|
|
|
#include <dlfcn.h>
|
1998-09-12 23:25:06 +04:00
|
|
|
#endif
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef HAVE_LIBDL
|
|
|
|
#include <dlfcn.h>
|
|
|
|
#endif
|
|
|
|
|
2000-04-13 07:51:43 +04:00
|
|
|
#if defined(XP_MAC) && !TARGET_CARBON
|
|
|
|
#include "macstdlibextras.h"
|
|
|
|
#endif
|
|
|
|
|
2000-02-24 08:40:40 +03:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
NS_COM void
|
|
|
|
NS_MeanAndStdDev(double n, double sumOfValues, double sumOfSquaredValues,
|
|
|
|
double *meanResult, double *stdDevResult)
|
|
|
|
{
|
|
|
|
double mean = 0.0, var = 0.0, stdDev = 0.0;
|
|
|
|
if (n > 0.0 && sumOfValues >= 0) {
|
|
|
|
mean = sumOfValues / n;
|
|
|
|
double temp = (n * sumOfSquaredValues) - (sumOfValues * sumOfValues);
|
|
|
|
if (temp < 0.0 || n <= 1)
|
|
|
|
var = 0.0;
|
|
|
|
else
|
|
|
|
var = temp / (n * (n - 1));
|
|
|
|
// for some reason, Windows says sqrt(0.0) is "-1.#J" (?!) so do this:
|
|
|
|
stdDev = var != 0.0 ? sqrt(var) : 0.0;
|
|
|
|
}
|
|
|
|
*meanResult = mean;
|
|
|
|
*stdDevResult = stdDev;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
1999-11-19 08:08:58 +03:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
|
|
#include "plhash.h"
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1998-09-19 10:56:22 +04:00
|
|
|
#if defined(NS_MT_SUPPORTED)
|
|
|
|
#include "prlock.h"
|
|
|
|
|
|
|
|
static PRLock* gTraceLock;
|
|
|
|
|
|
|
|
#define LOCK_TRACELOG() PR_Lock(gTraceLock)
|
|
|
|
#define UNLOCK_TRACELOG() PR_Unlock(gTraceLock)
|
|
|
|
#else /* ! NT_MT_SUPPORTED */
|
|
|
|
#define LOCK_TRACELOG()
|
|
|
|
#define UNLOCK_TRACELOG()
|
|
|
|
#endif /* ! NS_MT_SUPPORTED */
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
static PLHashTable* gBloatView;
|
|
|
|
static PLHashTable* gTypesToLog;
|
1999-11-11 06:23:24 +03:00
|
|
|
static PLHashTable* gObjectsToLog;
|
|
|
|
static PLHashTable* gSerialNumbers;
|
|
|
|
static PRInt32 gNextSerialNumber;
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
static PRBool gLogging;
|
|
|
|
static PRBool gLogToLeaky;
|
1999-10-23 07:16:19 +04:00
|
|
|
static PRBool gLogLeaksOnly;
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
static void (*leakyLogAddRef)(void* p, int oldrc, int newrc);
|
|
|
|
static void (*leakyLogRelease)(void* p, int oldrc, int newrc);
|
1999-10-08 01:50:20 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
static PRBool gInitialized = PR_FALSE;
|
|
|
|
static FILE *gBloatLog = nsnull;
|
|
|
|
static FILE *gRefcntsLog = nsnull;
|
|
|
|
static FILE *gAllocLog = nsnull;
|
|
|
|
static FILE *gLeakyLog = nsnull;
|
1999-10-21 07:44:37 +04:00
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
#define XPCOM_REFCNT_TRACK_BLOAT 0x1
|
|
|
|
#define XPCOM_REFCNT_LOG_ALL 0x2
|
|
|
|
#define XPCOM_REFCNT_LOG_SOME 0x4
|
|
|
|
#define XPCOM_REFCNT_LOG_TO_LEAKY 0x8
|
|
|
|
|
|
|
|
// Should only use this on NS_LOSING_ARCHITECTURE...
|
|
|
|
#define XPCOM_REFCNT_LOG_CALLS 0x10
|
|
|
|
#define XPCOM_REFCNT_LOG_NEW 0x20
|
|
|
|
|
2000-02-05 05:07:45 +03:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
struct GatherArgs {
|
|
|
|
nsTraceRefcntStatFunc func;
|
|
|
|
void* closure;
|
|
|
|
};
|
1999-10-08 01:50:20 +04:00
|
|
|
|
|
|
|
class BloatEntry {
|
|
|
|
public:
|
|
|
|
BloatEntry(const char* className, PRUint32 classSize)
|
|
|
|
: mClassName(className), mClassSize(classSize) {
|
1999-10-12 04:29:54 +04:00
|
|
|
Clear(&mNewStats);
|
|
|
|
Clear(&mAllStats);
|
2000-02-22 16:25:20 +03:00
|
|
|
mTotalLeaked = 0;
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
~BloatEntry() {}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-12-10 07:27:52 +03:00
|
|
|
PRUint32 GetClassSize() { return (PRUint32)mClassSize; }
|
2000-04-18 10:00:24 +04:00
|
|
|
const char* GetClassName() { return mClassName; }
|
1999-12-10 07:27:52 +03:00
|
|
|
|
1999-10-12 04:29:54 +04:00
|
|
|
static void Clear(nsTraceRefcntStats* stats) {
|
|
|
|
stats->mAddRefs = 0;
|
|
|
|
stats->mReleases = 0;
|
|
|
|
stats->mCreates = 0;
|
|
|
|
stats->mDestroys = 0;
|
|
|
|
stats->mRefsOutstandingTotal = 0;
|
2000-02-05 05:07:45 +03:00
|
|
|
stats->mRefsOutstandingSquared = 0;
|
1999-10-12 04:29:54 +04:00
|
|
|
stats->mObjsOutstandingTotal = 0;
|
2000-02-05 05:07:45 +03:00
|
|
|
stats->mObjsOutstandingSquared = 0;
|
1999-10-12 04:29:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Accumulate() {
|
|
|
|
mAllStats.mAddRefs += mNewStats.mAddRefs;
|
|
|
|
mAllStats.mReleases += mNewStats.mReleases;
|
|
|
|
mAllStats.mCreates += mNewStats.mCreates;
|
|
|
|
mAllStats.mDestroys += mNewStats.mDestroys;
|
|
|
|
mAllStats.mRefsOutstandingTotal += mNewStats.mRefsOutstandingTotal;
|
2000-02-05 05:07:45 +03:00
|
|
|
mAllStats.mRefsOutstandingSquared += mNewStats.mRefsOutstandingSquared;
|
1999-10-12 04:29:54 +04:00
|
|
|
mAllStats.mObjsOutstandingTotal += mNewStats.mObjsOutstandingTotal;
|
2000-02-05 05:07:45 +03:00
|
|
|
mAllStats.mObjsOutstandingSquared += mNewStats.mObjsOutstandingSquared;
|
1999-10-12 04:29:54 +04:00
|
|
|
Clear(&mNewStats);
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
void AddRef(nsrefcnt refcnt) {
|
1999-10-12 04:29:54 +04:00
|
|
|
mNewStats.mAddRefs++;
|
1999-10-08 01:50:20 +04:00
|
|
|
if (refcnt == 1) {
|
1999-10-12 04:29:54 +04:00
|
|
|
Ctor();
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
|
|
|
AccountRefs();
|
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
void Release(nsrefcnt refcnt) {
|
1999-10-12 04:29:54 +04:00
|
|
|
mNewStats.mReleases++;
|
1999-10-08 01:50:20 +04:00
|
|
|
if (refcnt == 0) {
|
1999-10-12 04:29:54 +04:00
|
|
|
Dtor();
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
|
|
|
AccountRefs();
|
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
void Ctor() {
|
1999-10-12 04:29:54 +04:00
|
|
|
mNewStats.mCreates++;
|
|
|
|
AccountObjs();
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Dtor() {
|
1999-10-12 04:29:54 +04:00
|
|
|
mNewStats.mDestroys++;
|
|
|
|
AccountObjs();
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
void AccountRefs() {
|
1999-10-12 04:29:54 +04:00
|
|
|
PRInt32 cnt = (mNewStats.mAddRefs - mNewStats.mReleases);
|
|
|
|
mNewStats.mRefsOutstandingTotal += cnt;
|
2000-02-05 05:07:45 +03:00
|
|
|
mNewStats.mRefsOutstandingSquared += cnt * cnt;
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
void AccountObjs() {
|
1999-10-12 04:29:54 +04:00
|
|
|
PRInt32 cnt = (mNewStats.mCreates - mNewStats.mDestroys);
|
|
|
|
mNewStats.mObjsOutstandingTotal += cnt;
|
2000-02-05 05:07:45 +03:00
|
|
|
mNewStats.mObjsOutstandingSquared += cnt * cnt;
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PRIntn PR_CALLBACK DumpEntry(PLHashEntry *he, PRIntn i, void *arg) {
|
1999-10-08 01:50:20 +04:00
|
|
|
BloatEntry* entry = (BloatEntry*)he->value;
|
1999-10-09 00:29:47 +04:00
|
|
|
if (entry) {
|
1999-10-12 04:29:54 +04:00
|
|
|
entry->Accumulate();
|
2000-04-18 10:00:24 +04:00
|
|
|
NS_STATIC_CAST(nsVoidArray*, arg)->AppendElement(entry);
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-12 04:29:54 +04:00
|
|
|
return HT_ENUMERATE_NEXT;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PRIntn PR_CALLBACK TotalEntries(PLHashEntry *he, PRIntn i, void *arg) {
|
1999-10-16 05:57:18 +04:00
|
|
|
BloatEntry* entry = (BloatEntry*)he->value;
|
1999-10-28 12:35:53 +04:00
|
|
|
if (entry && nsCRT::strcmp(entry->mClassName, "TOTAL") != 0) {
|
1999-10-16 05:57:18 +04:00
|
|
|
entry->Total((BloatEntry*)arg);
|
|
|
|
}
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Total(BloatEntry* total) {
|
|
|
|
total->mAllStats.mAddRefs += mNewStats.mAddRefs + mAllStats.mAddRefs;
|
|
|
|
total->mAllStats.mReleases += mNewStats.mReleases + mAllStats.mReleases;
|
|
|
|
total->mAllStats.mCreates += mNewStats.mCreates + mAllStats.mCreates;
|
|
|
|
total->mAllStats.mDestroys += mNewStats.mDestroys + mAllStats.mDestroys;
|
|
|
|
total->mAllStats.mRefsOutstandingTotal += mNewStats.mRefsOutstandingTotal + mAllStats.mRefsOutstandingTotal;
|
2000-02-05 05:07:45 +03:00
|
|
|
total->mAllStats.mRefsOutstandingSquared += mNewStats.mRefsOutstandingSquared + mAllStats.mRefsOutstandingSquared;
|
1999-10-16 05:57:18 +04:00
|
|
|
total->mAllStats.mObjsOutstandingTotal += mNewStats.mObjsOutstandingTotal + mAllStats.mObjsOutstandingTotal;
|
2000-02-05 05:07:45 +03:00
|
|
|
total->mAllStats.mObjsOutstandingSquared += mNewStats.mObjsOutstandingSquared + mAllStats.mObjsOutstandingSquared;
|
2000-01-27 08:14:51 +03:00
|
|
|
PRInt32 count = (mNewStats.mCreates + mAllStats.mCreates);
|
|
|
|
total->mClassSize += mClassSize * count; // adjust for average in DumpTotal
|
2000-02-24 08:40:40 +03:00
|
|
|
total->mTotalLeaked += (PRInt32)(mClassSize *
|
|
|
|
((mNewStats.mCreates + mAllStats.mCreates)
|
|
|
|
-(mNewStats.mDestroys + mAllStats.mDestroys)));
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
nsresult DumpTotal(PRUint32 nClasses, FILE* out) {
|
2000-01-27 08:14:51 +03:00
|
|
|
mClassSize /= mAllStats.mCreates;
|
2000-04-18 10:00:24 +04:00
|
|
|
return Dump(-1, out, nsTraceRefcnt::ALL_STATS);
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PRIntn PR_CALLBACK DestroyEntry(PLHashEntry *he, PRIntn i, void *arg) {
|
1999-10-09 00:29:47 +04:00
|
|
|
BloatEntry* entry = (BloatEntry*)he->value;
|
|
|
|
if (entry) {
|
1999-10-12 04:29:54 +04:00
|
|
|
delete entry;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
return HT_ENUMERATE_REMOVE | HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PRIntn PR_CALLBACK GatherEntry(PLHashEntry *he, PRIntn i, void *arg) {
|
1999-10-09 00:29:47 +04:00
|
|
|
BloatEntry* entry = (BloatEntry*)he->value;
|
|
|
|
GatherArgs* ga = (GatherArgs*) arg;
|
|
|
|
if (arg && entry && ga->func) {
|
1999-10-29 22:48:37 +04:00
|
|
|
PRBool stop = (*ga->func)(entry->mClassName, (PRUint32)entry->mClassSize,
|
1999-10-12 04:29:54 +04:00
|
|
|
&entry->mNewStats, &entry->mAllStats,
|
1999-10-09 00:29:47 +04:00
|
|
|
ga->closure);
|
|
|
|
if (stop) {
|
|
|
|
return HT_ENUMERATE_STOP;
|
|
|
|
}
|
|
|
|
}
|
1999-10-08 01:50:20 +04:00
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
static PRBool HaveLeaks(nsTraceRefcntStats* stats) {
|
|
|
|
return ((stats->mAddRefs != stats->mReleases) ||
|
|
|
|
(stats->mCreates != stats->mDestroys));
|
1999-10-12 04:29:54 +04:00
|
|
|
}
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
static nsresult PrintDumpHeader(FILE* out, const char* msg) {
|
|
|
|
fprintf(out, "\n== BloatView: %s\n\n", msg);
|
|
|
|
fprintf(out,
|
2000-04-18 10:00:24 +04:00
|
|
|
" |<----------------Class--------------->|<-----Bytes------>|<----------------Objects---------------->|<--------------References-------------->|\n");
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(out,
|
2000-04-18 10:00:24 +04:00
|
|
|
" Per-Inst Leaked Total Rem Mean StdDev Total Rem Mean StdDev\n");
|
1999-10-12 13:30:12 +04:00
|
|
|
return NS_OK;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
2000-04-18 10:00:24 +04:00
|
|
|
nsresult Dump(PRIntn i, FILE* out, nsTraceRefcnt::StatisticsType type) {
|
|
|
|
nsTraceRefcntStats* stats = (type == nsTraceRefcnt::NEW_STATS) ? &mNewStats : &mAllStats;
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gLogLeaksOnly && !HaveLeaks(stats)) {
|
1999-10-12 13:30:12 +04:00
|
|
|
return NS_OK;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-12-10 07:27:52 +03:00
|
|
|
|
2000-02-05 05:07:45 +03:00
|
|
|
double meanRefs, stddevRefs;
|
|
|
|
NS_MeanAndStdDev(stats->mAddRefs + stats->mReleases,
|
|
|
|
stats->mRefsOutstandingTotal,
|
|
|
|
stats->mRefsOutstandingSquared,
|
|
|
|
&meanRefs, &stddevRefs);
|
|
|
|
|
|
|
|
double meanObjs, stddevObjs;
|
|
|
|
NS_MeanAndStdDev(stats->mCreates + stats->mDestroys,
|
|
|
|
stats->mObjsOutstandingTotal,
|
|
|
|
stats->mObjsOutstandingSquared,
|
|
|
|
&meanObjs, &stddevObjs);
|
1999-10-12 04:29:54 +04:00
|
|
|
|
|
|
|
if ((stats->mAddRefs - stats->mReleases) != 0 ||
|
|
|
|
stats->mAddRefs != 0 ||
|
|
|
|
meanRefs != 0 ||
|
|
|
|
stddevRefs != 0 ||
|
|
|
|
(stats->mCreates - stats->mDestroys) != 0 ||
|
|
|
|
stats->mCreates != 0 ||
|
|
|
|
meanObjs != 0 ||
|
|
|
|
stddevObjs != 0) {
|
2000-04-18 10:00:24 +04:00
|
|
|
fprintf(out, "%4d %-40.40s %8d %8d %8d %8d (%8.2f +/- %8.2f) %8d %8d (%8.2f +/- %8.2f)\n",
|
1999-10-23 07:16:19 +04:00
|
|
|
i+1, mClassName,
|
1999-10-29 22:48:37 +04:00
|
|
|
(PRInt32)mClassSize,
|
2000-02-22 16:25:20 +03:00
|
|
|
(nsCRT::strcmp(mClassName, "TOTAL"))
|
|
|
|
?(PRInt32)((stats->mCreates - stats->mDestroys) * mClassSize)
|
|
|
|
:mTotalLeaked,
|
1999-10-23 07:16:19 +04:00
|
|
|
stats->mCreates,
|
|
|
|
(stats->mCreates - stats->mDestroys),
|
|
|
|
meanObjs,
|
|
|
|
stddevObjs,
|
|
|
|
stats->mAddRefs,
|
|
|
|
(stats->mAddRefs - stats->mReleases),
|
|
|
|
meanRefs,
|
|
|
|
stddevRefs);
|
1999-10-12 04:29:54 +04:00
|
|
|
}
|
1999-10-12 13:30:12 +04:00
|
|
|
return NS_OK;
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-08 01:50:20 +04:00
|
|
|
protected:
|
|
|
|
const char* mClassName;
|
1999-10-29 22:48:37 +04:00
|
|
|
double mClassSize; // this is stored as a double because of the way we compute the avg class size for total bloat
|
2000-02-22 16:25:20 +03:00
|
|
|
PRInt32 mTotalLeaked; // used only for TOTAL entry
|
1999-10-12 04:29:54 +04:00
|
|
|
nsTraceRefcntStats mNewStats;
|
|
|
|
nsTraceRefcntStats mAllStats;
|
1999-10-08 01:50:20 +04:00
|
|
|
};
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
static void
|
|
|
|
RecreateBloatView()
|
|
|
|
{
|
|
|
|
gBloatView = PL_NewHashTable(256,
|
|
|
|
PL_HashString,
|
|
|
|
PL_CompareStrings,
|
|
|
|
PL_CompareValues,
|
|
|
|
NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static BloatEntry*
|
|
|
|
GetBloatEntry(const char* aTypeName, PRUint32 aInstanceSize)
|
|
|
|
{
|
|
|
|
if (!gBloatView) {
|
|
|
|
RecreateBloatView();
|
|
|
|
}
|
|
|
|
BloatEntry* entry = NULL;
|
|
|
|
if (gBloatView) {
|
|
|
|
entry = (BloatEntry*)PL_HashTableLookup(gBloatView, aTypeName);
|
2000-06-02 19:50:36 +04:00
|
|
|
if (entry == NULL && aInstanceSize > 0) {
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
entry = new BloatEntry(aTypeName, aInstanceSize);
|
|
|
|
PLHashEntry* e = PL_HashTableAdd(gBloatView, aTypeName, entry);
|
|
|
|
if (e == NULL) {
|
|
|
|
delete entry;
|
|
|
|
entry = NULL;
|
|
|
|
}
|
2000-06-02 19:50:36 +04:00
|
|
|
} else {
|
|
|
|
NS_ASSERTION(aInstanceSize == 0 ||
|
|
|
|
entry->GetClassSize() == aInstanceSize,
|
|
|
|
"bad size recorded");
|
1999-12-10 07:27:52 +03:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
}
|
1999-10-12 04:29:54 +04:00
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PRIntn PR_CALLBACK DumpSerialNumbers(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure)
|
1999-11-11 06:23:24 +03:00
|
|
|
{
|
|
|
|
fprintf((FILE*) aClosure, "%d\n", PRInt32(aHashEntry->value));
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-10-09 02:04:04 +04:00
|
|
|
#endif /* NS_BUILD_REFCNT_LOGGING */
|
1999-10-12 04:29:54 +04:00
|
|
|
|
1999-10-12 13:30:12 +04:00
|
|
|
nsresult
|
1999-10-23 07:16:19 +04:00
|
|
|
nsTraceRefcnt::DumpStatistics(StatisticsType type, FILE* out)
|
1999-10-08 01:50:20 +04:00
|
|
|
{
|
1999-10-12 14:27:40 +04:00
|
|
|
nsresult rv = NS_OK;
|
1999-10-09 02:04:04 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog == nsnull || gBloatView == nsnull) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
if (out == nsnull) {
|
|
|
|
out = gBloatLog;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-12 13:30:12 +04:00
|
|
|
PRBool wasLogging = gLogging;
|
|
|
|
gLogging = PR_FALSE; // turn off logging for this method
|
|
|
|
|
|
|
|
const char* msg;
|
|
|
|
if (type == NEW_STATS) {
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gLogLeaksOnly)
|
|
|
|
msg = "NEW (incremental) LEAK STATISTICS";
|
|
|
|
else
|
|
|
|
msg = "NEW (incremental) LEAK AND BLOAT STATISTICS";
|
1999-10-12 04:29:54 +04:00
|
|
|
}
|
1999-10-12 13:30:12 +04:00
|
|
|
else {
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gLogLeaksOnly)
|
|
|
|
msg = "ALL (cumulative) LEAK STATISTICS";
|
|
|
|
else
|
|
|
|
msg = "ALL (cumulative) LEAK AND BLOAT STATISTICS";
|
1999-10-12 13:30:12 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
rv = BloatEntry::PrintDumpHeader(out, msg);
|
1999-10-12 13:30:12 +04:00
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-10-16 05:57:18 +04:00
|
|
|
|
2000-04-18 10:00:24 +04:00
|
|
|
{
|
|
|
|
BloatEntry total("TOTAL", 0);
|
|
|
|
PL_HashTableEnumerateEntries(gBloatView, BloatEntry::TotalEntries, &total);
|
|
|
|
total.DumpTotal(gBloatView->nentries, out);
|
|
|
|
|
|
|
|
nsVoidArray entries;
|
|
|
|
PL_HashTableEnumerateEntries(gBloatView, BloatEntry::DumpEntry, &entries);
|
1999-10-16 05:57:18 +04:00
|
|
|
|
2000-04-18 10:00:24 +04:00
|
|
|
printf("nsTraceRefcnt::DumpStatistics: %d entries\n", entries.Count());
|
|
|
|
|
|
|
|
// Sort the entries alphabetically by classname.
|
|
|
|
PRInt32 i, j;
|
|
|
|
for (i = entries.Count() - 1; i >= 1; --i) {
|
|
|
|
for (j = i - 1; j >= 0; --j) {
|
|
|
|
BloatEntry* left = NS_STATIC_CAST(BloatEntry*, entries[i]);
|
|
|
|
BloatEntry* right = NS_STATIC_CAST(BloatEntry*, entries[j]);
|
|
|
|
|
|
|
|
if (PL_strcmp(left->GetClassName(), right->GetClassName()) < 0) {
|
|
|
|
entries.ReplaceElementAt(right, i);
|
|
|
|
entries.ReplaceElementAt(left, j);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enumerate from back-to-front, so things come out in alpha order
|
|
|
|
for (i = 0; i < entries.Count(); ++i) {
|
|
|
|
BloatEntry* entry = NS_STATIC_CAST(BloatEntry*, entries[i]);
|
|
|
|
entry->Dump(i, out, type);
|
|
|
|
}
|
|
|
|
}
|
1999-10-12 04:29:54 +04:00
|
|
|
|
1999-11-11 06:23:24 +03:00
|
|
|
if (gSerialNumbers) {
|
|
|
|
fprintf(out, "\n\nSerial Numbers of Leaked Objects:\n");
|
|
|
|
PL_HashTableEnumerateEntries(gSerialNumbers, DumpSerialNumbers, out);
|
|
|
|
}
|
|
|
|
|
1999-10-12 13:30:12 +04:00
|
|
|
done:
|
|
|
|
gLogging = wasLogging;
|
1999-10-09 00:29:47 +04:00
|
|
|
UNLOCK_TRACELOG();
|
1999-10-09 02:04:04 +04:00
|
|
|
#endif
|
1999-10-12 14:27:40 +04:00
|
|
|
return rv;
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
void
|
|
|
|
nsTraceRefcnt::ResetStatistics()
|
|
|
|
{
|
1999-10-09 02:04:04 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
|
|
|
if (gBloatView) {
|
|
|
|
PL_HashTableEnumerateEntries(gBloatView, BloatEntry::DestroyEntry, 0);
|
|
|
|
PL_HashTableDestroy(gBloatView);
|
|
|
|
gBloatView = nsnull;
|
|
|
|
}
|
|
|
|
UNLOCK_TRACELOG();
|
1999-10-09 02:04:04 +04:00
|
|
|
#endif
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsTraceRefcnt::GatherStatistics(nsTraceRefcntStatFunc aFunc,
|
|
|
|
void* aClosure)
|
|
|
|
{
|
1999-10-09 02:04:04 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
|
|
|
if (gBloatView) {
|
|
|
|
GatherArgs ga;
|
|
|
|
ga.func = aFunc;
|
|
|
|
ga.closure = aClosure;
|
|
|
|
PL_HashTableEnumerateEntries(gBloatView, BloatEntry::GatherEntry,
|
|
|
|
(void*) &ga);
|
|
|
|
}
|
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
1999-10-09 02:04:04 +04:00
|
|
|
#endif
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
|
1999-10-09 02:04:04 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-09 00:29:47 +04:00
|
|
|
static PRBool LogThisType(const char* aTypeName)
|
|
|
|
{
|
|
|
|
void* he = PL_HashTableLookup(gTypesToLog, aTypeName);
|
|
|
|
return nsnull != he;
|
|
|
|
}
|
1999-10-08 01:50:20 +04:00
|
|
|
|
2000-02-29 04:35:38 +03:00
|
|
|
static PRInt32 GetSerialNumber(void* aPtr, PRBool aCreate)
|
1999-11-11 06:23:24 +03:00
|
|
|
{
|
2000-04-13 07:51:43 +04:00
|
|
|
#ifdef GC_LEAK_DETECTOR
|
|
|
|
// need to disguise this pointer, so the table won't keep the object alive.
|
|
|
|
aPtr = (void*) ~PLHashNumber(aPtr);
|
|
|
|
#endif
|
1999-11-11 06:23:24 +03:00
|
|
|
PLHashEntry** hep = PL_HashTableRawLookup(gSerialNumbers, PLHashNumber(aPtr), aPtr);
|
|
|
|
if (hep && *hep) {
|
|
|
|
return PRInt32((*hep)->value);
|
|
|
|
}
|
2000-02-29 04:35:38 +03:00
|
|
|
else if (aCreate) {
|
1999-11-11 06:23:24 +03:00
|
|
|
PL_HashTableRawAdd(gSerialNumbers, hep, PLHashNumber(aPtr), aPtr, (void*)(++gNextSerialNumber));
|
|
|
|
return gNextSerialNumber;
|
|
|
|
}
|
2000-02-29 04:35:38 +03:00
|
|
|
else {
|
|
|
|
return 0;
|
|
|
|
}
|
1999-11-11 06:23:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void RecycleSerialNumberPtr(void* aPtr)
|
|
|
|
{
|
2000-04-13 07:51:43 +04:00
|
|
|
#ifdef GC_LEAK_DETECTOR
|
|
|
|
// need to disguise this pointer, so the table won't keep the object alive.
|
|
|
|
aPtr = (void*) ~PLHashNumber(aPtr);
|
|
|
|
#endif
|
1999-11-11 06:23:24 +03:00
|
|
|
PL_HashTableRemove(gSerialNumbers, aPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PRBool LogThisObj(PRInt32 aSerialNumber)
|
|
|
|
{
|
|
|
|
return nsnull != PL_HashTableLookup(gObjectsToLog, (const void*)(aSerialNumber));
|
|
|
|
}
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
static PRBool InitLog(const char* envVar, const char* msg, FILE* *result)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-10-23 07:16:19 +04:00
|
|
|
const char* value = getenv(envVar);
|
|
|
|
if (value) {
|
|
|
|
if (nsCRT::strcmp(value, "1") == 0) {
|
|
|
|
*result = stdout;
|
|
|
|
fprintf(stdout, "### %s defined -- logging %s to stdout\n",
|
|
|
|
envVar, msg);
|
|
|
|
return PR_TRUE;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
else if (nsCRT::strcmp(value, "2") == 0) {
|
|
|
|
*result = stderr;
|
|
|
|
fprintf(stdout, "### %s defined -- logging %s to stderr\n",
|
|
|
|
envVar, msg);
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
FILE *stream = ::fopen(value, "w");
|
|
|
|
if (stream != NULL) {
|
|
|
|
*result = stream;
|
|
|
|
fprintf(stdout, "### %s defined -- logging %s to %s\n",
|
|
|
|
envVar, msg, value);
|
|
|
|
return PR_TRUE;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
else {
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(stdout, "### %s defined -- unable to log %s to %s\n",
|
|
|
|
envVar, msg, value);
|
|
|
|
return PR_FALSE;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-11-11 06:23:24 +03:00
|
|
|
|
2000-06-01 18:12:05 +04:00
|
|
|
static PLHashNumber PR_CALLBACK HashNumber(const void* aKey)
|
1999-11-11 06:23:24 +03:00
|
|
|
{
|
|
|
|
return PLHashNumber(aKey);
|
|
|
|
}
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
static void InitTraceLog(void)
|
|
|
|
{
|
|
|
|
if (gInitialized) return;
|
|
|
|
gInitialized = PR_TRUE;
|
|
|
|
|
2000-04-13 07:51:43 +04:00
|
|
|
#if defined(XP_MAC) && !TARGET_CARBON
|
|
|
|
// this can get called before Toolbox has been initialized.
|
|
|
|
InitializeMacToolbox();
|
|
|
|
#endif
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
PRBool defined;
|
|
|
|
defined = InitLog("XPCOM_MEM_BLOAT_LOG", "bloat/leaks", &gBloatLog);
|
|
|
|
if (!defined)
|
|
|
|
gLogLeaksOnly = InitLog("XPCOM_MEM_LEAK_LOG", "leaks", &gBloatLog);
|
|
|
|
if (defined || gLogLeaksOnly) {
|
|
|
|
RecreateBloatView();
|
|
|
|
if (NS_WARN_IF_FALSE(gBloatView, "out of memory")) {
|
|
|
|
gBloatLog = nsnull;
|
|
|
|
gLogLeaksOnly = PR_FALSE;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
(void)InitLog("XPCOM_MEM_REFCNT_LOG", "refcounts", &gRefcntsLog);
|
|
|
|
|
|
|
|
(void)InitLog("XPCOM_MEM_ALLOC_LOG", "new/delete", &gAllocLog);
|
|
|
|
|
|
|
|
defined = InitLog("XPCOM_MEM_LEAKY_LOG", "for leaky", &gLeakyLog);
|
|
|
|
if (defined) {
|
|
|
|
gLogToLeaky = PR_TRUE;
|
|
|
|
void* p = nsnull;
|
|
|
|
void* q = nsnull;
|
|
|
|
#ifdef HAVE_LIBDL
|
|
|
|
p = dlsym(0, "__log_addref");
|
|
|
|
q = dlsym(0, "__log_release");
|
1999-10-09 00:29:47 +04:00
|
|
|
#endif
|
1999-10-23 07:16:19 +04:00
|
|
|
if (p && q) {
|
|
|
|
leakyLogAddRef = (void (*)(void*,int,int)) p;
|
|
|
|
leakyLogRelease = (void (*)(void*,int,int)) q;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
else {
|
|
|
|
gLogToLeaky = PR_FALSE;
|
|
|
|
fprintf(stdout, "### ERROR: XPCOM_MEM_LEAKY_LOG defined, but can't locate __log_addref and __log_release symbols\n");
|
1999-10-25 02:01:09 +04:00
|
|
|
fflush(stdout);
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
const char* classes = getenv("XPCOM_MEM_LOG_CLASSES");
|
|
|
|
if (classes) {
|
2000-02-24 09:02:38 +03:00
|
|
|
// if XPCOM_MEM_LOG_CLASSES was set to some value, the value is interpreted
|
1999-10-23 07:16:19 +04:00
|
|
|
// as a list of class names to track
|
|
|
|
gTypesToLog = PL_NewHashTable(256,
|
|
|
|
PL_HashString,
|
|
|
|
PL_CompareStrings,
|
|
|
|
PL_CompareValues,
|
|
|
|
NULL, NULL);
|
|
|
|
if (NS_WARN_IF_FALSE(gTypesToLog, "out of memory")) {
|
|
|
|
fprintf(stdout, "### XPCOM_MEM_LOG_CLASSES defined -- unable to log specific classes\n");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fprintf(stdout, "### XPCOM_MEM_LOG_CLASSES defined -- only logging these classes: ");
|
|
|
|
const char* cp = classes;
|
|
|
|
for (;;) {
|
1999-11-13 02:52:17 +03:00
|
|
|
char* cm = (char*) strchr(cp, ',');
|
1999-10-23 07:16:19 +04:00
|
|
|
if (cm) {
|
|
|
|
*cm = '\0';
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
PL_HashTableAdd(gTypesToLog, nsCRT::strdup(cp), (void*)1);
|
|
|
|
fprintf(stdout, "%s ", cp);
|
|
|
|
if (!cm) break;
|
|
|
|
*cm = ',';
|
|
|
|
cp = cm + 1;
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(stdout, "\n");
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
1999-11-11 06:23:24 +03:00
|
|
|
|
|
|
|
gSerialNumbers = PL_NewHashTable(256,
|
|
|
|
HashNumber,
|
|
|
|
PL_CompareValues,
|
|
|
|
PL_CompareValues,
|
|
|
|
NULL, NULL);
|
1999-11-19 06:50:28 +03:00
|
|
|
|
|
|
|
|
1999-11-11 06:23:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
const char* objects = getenv("XPCOM_MEM_LOG_OBJECTS");
|
|
|
|
if (objects) {
|
|
|
|
gObjectsToLog = PL_NewHashTable(256,
|
|
|
|
HashNumber,
|
|
|
|
PL_CompareValues,
|
|
|
|
PL_CompareValues,
|
|
|
|
NULL, NULL);
|
|
|
|
|
2000-04-22 04:40:13 +04:00
|
|
|
if (NS_WARN_IF_FALSE(gObjectsToLog, "out of memory")) {
|
1999-11-11 06:23:24 +03:00
|
|
|
fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- unable to log specific objects\n");
|
|
|
|
}
|
2000-04-22 04:40:13 +04:00
|
|
|
else if (! (gRefcntsLog || gAllocLog)) {
|
|
|
|
fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- but neither XPCOM_MEM_REFCNT_LOG nor XPCOM_MEM_ALLOC_LOG is defined\n");
|
1999-11-11 06:23:24 +03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
fprintf(stdout, "### XPCOM_MEM_LOG_OBJECTS defined -- only logging these objects: ");
|
|
|
|
const char* cp = objects;
|
|
|
|
for (;;) {
|
1999-11-13 02:52:17 +03:00
|
|
|
char* cm = (char*) strchr(cp, ',');
|
1999-11-11 06:23:24 +03:00
|
|
|
if (cm) {
|
|
|
|
*cm = '\0';
|
|
|
|
}
|
|
|
|
PRInt32 serialno = 0;
|
|
|
|
while (*cp) {
|
|
|
|
serialno *= 10;
|
|
|
|
serialno += *cp - '0';
|
|
|
|
++cp;
|
|
|
|
}
|
|
|
|
PL_HashTableAdd(gObjectsToLog, (const void*)serialno, (void*)1);
|
|
|
|
fprintf(stdout, "%d ", serialno);
|
|
|
|
if (!cm) break;
|
|
|
|
*cm = ',';
|
|
|
|
cp = cm + 1;
|
|
|
|
}
|
|
|
|
fprintf(stdout, "\n");
|
|
|
|
}
|
1999-10-23 07:16:19 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-11-19 06:50:28 +03:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog || gRefcntsLog || gAllocLog || gLeakyLog) {
|
|
|
|
gLogging = PR_TRUE;
|
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1998-09-19 10:56:22 +04:00
|
|
|
#if defined(NS_MT_SUPPORTED)
|
1999-10-23 07:16:19 +04:00
|
|
|
gTraceLock = PR_NewLock();
|
1998-09-19 10:56:22 +04:00
|
|
|
#endif /* NS_MT_SUPPORTED */
|
1999-10-08 01:50:20 +04:00
|
|
|
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
1999-11-19 06:50:28 +03:00
|
|
|
|
1999-10-09 02:04:04 +04:00
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-07-25 02:00:00 +04:00
|
|
|
#if defined(_WIN32) && defined(_M_IX86) // WIN32 x86 stack walking code
|
1998-09-12 23:25:06 +04:00
|
|
|
#include "imagehlp.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
|
1999-06-15 07:25:27 +04:00
|
|
|
// Define these as static pointers so that we can load the DLL on the
|
|
|
|
// fly (and not introduce a link-time dependency on it). Tip o' the
|
|
|
|
// hat to Matt Pietrick for this idea. See:
|
|
|
|
//
|
|
|
|
// http://msdn.microsoft.com/library/periodic/period97/F1/D3/S245C6.htm
|
|
|
|
//
|
|
|
|
typedef BOOL (__stdcall *SYMINITIALIZEPROC)(HANDLE, LPSTR, BOOL);
|
|
|
|
static SYMINITIALIZEPROC _SymInitialize;
|
|
|
|
|
|
|
|
typedef BOOL (__stdcall *SYMCLEANUPPROC)(HANDLE);
|
|
|
|
static SYMCLEANUPPROC _SymCleanup;
|
|
|
|
|
|
|
|
typedef BOOL (__stdcall *STACKWALKPROC)(DWORD,
|
|
|
|
HANDLE,
|
|
|
|
HANDLE,
|
|
|
|
LPSTACKFRAME,
|
|
|
|
LPVOID,
|
|
|
|
PREAD_PROCESS_MEMORY_ROUTINE,
|
|
|
|
PFUNCTION_TABLE_ACCESS_ROUTINE,
|
|
|
|
PGET_MODULE_BASE_ROUTINE,
|
|
|
|
PTRANSLATE_ADDRESS_ROUTINE);
|
|
|
|
static STACKWALKPROC _StackWalk;
|
|
|
|
|
|
|
|
typedef LPVOID (__stdcall *SYMFUNCTIONTABLEACCESSPROC)(HANDLE, DWORD);
|
|
|
|
static SYMFUNCTIONTABLEACCESSPROC _SymFunctionTableAccess;
|
|
|
|
|
|
|
|
typedef DWORD (__stdcall *SYMGETMODULEBASEPROC)(HANDLE, DWORD);
|
|
|
|
static SYMGETMODULEBASEPROC _SymGetModuleBase;
|
|
|
|
|
|
|
|
typedef BOOL (__stdcall *SYMGETSYMFROMADDRPROC)(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
|
|
|
|
static SYMGETSYMFROMADDRPROC _SymGetSymFromAddr;
|
|
|
|
|
1999-11-19 06:50:28 +03:00
|
|
|
typedef DWORD ( __stdcall *SYMLOADMODULE)(HANDLE, HANDLE, PSTR, PSTR, DWORD, DWORD);
|
|
|
|
static SYMLOADMODULE _SymLoadModule;
|
1999-06-15 07:25:27 +04:00
|
|
|
|
|
|
|
static PRBool
|
1999-11-19 06:50:28 +03:00
|
|
|
EnsureImageHlpInitialized()
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-11-19 06:50:28 +03:00
|
|
|
static PRBool gInitialized = PR_FALSE;
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-06-15 07:25:27 +04:00
|
|
|
if (! gInitialized) {
|
|
|
|
HMODULE module = ::LoadLibrary("IMAGEHLP.DLL");
|
|
|
|
if (!module) return PR_FALSE;
|
|
|
|
|
|
|
|
_SymInitialize = (SYMINITIALIZEPROC) ::GetProcAddress(module, "SymInitialize");
|
|
|
|
if (!_SymInitialize) return PR_FALSE;
|
|
|
|
|
|
|
|
_SymCleanup = (SYMCLEANUPPROC)GetProcAddress(module, "SymCleanup");
|
|
|
|
if (!_SymCleanup) return PR_FALSE;
|
|
|
|
|
|
|
|
_StackWalk = (STACKWALKPROC)GetProcAddress(module, "StackWalk");
|
|
|
|
if (!_StackWalk) return PR_FALSE;
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-06-15 07:25:27 +04:00
|
|
|
_SymFunctionTableAccess = (SYMFUNCTIONTABLEACCESSPROC) GetProcAddress(module, "SymFunctionTableAccess");
|
|
|
|
if (!_SymFunctionTableAccess) return PR_FALSE;
|
|
|
|
|
|
|
|
_SymGetModuleBase = (SYMGETMODULEBASEPROC)GetProcAddress(module, "SymGetModuleBase");
|
|
|
|
if (!_SymGetModuleBase) return PR_FALSE;
|
|
|
|
|
|
|
|
_SymGetSymFromAddr = (SYMGETSYMFROMADDRPROC)GetProcAddress(module, "SymGetSymFromAddr");
|
|
|
|
if (!_SymGetSymFromAddr) return PR_FALSE;
|
|
|
|
|
1999-11-19 06:50:28 +03:00
|
|
|
_SymLoadModule = (SYMLOADMODULE)GetProcAddress(module, "SymLoadModule");
|
|
|
|
if (!_SymLoadModule) return PR_FALSE;
|
|
|
|
|
|
|
|
gInitialized = PR_TRUE;
|
1999-06-15 07:25:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return gInitialized;
|
1999-11-19 06:50:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PRBool
|
|
|
|
EnsureSymInitialized()
|
|
|
|
{
|
|
|
|
static PRBool gInitialized = PR_FALSE;
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-11-19 06:50:28 +03:00
|
|
|
if (! gInitialized) {
|
|
|
|
if (! EnsureImageHlpInitialized())
|
|
|
|
return PR_FALSE;
|
|
|
|
gInitialized = _SymInitialize(GetCurrentProcess(), 0, TRUE);
|
|
|
|
}
|
|
|
|
return gInitialized;
|
|
|
|
}
|
1998-09-12 23:25:06 +04:00
|
|
|
/**
|
|
|
|
* Walk the stack, translating PC's found into strings and recording the
|
|
|
|
* chain in aBuffer. For this to work properly, the dll's must be rebased
|
|
|
|
* so that the address in the file agrees with the address in memory.
|
|
|
|
* Otherwise StackWalk will return FALSE when it hits a frame in a dll's
|
|
|
|
* whose in memory address doesn't match it's in-file address.
|
|
|
|
*
|
|
|
|
* Fortunately, there is a handy dandy routine in IMAGEHLP.DLL that does
|
|
|
|
* the rebasing and accordingly I've made a tool to use it to rebase the
|
|
|
|
* DLL's in one fell swoop (see xpcom/tools/windows/rebasedlls.cpp).
|
|
|
|
*/
|
1999-10-21 07:44:37 +04:00
|
|
|
|
1998-11-26 21:03:20 +03:00
|
|
|
void
|
1999-10-21 07:44:37 +04:00
|
|
|
nsTraceRefcnt::WalkTheStack(FILE* aStream)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
|
|
|
HANDLE myProcess = ::GetCurrentProcess();
|
|
|
|
HANDLE myThread = ::GetCurrentThread();
|
1999-06-15 07:25:27 +04:00
|
|
|
BOOL ok;
|
|
|
|
|
|
|
|
ok = EnsureSymInitialized();
|
|
|
|
if (! ok)
|
|
|
|
return;
|
|
|
|
|
1998-09-12 23:25:06 +04:00
|
|
|
// Get the context information for this thread. That way we will
|
|
|
|
// know where our sp, fp, pc, etc. are and can fill in the
|
|
|
|
// STACKFRAME with the initial values.
|
1999-06-15 07:25:27 +04:00
|
|
|
CONTEXT context;
|
1998-09-12 23:25:06 +04:00
|
|
|
context.ContextFlags = CONTEXT_FULL;
|
1999-06-15 07:25:27 +04:00
|
|
|
ok = GetThreadContext(myThread, &context);
|
|
|
|
if (! ok)
|
1998-09-12 23:25:06 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Setup initial stack frame to walk from
|
1999-06-15 07:25:27 +04:00
|
|
|
STACKFRAME frame;
|
1998-09-12 23:25:06 +04:00
|
|
|
memset(&frame, 0, sizeof(frame));
|
1999-06-15 07:25:27 +04:00
|
|
|
frame.AddrPC.Offset = context.Eip;
|
|
|
|
frame.AddrPC.Mode = AddrModeFlat;
|
1998-09-12 23:25:06 +04:00
|
|
|
frame.AddrStack.Offset = context.Esp;
|
1999-06-15 07:25:27 +04:00
|
|
|
frame.AddrStack.Mode = AddrModeFlat;
|
|
|
|
frame.AddrFrame.Offset = context.Ebp;
|
|
|
|
frame.AddrFrame.Mode = AddrModeFlat;
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-10-21 07:44:37 +04:00
|
|
|
// Now walk the stack and map the pc's to symbol names
|
1998-09-12 23:25:06 +04:00
|
|
|
int skip = 2;
|
1999-10-21 07:44:37 +04:00
|
|
|
while (1) {
|
1999-06-15 07:25:27 +04:00
|
|
|
ok = _StackWalk(IMAGE_FILE_MACHINE_I386,
|
|
|
|
myProcess,
|
|
|
|
myThread,
|
|
|
|
&frame,
|
|
|
|
&context,
|
|
|
|
0, // read process memory routine
|
|
|
|
_SymFunctionTableAccess, // function table access routine
|
|
|
|
_SymGetModuleBase, // module base routine
|
|
|
|
0); // translate address routine
|
|
|
|
|
1999-10-24 13:13:52 +04:00
|
|
|
if (!ok) {
|
|
|
|
LPVOID lpMsgBuf;
|
|
|
|
FormatMessage(
|
|
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
|
|
NULL,
|
|
|
|
GetLastError(),
|
|
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
|
|
(LPTSTR) &lpMsgBuf,
|
|
|
|
0,
|
|
|
|
NULL
|
|
|
|
);
|
1999-11-19 06:50:28 +03:00
|
|
|
fprintf(aStream, "### ERROR: WalkStack: %s", lpMsgBuf);
|
|
|
|
fflush(aStream);
|
1999-10-24 13:13:52 +04:00
|
|
|
LocalFree( lpMsgBuf );
|
|
|
|
}
|
1999-06-15 07:25:27 +04:00
|
|
|
if (!ok || frame.AddrPC.Offset == 0)
|
1998-09-12 23:25:06 +04:00
|
|
|
break;
|
1999-06-15 07:25:27 +04:00
|
|
|
|
|
|
|
if (skip-- > 0)
|
1998-09-12 23:25:06 +04:00
|
|
|
continue;
|
1999-06-15 07:25:27 +04:00
|
|
|
|
|
|
|
char buf[sizeof(IMAGEHLP_SYMBOL) + 512];
|
|
|
|
PIMAGEHLP_SYMBOL symbol = (PIMAGEHLP_SYMBOL) buf;
|
|
|
|
symbol->SizeOfStruct = sizeof(buf);
|
|
|
|
symbol->MaxNameLength = 512;
|
|
|
|
|
|
|
|
DWORD displacement;
|
|
|
|
ok = _SymGetSymFromAddr(myProcess,
|
|
|
|
frame.AddrPC.Offset,
|
|
|
|
&displacement,
|
|
|
|
symbol);
|
|
|
|
|
|
|
|
if (ok) {
|
1999-10-21 07:44:37 +04:00
|
|
|
fprintf(aStream, "%s+0x%08X\n", symbol->Name, displacement);
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
|
|
|
else {
|
1999-10-21 07:44:37 +04:00
|
|
|
fprintf(aStream, "0x%08X\n", frame.AddrPC.Offset);
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-06-21 06:29:17 +04:00
|
|
|
|
2000-03-24 02:39:25 +03:00
|
|
|
#elif defined(linux) && defined(__GLIBC__) && (defined(__i386) || defined(PPC)) // i386 or PPC Linux stackwalking code
|
1999-06-16 06:05:32 +04:00
|
|
|
|
|
|
|
void
|
1999-10-21 07:44:37 +04:00
|
|
|
nsTraceRefcnt::WalkTheStack(FILE* aStream)
|
1999-06-16 06:05:32 +04:00
|
|
|
{
|
|
|
|
jmp_buf jb;
|
|
|
|
setjmp(jb);
|
|
|
|
|
2000-03-24 02:39:25 +03:00
|
|
|
// Stack walking code courtesy Kipp's "leaky".
|
|
|
|
#if defined(__i386)
|
1999-06-16 06:05:32 +04:00
|
|
|
u_long* bp = (u_long*) (jb[0].__jmpbuf[JB_BP]);
|
2000-03-24 02:39:25 +03:00
|
|
|
#elif defined(PPC)
|
|
|
|
u_long* bp = (u_long*) (jb[0].__jmpbuf[JB_GPR1]);
|
|
|
|
#endif
|
|
|
|
|
1999-06-16 06:05:32 +04:00
|
|
|
int skip = 2;
|
|
|
|
for (;;) {
|
|
|
|
u_long* nextbp = (u_long*) *bp++;
|
|
|
|
u_long pc = *bp;
|
|
|
|
if ((pc < 0x08000000) || (pc > 0x7fffffff) || (nextbp < bp)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (--skip <= 0) {
|
|
|
|
Dl_info info;
|
|
|
|
int ok = dladdr((void*) pc, &info);
|
|
|
|
if (ok < 0)
|
|
|
|
break;
|
|
|
|
|
1999-09-14 17:24:25 +04:00
|
|
|
const char * symbol = info.dli_sname;
|
|
|
|
|
|
|
|
int len = strlen(symbol);
|
1999-06-16 06:05:32 +04:00
|
|
|
if (! len)
|
|
|
|
break; // XXX Lazy. We could look at the filename or something.
|
|
|
|
|
1999-09-14 17:24:25 +04:00
|
|
|
char demangled[4096] = "\0";
|
|
|
|
|
|
|
|
DemangleSymbol(symbol,demangled,sizeof(demangled));
|
|
|
|
|
1999-10-21 07:44:37 +04:00
|
|
|
if (strlen(demangled)) {
|
1999-09-14 17:24:25 +04:00
|
|
|
symbol = demangled;
|
|
|
|
len = strlen(symbol);
|
|
|
|
}
|
1999-06-16 06:05:32 +04:00
|
|
|
|
|
|
|
PRUint32 off = (char*)pc - (char*)info.dli_saddr;
|
1999-10-21 07:44:37 +04:00
|
|
|
fprintf(aStream, "%s+0x%08X\n", symbol, off);
|
1999-06-16 06:05:32 +04:00
|
|
|
}
|
|
|
|
bp = nextbp;
|
|
|
|
}
|
|
|
|
}
|
1999-10-21 07:44:37 +04:00
|
|
|
#elif defined(XP_MAC)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stack walking code for the Mac OS.
|
|
|
|
*/
|
|
|
|
|
2000-04-13 07:51:43 +04:00
|
|
|
#include "gc_fragments.h"
|
|
|
|
|
|
|
|
#include <typeinfo>
|
|
|
|
|
1999-10-21 07:44:37 +04:00
|
|
|
extern "C" {
|
|
|
|
void MWUnmangle(const char *mangled_name, char *unmangled_name, size_t buffersize);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct traceback_table {
|
|
|
|
long zero;
|
|
|
|
long magic;
|
|
|
|
long reserved;
|
|
|
|
long codeSize;
|
|
|
|
short nameLength;
|
|
|
|
char name[2];
|
|
|
|
};
|
|
|
|
|
|
|
|
static char* pc2name(long* pc, char name[], long size)
|
|
|
|
{
|
|
|
|
name[0] = '\0';
|
|
|
|
|
|
|
|
// make sure pc is instruction aligned (at least).
|
|
|
|
if (UInt32(pc) == (UInt32(pc) & 0xFFFFFFFC)) {
|
|
|
|
long instructionsToLook = 4096;
|
|
|
|
long* instruction = (long*)pc;
|
|
|
|
|
|
|
|
// look for the traceback table.
|
|
|
|
while (instructionsToLook--) {
|
|
|
|
if (instruction[0] == 0x4E800020 && instruction[1] == 0x00000000) {
|
|
|
|
traceback_table* tb = (traceback_table*)&instruction[1];
|
|
|
|
long nameLength = (tb->nameLength > --size ? size : tb->nameLength);
|
|
|
|
memcpy(name, tb->name + 1, --nameLength);
|
|
|
|
name[nameLength] = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++instruction;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return name;
|
|
|
|
}
|
1999-02-26 20:39:55 +03:00
|
|
|
|
2000-04-13 07:51:43 +04:00
|
|
|
struct stack_frame {
|
|
|
|
stack_frame* next; // savedSP
|
|
|
|
void* savedCR;
|
|
|
|
void* savedLR;
|
|
|
|
void* reserved0;
|
|
|
|
void* reserved1;
|
|
|
|
void* savedTOC;
|
|
|
|
};
|
|
|
|
|
|
|
|
static asm stack_frame* getStackFrame()
|
|
|
|
{
|
|
|
|
mr r3, sp
|
|
|
|
blr
|
|
|
|
}
|
|
|
|
|
1999-06-15 07:25:27 +04:00
|
|
|
NS_COM void
|
1999-10-21 07:44:37 +04:00
|
|
|
nsTraceRefcnt::WalkTheStack(FILE* aStream)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
2000-04-13 07:51:43 +04:00
|
|
|
stack_frame* currentFrame = getStackFrame(); // WalkTheStack's frame.
|
|
|
|
currentFrame = currentFrame->next; // WalkTheStack's caller's frame.
|
|
|
|
currentFrame = currentFrame->next; // WalkTheStack's caller's caller's frame.
|
|
|
|
|
1999-10-21 07:44:37 +04:00
|
|
|
while (true) {
|
|
|
|
// LR saved at 8(SP) in each frame. subtract 4 to get address of calling instruction.
|
2000-04-13 07:51:43 +04:00
|
|
|
void* pc = currentFrame->savedLR;
|
1999-10-21 07:44:37 +04:00
|
|
|
|
|
|
|
// convert PC to name, unmangle it, and generate source location, if possible.
|
2000-04-13 07:51:43 +04:00
|
|
|
static char symbol_name[1024], unmangled_name[1024], file_name[256]; UInt32 file_offset;
|
1999-10-21 07:44:37 +04:00
|
|
|
|
2000-04-13 07:51:43 +04:00
|
|
|
if (GC_address_to_source((char*)pc, symbol_name, file_name, &file_offset)) {
|
|
|
|
MWUnmangle(symbol_name, unmangled_name, sizeof(unmangled_name));
|
1999-10-21 07:44:37 +04:00
|
|
|
fprintf(aStream, "%s[%s,%ld]\n", unmangled_name, file_name, file_offset);
|
2000-04-13 07:51:43 +04:00
|
|
|
} else {
|
|
|
|
pc2name((long*)pc, symbol_name, sizeof(symbol_name));
|
|
|
|
MWUnmangle(symbol_name, unmangled_name, sizeof(unmangled_name));
|
|
|
|
fprintf(aStream, "%s(0x%08X)\n", unmangled_name, pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
currentFrame = currentFrame->next;
|
|
|
|
// the bottom-most frame is marked as pointing to NULL, or is ODD if a 68K transition frame.
|
|
|
|
if (currentFrame == NULL || UInt32(currentFrame) & 0x1)
|
1999-10-21 07:44:37 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // unsupported platform.
|
|
|
|
|
|
|
|
void
|
|
|
|
nsTraceRefcnt::WalkTheStack(FILE* aStream)
|
|
|
|
{
|
1999-10-21 08:28:07 +04:00
|
|
|
fprintf(aStream, "write me, dammit!\n");
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
1999-06-15 07:25:27 +04:00
|
|
|
|
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// This thing is exported by libiberty.a (-liberty)
|
|
|
|
// Yes, this is a gcc only hack
|
|
|
|
#if defined(MOZ_DEMANGLE_SYMBOLS)
|
|
|
|
extern "C" char * cplus_demangle(const char *,int);
|
|
|
|
#include <stdlib.h> // for free()
|
|
|
|
#endif // MOZ_DEMANGLE_SYMBOLS
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
NS_COM void
|
|
|
|
nsTraceRefcnt::DemangleSymbol(const char * aSymbol,
|
|
|
|
char * aBuffer,
|
|
|
|
int aBufLen)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(nsnull != aSymbol,"null symbol");
|
|
|
|
NS_ASSERTION(nsnull != aBuffer,"null buffer");
|
|
|
|
NS_ASSERTION(aBufLen >= 32 ,"pulled 32 out of you know where");
|
|
|
|
|
|
|
|
aBuffer[0] = '\0';
|
|
|
|
|
|
|
|
#if defined(MOZ_DEMANGLE_SYMBOLS)
|
|
|
|
/* See demangle.h in the gcc source for the voodoo */
|
|
|
|
char * demangled = cplus_demangle(aSymbol,3);
|
|
|
|
|
|
|
|
if (demangled)
|
|
|
|
{
|
|
|
|
strncpy(aBuffer,demangled,aBufLen);
|
|
|
|
|
|
|
|
free(demangled);
|
|
|
|
}
|
|
|
|
#endif // MOZ_DEMANGLE_SYMBOLS
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // __linux__
|
|
|
|
|
|
|
|
NS_COM void
|
|
|
|
nsTraceRefcnt::DemangleSymbol(const char * aSymbol,
|
|
|
|
char * aBuffer,
|
|
|
|
int aBufLen)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(nsnull != aSymbol,"null symbol");
|
|
|
|
NS_ASSERTION(nsnull != aBuffer,"null buffer");
|
|
|
|
|
|
|
|
// lose
|
|
|
|
aBuffer[0] = '\0';
|
|
|
|
}
|
|
|
|
#endif // __linux__
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
1998-09-12 23:25:06 +04:00
|
|
|
NS_COM void
|
|
|
|
nsTraceRefcnt::LoadLibrarySymbols(const char* aLibraryName,
|
|
|
|
void* aLibrayHandle)
|
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-07-25 02:00:00 +04:00
|
|
|
#if defined(_WIN32) && defined(_M_IX86) /* Win32 x86 only */
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1999-10-23 07:16:19 +04:00
|
|
|
|
|
|
|
if (gAllocLog || gRefcntsLog) {
|
1999-10-25 02:01:09 +04:00
|
|
|
fprintf(stdout, "### Loading symbols for %s\n", aLibraryName);
|
|
|
|
fflush(stdout);
|
|
|
|
|
1999-11-19 06:50:28 +03:00
|
|
|
HANDLE myProcess = ::GetCurrentProcess();
|
|
|
|
BOOL ok = EnsureSymInitialized();
|
1999-10-25 02:01:09 +04:00
|
|
|
if (ok) {
|
|
|
|
const char* baseName = aLibraryName;
|
|
|
|
// just get the base name of the library if a full path was given:
|
|
|
|
PRInt32 len = nsCRT::strlen(aLibraryName);
|
|
|
|
for (PRInt32 i = len - 1; i >= 0; i--) {
|
|
|
|
if (aLibraryName[i] == '\\') {
|
|
|
|
baseName = &aLibraryName[i + 1];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1999-11-19 06:50:28 +03:00
|
|
|
DWORD baseAddr = _SymLoadModule(myProcess,
|
1999-10-25 02:01:09 +04:00
|
|
|
NULL,
|
|
|
|
(char*)baseName,
|
|
|
|
(char*)baseName,
|
|
|
|
0,
|
|
|
|
0);
|
|
|
|
ok = (baseAddr != nsnull);
|
|
|
|
}
|
|
|
|
if (!ok) {
|
|
|
|
LPVOID lpMsgBuf;
|
|
|
|
FormatMessage(
|
|
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
|
|
NULL,
|
|
|
|
GetLastError(),
|
|
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
|
|
(LPTSTR) &lpMsgBuf,
|
|
|
|
0,
|
|
|
|
NULL
|
|
|
|
);
|
|
|
|
fprintf(stdout, "### ERROR: LoadLibrarySymbols for %s: %s\n",
|
|
|
|
aLibraryName, lpMsgBuf);
|
|
|
|
fflush(stdout);
|
|
|
|
LocalFree( lpMsgBuf );
|
1998-09-15 04:13:35 +04:00
|
|
|
}
|
|
|
|
}
|
1998-09-12 23:25:06 +04:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
1999-10-21 07:44:37 +04:00
|
|
|
/*
|
|
|
|
For consistency, and ease of munging the output, the following record format will be used:
|
|
|
|
|
|
|
|
<TypeName> 0xADDRESS Verb [optional data]
|
|
|
|
*/
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
NS_COM void
|
|
|
|
nsTraceRefcnt::LogAddRef(void* aPtr,
|
|
|
|
nsrefcnt aRefCnt,
|
|
|
|
const char* aClazz,
|
|
|
|
PRUint32 classSize)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogging) {
|
|
|
|
LOCK_TRACELOG();
|
2000-04-13 07:51:43 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog) {
|
1999-10-09 00:29:47 +04:00
|
|
|
BloatEntry* entry = GetBloatEntry(aClazz, classSize);
|
|
|
|
if (entry) {
|
|
|
|
entry->AddRef(aRefCnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
// Here's the case where neither NS_NEWXPCOM nor MOZ_COUNT_CTOR were used,
|
|
|
|
// yet we still want to see creation information:
|
|
|
|
#ifndef NS_LOSING_ARCHITECTURE
|
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogNewXPCOM instead to get file and line numbers.)
|
1999-10-24 13:13:52 +04:00
|
|
|
PRBool loggingThisType = (!gTypesToLog || LogThisType(aClazz));
|
1999-11-11 06:23:24 +03:00
|
|
|
PRInt32 serialno = 0;
|
|
|
|
if (gSerialNumbers && loggingThisType) {
|
2000-02-29 04:35:38 +03:00
|
|
|
serialno = GetSerialNumber(aPtr, aRefCnt == 1);
|
1999-11-11 06:23:24 +03:00
|
|
|
}
|
|
|
|
|
2000-04-22 04:40:13 +04:00
|
|
|
PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
|
|
|
|
if (aRefCnt == 1 && gAllocLog && loggingThisType && loggingThisObject) {
|
1999-11-11 06:23:24 +03:00
|
|
|
fprintf(gAllocLog, "\n<%s> 0x%08X %d Create\n",
|
2000-04-22 04:40:13 +04:00
|
|
|
aClazz, PRInt32(aPtr), serialno);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogAddRefCall instead to get file and line numbers.)
|
1999-11-11 06:23:24 +03:00
|
|
|
if (gRefcntsLog && loggingThisType && loggingThisObject) {
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogToLeaky) {
|
|
|
|
(*leakyLogAddRef)(aPtr, aRefCnt - 1, aRefCnt);
|
|
|
|
}
|
1999-11-19 06:50:28 +03:00
|
|
|
else {
|
|
|
|
// Can't use PR_LOG(), b/c it truncates the line
|
|
|
|
fprintf(gRefcntsLog,
|
|
|
|
"\n<%s> 0x%08X %d AddRef %d\n", aClazz, PRInt32(aPtr), serialno, aRefCnt);
|
|
|
|
WalkTheStack(gRefcntsLog);
|
|
|
|
fflush(gRefcntsLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
}
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_COM void
|
|
|
|
nsTraceRefcnt::LogRelease(void* aPtr,
|
|
|
|
nsrefcnt aRefCnt,
|
|
|
|
const char* aClazz)
|
|
|
|
{
|
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogging) {
|
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog) {
|
1999-12-10 07:27:52 +03:00
|
|
|
BloatEntry* entry = GetBloatEntry(aClazz, 0);
|
1999-10-09 00:29:47 +04:00
|
|
|
if (entry) {
|
|
|
|
entry->Release(aRefCnt);
|
|
|
|
}
|
|
|
|
}
|
1999-10-16 05:57:18 +04:00
|
|
|
|
|
|
|
#ifndef NS_LOSING_ARCHITECTURE
|
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogReleaseCall instead to get file and line numbers.)
|
1999-10-24 13:13:52 +04:00
|
|
|
PRBool loggingThisType = (!gTypesToLog || LogThisType(aClazz));
|
1999-11-11 06:23:24 +03:00
|
|
|
PRInt32 serialno = 0;
|
|
|
|
if (gSerialNumbers && loggingThisType) {
|
2000-02-29 04:35:38 +03:00
|
|
|
serialno = GetSerialNumber(aPtr, PR_FALSE);
|
1999-11-11 06:23:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
|
|
|
|
if (gRefcntsLog && loggingThisType && loggingThisObject) {
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogToLeaky) {
|
|
|
|
(*leakyLogRelease)(aPtr, aRefCnt + 1, aRefCnt);
|
|
|
|
}
|
|
|
|
else {
|
1999-11-19 06:50:28 +03:00
|
|
|
// Can't use PR_LOG(), b/c it truncates the line
|
|
|
|
fprintf(gRefcntsLog,
|
|
|
|
"\n<%s> 0x%08X %d Release %d\n", aClazz, PRInt32(aPtr), serialno, aRefCnt);
|
|
|
|
WalkTheStack(gRefcntsLog);
|
|
|
|
fflush(gRefcntsLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
// Here's the case where neither NS_DELETEXPCOM nor MOZ_COUNT_DTOR were used,
|
|
|
|
// yet we still want to see deletion information:
|
|
|
|
|
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogDeleteXPCOM instead to get file and line numbers.)
|
2000-04-22 04:40:13 +04:00
|
|
|
if (aRefCnt == 0 && gAllocLog && loggingThisType && loggingThisObject) {
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(gAllocLog,
|
1999-11-11 06:23:24 +03:00
|
|
|
"\n<%s> 0x%08X %d Destroy\n",
|
|
|
|
aClazz, PRInt32(aPtr), serialno);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
1999-11-11 06:23:24 +03:00
|
|
|
|
|
|
|
if (aRefCnt == 0 && gSerialNumbers && loggingThisType) {
|
|
|
|
RecycleSerialNumberPtr(aPtr);
|
|
|
|
}
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
UNLOCK_TRACELOG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_COM nsrefcnt
|
|
|
|
nsTraceRefcnt::LogAddRefCall(void* aPtr,
|
|
|
|
nsrefcnt aNewRefcnt,
|
|
|
|
const char* aFile,
|
|
|
|
int aLine)
|
|
|
|
{
|
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifdef NS_LOSING_ARCHITECTURE
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gRefcntsLog) {
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
1998-09-19 10:56:22 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(gRefcntsLog, "\n<Call> 0x%08X AddRef %d=>%d in %s (line %d)\n",
|
1999-10-21 07:44:37 +04:00
|
|
|
aPtr, aNewRefcnt-1, aNewRefcnt, aFile, aLine);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gRefcntsLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
#endif
|
|
|
|
return aNewRefcnt;
|
|
|
|
}
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
NS_COM nsrefcnt
|
|
|
|
nsTraceRefcnt::LogReleaseCall(void* aPtr,
|
|
|
|
nsrefcnt aNewRefcnt,
|
|
|
|
const char* aFile,
|
|
|
|
int aLine)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifdef NS_LOSING_ARCHITECTURE
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1998-09-19 10:56:22 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gRefcntsLog) {
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(gRefcntsLog, "\n<Call> 0x%08X Release %d=>%d in %s (line %d)\n",
|
1999-10-21 07:44:37 +04:00
|
|
|
aPtr, aNewRefcnt+1, aNewRefcnt, aFile, aLine);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gRefcntsLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
#endif
|
|
|
|
return aNewRefcnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_COM void
|
1999-10-09 00:29:47 +04:00
|
|
|
nsTraceRefcnt::LogNewXPCOM(void* aPtr,
|
|
|
|
const char* aType,
|
|
|
|
PRUint32 aInstanceSize,
|
|
|
|
const char* aFile,
|
|
|
|
int aLine)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifdef NS_LOSING_ARCHITECTURE
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1998-09-19 10:56:22 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gAllocLog) {
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(gAllocLog, "\n<%s> 0x%08X NewXPCOM in %s (line %d)\n",
|
1999-10-21 07:44:37 +04:00
|
|
|
aType, aPtr, aFile, aLine);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
|
|
|
#endif
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_COM void
|
1999-10-09 00:29:47 +04:00
|
|
|
nsTraceRefcnt::LogDeleteXPCOM(void* aPtr,
|
|
|
|
const char* aFile,
|
|
|
|
int aLine)
|
1998-09-12 23:25:06 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifdef NS_LOSING_ARCHITECTURE
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
1998-09-19 10:56:22 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gAllocLog) {
|
1999-10-09 00:29:47 +04:00
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
fprintf(gAllocLog, "\n<%s> 0x%08X Destroy in %s (line %d)\n",
|
|
|
|
"?", aPtr, aFile, aLine);
|
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-09 00:29:47 +04:00
|
|
|
|
|
|
|
UNLOCK_TRACELOG();
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
|
|
|
#endif
|
1999-10-16 05:57:18 +04:00
|
|
|
#endif
|
1998-09-12 23:25:06 +04:00
|
|
|
}
|
1999-06-15 07:25:27 +04:00
|
|
|
|
|
|
|
NS_COM void
|
1999-10-09 00:29:47 +04:00
|
|
|
nsTraceRefcnt::LogCtor(void* aPtr,
|
1999-10-21 07:44:37 +04:00
|
|
|
const char* aType,
|
1999-10-09 00:29:47 +04:00
|
|
|
PRUint32 aInstanceSize)
|
1999-06-15 07:25:27 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogging) {
|
|
|
|
LOCK_TRACELOG();
|
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog) {
|
1999-10-21 07:44:37 +04:00
|
|
|
BloatEntry* entry = GetBloatEntry(aType, aInstanceSize);
|
1999-10-09 00:29:47 +04:00
|
|
|
if (entry) {
|
|
|
|
entry->Ctor();
|
|
|
|
}
|
1999-10-08 01:50:20 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifndef NS_LOSING_ARCHITECTURE
|
2000-04-22 04:40:13 +04:00
|
|
|
PRBool loggingThisType = (!gTypesToLog || LogThisType(aType));
|
|
|
|
PRInt32 serialno = 0;
|
|
|
|
if (gSerialNumbers && loggingThisType) {
|
|
|
|
serialno = GetSerialNumber(aPtr, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogNewXPCOM instead to get file and line numbers.)
|
2000-04-22 04:40:13 +04:00
|
|
|
PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
|
|
|
|
if (gAllocLog && loggingThisType && loggingThisObject) {
|
|
|
|
fprintf(gAllocLog, "\n<%s> 0x%08X %d Ctor (%d)\n",
|
|
|
|
aType, PRInt32(aPtr), serialno, aInstanceSize);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
UNLOCK_TRACELOG();
|
1999-06-15 07:25:27 +04:00
|
|
|
}
|
1999-10-08 01:50:20 +04:00
|
|
|
#endif
|
1999-06-15 07:25:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_COM void
|
1999-10-21 07:44:37 +04:00
|
|
|
nsTraceRefcnt::LogDtor(void* aPtr, const char* aType,
|
1999-10-09 00:29:47 +04:00
|
|
|
PRUint32 aInstanceSize)
|
1999-06-15 07:25:27 +04:00
|
|
|
{
|
1999-10-09 00:29:47 +04:00
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
1999-10-23 07:16:19 +04:00
|
|
|
if (!gInitialized)
|
1999-10-16 05:57:18 +04:00
|
|
|
InitTraceLog();
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
if (gLogging) {
|
|
|
|
LOCK_TRACELOG();
|
1999-10-05 03:36:18 +04:00
|
|
|
|
1999-10-23 07:16:19 +04:00
|
|
|
if (gBloatLog) {
|
1999-10-21 07:44:37 +04:00
|
|
|
BloatEntry* entry = GetBloatEntry(aType, aInstanceSize);
|
1999-10-09 00:29:47 +04:00
|
|
|
if (entry) {
|
|
|
|
entry->Dtor();
|
1999-10-05 03:36:18 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
#ifndef NS_LOSING_ARCHITECTURE
|
2000-04-22 04:40:13 +04:00
|
|
|
PRBool loggingThisType = (!gTypesToLog || LogThisType(aType));
|
|
|
|
PRInt32 serialno = 0;
|
|
|
|
if (gSerialNumbers && loggingThisType) {
|
|
|
|
serialno = GetSerialNumber(aPtr, PR_FALSE);
|
|
|
|
RecycleSerialNumberPtr(aPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
|
|
|
|
|
1999-10-16 05:57:18 +04:00
|
|
|
// (If we're on a losing architecture, don't do this because we'll be
|
|
|
|
// using LogDeleteXPCOM instead to get file and line numbers.)
|
2000-04-22 04:40:13 +04:00
|
|
|
if (gAllocLog && loggingThisType && loggingThisObject) {
|
|
|
|
fprintf(gAllocLog, "\n<%s> 0x%08X %d Dtor (%d)\n",
|
|
|
|
aType, PRInt32(aPtr), serialno, aInstanceSize);
|
1999-10-23 07:16:19 +04:00
|
|
|
WalkTheStack(gAllocLog);
|
1999-10-16 05:57:18 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-10-09 00:29:47 +04:00
|
|
|
UNLOCK_TRACELOG();
|
1999-10-05 03:36:18 +04:00
|
|
|
}
|
1999-10-09 00:29:47 +04:00
|
|
|
#endif
|
1999-10-05 03:36:18 +04:00
|
|
|
}
|