The Tor Browser: tools/trace-malloc/spacetrace.c@97036ab72558 (annotated)

tools/trace-malloc/spacetrace.c@97036ab72558 (annotated)

tools/trace-malloc/spacetrace.c

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /*
 ** spacetrace.c
 **
 ** SpaceTrace is meant to take the output of trace-malloc and present
 **   a picture of allocations over the run of the application.
 */
 /*
 ** Required include files.
 */
 #include "spacetrace.h"
 #include <ctype.h>
 #include <math.h>
 #include <string.h>
 #include <time.h>
 #if defined(XP_WIN32)
 #include <malloc.h>             /* _heapMin */
 #endif
 #if defined(HAVE_BOUTELL_GD)
 /*
 ** See http://www.boutell.com/gd for the GD graphics library.
 ** Ports for many platorms exist.
 ** Your box may already have the lib (mine did, redhat 7.1 workstation).
 */
 #include <gd.h>
 #include <gdfontt.h>
 #include <gdfonts.h>
 #include <gdfontmb.h>
 #endif /* HAVE_BOUTELL_GD */
 #include "nsQuickSort.h"
 /*
 **  strcasecmp API please.
 */
 #if defined(_MSC_VER)
 #define strcasecmp _stricmp
 #define strncasecmp _strnicmp
 #endif
 /*
 ** the globals variables.  happy joy.
 */
 STGlobals globals;
 /*
 ** have the heap cleanup at opportune times, if possible.
 */
 void
 heapCompact(void)
 {
 #if defined(XP_WIN32)
     _heapmin();
 #endif
 }
 #define ST_CMD_OPTION_BOOL(option_name, option_genre, option_help) \
     PR_fprintf(PR_STDOUT, "--%s\nDisabled by default.\n%s\n", #option_name, option_help);
 #define ST_CMD_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     PR_fprintf(PR_STDOUT, "--%s=<value>\nDefault value is \"%s\".\n%s\n", #option_name, default_value, option_help);
 #define ST_CMD_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     PR_fprintf(PR_STDOUT, "--%s=<value>\nUp to %u occurrences allowed.\n%s\n", #option_name, array_size, option_help);
 #define ST_CMD_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help) \
     PR_fprintf(PR_STDOUT, "--%s=<value>\nUnlimited occurrences allowed.\n%s\n", #option_name, option_help);
 #define ST_CMD_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     PR_fprintf(PR_STDOUT, "--%s=<value>\nDefault value is %u.\n%s\n", #option_name, default_value, option_help);
 #define ST_CMD_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     PR_fprintf(PR_STDOUT, "--%s=<value>\nDefault value is %llu.\n%s\n", #option_name, default_value, option_help);
 /*
 ** showHelp
 **
 ** Give simple command line help.
 ** Returns !0 if the help was showed.
 */
 int
 showHelp(void)
 {
     int retval = 0;
     if (PR_FALSE != globals.mCommandLineOptions.mHelp) {
         PR_fprintf(PR_STDOUT, "Usage:\t%s [OPTION]... [-|filename]\n\n",
                    globals.mProgramName);
 #include "stoptions.h"
         /*
          ** Showed something.
          */
         retval = __LINE__;
     }
     return retval;
 }
 /*
 ** ticks2xsec
 **
 ** Convert platform specific ticks to second units
 ** Returns 0 on success.
 */
 uint32_t
 ticks2xsec(tmreader * aReader, uint32_t aTicks, uint32_t aResolution)
 {
     return (uint32_t)((aResolution * aTicks)/aReader->ticksPerSec);
 }
 #define ticks2msec(reader, ticks) ticks2xsec((reader), (ticks), 1000)
 #define ticks2usec(reader, ticks) ticks2xsec((reader), (ticks), 1000000)
 /*
 ** initOptions
 **
 ** Determine global settings for the application.
 ** Returns 0 on success.
 */
 int
 initOptions(int aArgCount, char **aArgArray)
 {
     int retval = 0;
     int traverse = 0;
     /*
      **  Set the initial global default options.
      */
 #define ST_CMD_OPTION_BOOL(option_name, option_genre, option_help) globals.mCommandLineOptions.m##option_name = PR_FALSE;
 #define ST_CMD_OPTION_STRING(option_name, option_genre, default_value, option_help) PR_snprintf(globals.mCommandLineOptions.m##option_name, sizeof(globals.mCommandLineOptions.m##option_name), "%s", default_value);
 #define ST_CMD_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) { int loop; for(loop = 0; loop < array_size; loop++) { globals.mCommandLineOptions.m##option_name[loop][0] = '\0'; } }
 #define ST_CMD_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help) globals.mCommandLineOptions.m##option_name = NULL; globals.mCommandLineOptions.m##option_name##Count = 0;
 #define ST_CMD_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) globals.mCommandLineOptions.m##option_name = default_value * multiplier;
 #define ST_CMD_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) { uint64_t def64 = default_value; uint64_t mul64 = multiplier; globals.mCommandLineOptions.m##option_name##64 = def64 * mul64; }
 #include "stoptions.h"
     /*
      ** Go through all arguments.
      ** Two dashes lead off an option.
      ** Any single dash leads off help, unless it is a lone dash (stdin).
      ** Anything else will be attempted as a file to be processed.
      */
     for (traverse = 1; traverse < aArgCount; traverse++) {
         if ('-' == aArgArray[traverse][0] && '-' == aArgArray[traverse][1]) {
             const char *option = &aArgArray[traverse][2];
             /*
              **  Initial if(0) needed to make "else if"s valid.
              */
             if (0) {
             }
 #define ST_CMD_OPTION_BOOL(option_name, option_genre, option_help) \
     else if(0 == strcasecmp(option, #option_name)) \
     { \
         globals.mCommandLineOptions.m##option_name = PR_TRUE; \
     }
 #define ST_CMD_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     else if(0 == strncasecmp(option, #option_name "=", strlen(#option_name "="))) \
     { \
         PR_snprintf(globals.mCommandLineOptions.m##option_name, sizeof(globals.mCommandLineOptions.m##option_name), "%s", option + strlen(#option_name "=")); \
     }
 #define ST_CMD_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     else if(0 == strncasecmp(option, #option_name "=", strlen(#option_name "="))) \
     { \
         int arrLoop = 0; \
         \
         for(arrLoop = 0; arrLoop < array_size; arrLoop++) \
         { \
             if('\0' == globals.mCommandLineOptions.m##option_name[arrLoop][0]) \
             { \
                 break; \
             } \
         }\
         \
         if(arrLoop != array_size) \
         { \
             PR_snprintf(globals.mCommandLineOptions.m##option_name[arrLoop], sizeof(globals.mCommandLineOptions.m##option_name[arrLoop]), "%s", option + strlen(#option_name "=")); \
         } \
         else \
         { \
             REPORT_ERROR_MSG(__LINE__, option); \
             retval = __LINE__; \
             globals.mCommandLineOptions.mHelp = PR_TRUE; \
         } \
     }
 #define ST_CMD_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help) \
     else if(0 == strncasecmp(option, #option_name "=", strlen(#option_name "="))) \
     { \
         const char** expand = NULL; \
         \
         expand = (const char**)realloc((void*)globals.mCommandLineOptions.m##option_name, sizeof(const char*) * (globals.mCommandLineOptions.m##option_name##Count + 1)); \
         if(NULL != expand) \
         { \
             globals.mCommandLineOptions.m##option_name = expand; \
             globals.mCommandLineOptions.m##option_name[globals.mCommandLineOptions.m##option_name##Count] = option + strlen(#option_name "="); \
             globals.mCommandLineOptions.m##option_name##Count++; \
         } \
         else \
         { \
             retval = __LINE__; \
             globals.mCommandLineOptions.mHelp = PR_TRUE; \
         } \
     }
 #define ST_CMD_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     else if(0 == strncasecmp(option, #option_name "=", strlen(#option_name "="))) \
     { \
         int32_t scanRes = 0; \
         \
         scanRes = PR_sscanf(option + strlen(#option_name "="), "%u", &globals.mCommandLineOptions.m##option_name); \
         if(1 != scanRes) \
         { \
             REPORT_ERROR_MSG(__LINE__, option); \
             retval = __LINE__; \
             globals.mCommandLineOptions.mHelp = PR_TRUE; \
         } \
     }
 #define ST_CMD_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     else if(0 == strncasecmp(option, #option_name "=", strlen(#option_name "="))) \
     { \
         int32_t scanRes = 0; \
         \
         scanRes = PR_sscanf(option + strlen(#option_name "="), "%llu", &globals.mCommandLineOptions.m##option_name##64); \
         if(1 != scanRes) \
         { \
             REPORT_ERROR_MSG(__LINE__, option); \
             retval = __LINE__; \
             globals.mCommandLineOptions.mHelp = PR_TRUE; \
         } \
     }
 #include "stoptions.h"
             /*
              **  If no match on options, this else will get hit.
              */
             else {
                 REPORT_ERROR_MSG(__LINE__, option);
                 retval = __LINE__;
                 globals.mCommandLineOptions.mHelp = PR_TRUE;
             }
         }
         else if ('-' == aArgArray[traverse][0]
                  && '\0' != aArgArray[traverse][1]) {
             /*
              **  Show help, bad/legacy option.
              */
             REPORT_ERROR_MSG(__LINE__, aArgArray[traverse]);
             retval = __LINE__;
             globals.mCommandLineOptions.mHelp = PR_TRUE;
         }
         else {
             /*
              ** Default is same as FileName option, the file to process.
              */
             PR_snprintf(globals.mCommandLineOptions.mFileName,
                         sizeof(globals.mCommandLineOptions.mFileName), "%s",
                         aArgArray[traverse]);
         }
     }
     /*
      ** initialize the categories
      */
     initCategories(&globals);
     return retval;
 }
 #if ST_WANT_GRAPHS
 /*
 ** createGraph
 **
 ** Create a GD image with the common properties of a graph.
 ** Upon return, you normally allocate legend colors,
 **  draw your graph inside the region
 **  STGD_MARGIN,STGD_MARGIN,STGD_WIDTH-STGD_MARGIN,STGD_HEIGH-STGD_MARGIN,
 **  and then call drawGraph to format the surrounding information.
 **
 ** You should use the normal GD image release function, gdImageDestroy
 **  when done with it.
 **
 ** Image attributes:
 **   STGD_WIDTHxSTGD_HEIGHT
 **   trasparent (white) background
 **   incremental display
 */
 gdImagePtr
 createGraph(int *aTransparencyColor)
 {
     gdImagePtr retval = NULL;
     if (NULL != aTransparencyColor) {
         *aTransparencyColor = -1;
         retval = gdImageCreate(STGD_WIDTH, STGD_HEIGHT);
         if (NULL != retval) {
             /*
              ** Background color (first one).
              */
             *aTransparencyColor = gdImageColorAllocate(retval, 255, 255, 255);
             if (-1 != *aTransparencyColor) {
                 /*
                  ** As transparency.
                  */
                 gdImageColorTransparent(retval, *aTransparencyColor);
             }
             /*
              ** And to set interlacing.
              */
             gdImageInterlace(retval, 1);
         }
         else {
             REPORT_ERROR(__LINE__, gdImageCreate);
         }
     }
     else {
         REPORT_ERROR(__LINE__, createGraph);
     }
     return retval;
 }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
 /*
 ** drawGraph
 **
 ** This function mainly exists to simplify putitng all the pretty lace
 **  around a home made graph.
 */
 void
 drawGraph(gdImagePtr aImage, int aColor,
           const char *aGraphTitle,
           const char *aXAxisTitle,
           const char *aYAxisTitle,
           uint32_t aXMarkCount,
           uint32_t * aXMarkPercents,
           const char **aXMarkTexts,
           uint32_t aYMarkCount,
           uint32_t * aYMarkPercents,
           const char **aYMarkTexts,
           uint32_t aLegendCount,
           int *aLegendColors, const char **aLegendTexts)
 {
     if (NULL != aImage && NULL != aGraphTitle &&
         NULL != aXAxisTitle && NULL != aYAxisTitle &&
         (0 == aXMarkCount || (NULL != aXMarkPercents && NULL != aXMarkTexts))
         && (0 == aYMarkCount
             || (NULL != aYMarkPercents && NULL != aYMarkTexts))
         && (0 == aLegendCount
             || (NULL != aLegendColors && NULL != aLegendTexts))) {
         int margin = 1;
         uint32_t traverse = 0;
         uint32_t target = 0;
         const int markSize = 2;
         int x1 = 0;
         int y1 = 0;
         int x2 = 0;
         int y2 = 0;
         time_t theTimeT = time(NULL);
         char *theTime = ctime(&theTimeT);
         const char *logo = "SpaceTrace";
         gdFontPtr titleFont = gdFontMediumBold;
         gdFontPtr markFont = gdFontTiny;
         gdFontPtr dateFont = gdFontTiny;
         gdFontPtr axisFont = gdFontSmall;
         gdFontPtr legendFont = gdFontTiny;
         gdFontPtr logoFont = gdFontTiny;
         /*
          ** Fixup the color.
          ** Black by default.
          */
         if (-1 == aColor) {
             aColor = gdImageColorAllocate(aImage, 0, 0, 0);
         }
         if (-1 == aColor) {
             aColor = gdImageColorClosest(aImage, 0, 0, 0);
         }
         /*
          ** Output the box.
          */
         x1 = STGD_MARGIN - margin;
         y1 = STGD_MARGIN - margin;
         x2 = STGD_WIDTH - x1;
         y2 = STGD_HEIGHT - y1;
         gdImageRectangle(aImage, x1, y1, x2, y2, aColor);
         margin++;
         /*
          ** Need to make small markings on the graph to indicate where the
          **  labels line up exactly.
          ** While we're at it, draw the label text.
          */
         for (traverse = 0; traverse < aXMarkCount; traverse++) {
             target =
                 ((STGD_WIDTH -
                   (STGD_MARGIN * 2)) * aXMarkPercents[traverse]) / 100;
             x1 = STGD_MARGIN + target;
             y1 = STGD_MARGIN - margin;
             x2 = x1;
             y2 = y1 - markSize;
             gdImageLine(aImage, x1, y1, x2, y2, aColor);
             y1 = STGD_HEIGHT - y1;
             y2 = STGD_HEIGHT - y2;
             gdImageLine(aImage, x1, y1, x2, y2, aColor);
             if (NULL != aXMarkTexts[traverse]) {
                 x1 = STGD_MARGIN + target - (markFont->h / 2);
                 y1 = STGD_HEIGHT - STGD_MARGIN + margin + markSize +
                     (strlen(aXMarkTexts[traverse]) * markFont->w);
                 gdImageStringUp(aImage, markFont, x1, y1,
                                 (unsigned char *) aXMarkTexts[traverse],
                                 aColor);
             }
         }
         for (traverse = 0; traverse < aYMarkCount; traverse++) {
             target =
                 ((STGD_HEIGHT - (STGD_MARGIN * 2)) * (100 -
                                                       aYMarkPercents
                                                       [traverse])) / 100;
             x1 = STGD_MARGIN - margin;
             y1 = STGD_MARGIN + target;
             x2 = x1 - markSize;
             y2 = y1;
             gdImageLine(aImage, x1, y1, x2, y2, aColor);
             x1 = STGD_WIDTH - x1;
             x2 = STGD_WIDTH - x2;
             gdImageLine(aImage, x1, y1, x2, y2, aColor);
             if (NULL != aYMarkTexts[traverse]) {
                 x1 = STGD_MARGIN - margin - markSize -
                     (strlen(aYMarkTexts[traverse]) * markFont->w);
                 y1 = STGD_MARGIN + target - (markFont->h / 2);
                 gdImageString(aImage, markFont, x1, y1,
                               (unsigned char *) aYMarkTexts[traverse],
                               aColor);
             }
         }
         margin += markSize;
         /*
          ** Title will be centered above the image.
          */
         x1 = (STGD_WIDTH / 2) - ((strlen(aGraphTitle) * titleFont->w) / 2);
         y1 = ((STGD_MARGIN - margin) / 2) - (titleFont->h / 2);
         gdImageString(aImage, titleFont, x1, y1,
                       (unsigned char *) aGraphTitle, aColor);
         /*
          ** Upper left will be the date.
          */
         x1 = 0;
         y1 = 0;
         traverse = strlen(theTime) - 1;
         if (isspace(theTime[traverse])) {
             theTime[traverse] = '\0';
         }
         gdImageString(aImage, dateFont, x1, y1, (unsigned char *) theTime,
                       aColor);
         /*
          ** Lower right will be the logo.
          */
         x1 = STGD_WIDTH - (strlen(logo) * logoFont->w);
         y1 = STGD_HEIGHT - logoFont->h;
         gdImageString(aImage, logoFont, x1, y1, (unsigned char *) logo,
                       aColor);
         /*
          ** X and Y axis titles
          */
         x1 = (STGD_WIDTH / 2) - ((strlen(aXAxisTitle) * axisFont->w) / 2);
         y1 = STGD_HEIGHT - axisFont->h;
         gdImageString(aImage, axisFont, x1, y1, (unsigned char *) aXAxisTitle,
                       aColor);
         x1 = 0;
         y1 = (STGD_HEIGHT / 2) + ((strlen(aYAxisTitle) * axisFont->w) / 2);
         gdImageStringUp(aImage, axisFont, x1, y1,
                         (unsigned char *) aYAxisTitle, aColor);
         /*
          ** The legend.
          ** Centered on the right hand side, going up.
          */
         x1 = STGD_WIDTH - STGD_MARGIN + margin +
             (aLegendCount * legendFont->h) / 2;
         x2 = STGD_WIDTH - (aLegendCount * legendFont->h);
         if (x1 > x2) {
             x1 = x2;
         }
         y1 = 0;
         for (traverse = 0; traverse < aLegendCount; traverse++) {
             y2 = (STGD_HEIGHT / 2) +
                 ((strlen(aLegendTexts[traverse]) * legendFont->w) / 2);
             if (y2 > y1) {
                 y1 = y2;
             }
         }
         for (traverse = 0; traverse < aLegendCount; traverse++) {
             gdImageStringUp(aImage, legendFont, x1, y1,
                             (unsigned char *) aLegendTexts[traverse],
                             aLegendColors[traverse]);
             x1 += legendFont->h;
         }
     }
 }
 #endif /* ST_WANT_GRAPHS */
 #if defined(HAVE_BOUTELL_GD)
 /*
 ** pngSink
 **
 ** GD callback, used to write out the png.
 */
 int
 pngSink(void *aContext, const char *aBuffer, int aLen)
 {
     return PR_Write((PRFileDesc *) aContext, aBuffer, aLen);
 }
 #endif /* HAVE_BOUTELL_GD */
 /*
 ** FormatNumber
 **
 ** Formats a number with thousands separator. Don't free the result. Returns
 ** static data.
 */
 char *
 FormatNumber(int32_t num)
 {
     static char buf[64];
     char tmpbuf[64];
     int len = 0;
     int bufindex = sizeof(buf) - 1;
     int mod3;
     PR_snprintf(tmpbuf, sizeof(tmpbuf), "%d", num);
     /* now insert the thousands separator */
     mod3 = 0;
     len = strlen(tmpbuf);
     while (len >= 0) {
         if (tmpbuf[len] >= '0' && tmpbuf[len] <= '9') {
             if (mod3 == 3) {
                 buf[bufindex--] = ',';
                 mod3 = 0;
             }
             mod3++;
         }
         buf[bufindex--] = tmpbuf[len--];
     }
     return buf + bufindex + 1;
 }
 /*
 ** actualByteSize
 **
 ** Apply alignment and overhead to size to figure out actual byte size
 */
 uint32_t
 actualByteSize(STOptions * inOptions, uint32_t retval)
 {
     /*
      ** Need to bump the result by our alignment and overhead.
      ** The idea here is that an allocation actually costs you more than you
      **  thought.
      **
      ** The msvcrt malloc has an alignment of 16 with an overhead of 8.
      ** The win32 HeapAlloc has an alignment of 8 with an overhead of 8.
      */
     if (0 != retval) {
         uint32_t eval = 0;
         uint32_t over = 0;
         eval = retval - 1;
         if (0 != inOptions->mAlignBy) {
             over = eval % inOptions->mAlignBy;
         }
         retval = eval + inOptions->mOverhead + inOptions->mAlignBy - over;
     }
     return retval;
 }
 /*
 ** byteSize
 **
 ** Figuring the byte size of an allocation.
 ** Might expand in the future to report size at a given time.
 ** For now, just use last relevant event.
 */
 uint32_t
 byteSize(STOptions * inOptions, STAllocation * aAlloc)
 {
     uint32_t retval = 0;
     if (NULL != aAlloc && 0 != aAlloc->mEventCount) {
         uint32_t index = aAlloc->mEventCount;
         /*
          ** Generally, the size is the last event's size.
          */
         do {
             index--;
             retval = aAlloc->mEvents[index].mHeapSize;
         }
         while (0 == retval && 0 != index);
     }
     return actualByteSize(inOptions, retval);
 }
 /*
 ** recalculateAllocationCost
 **
 ** Given an allocation, does a recalculation of Cost - weight, heapcount etc.
 ** and does the right thing to propagate the cost upwards.
 */
 int
 recalculateAllocationCost(STOptions * inOptions, STContext * inContext,
                           STRun * aRun, STAllocation * aAllocation,
                           PRBool updateParent)
 {
     /*
      ** Now, see if they desire a callsite update.
      ** As mentioned previously, we decide if the run desires us to
      **  manipulate the callsite data only if its stamp is set.
      ** We change all callsites and parent callsites to have that
      **  stamp as well, so as to mark them as being relevant to
      **  the current run in question.
      */
     if (NULL != inContext && 0 != aRun->mStats[inContext->mIndex].mStamp) {
         uint32_t timeval =
             aAllocation->mMaxTimeval - aAllocation->mMinTimeval;
         uint32_t size = byteSize(inOptions, aAllocation);
         uint32_t heapCost = aAllocation->mHeapRuntimeCost;
         uint64_t timeval64 = timeval;
         uint64_t size64 = size;
         uint64_t weight64 = timeval64 * size64;
         /*
          ** First, update this run.
          */
         aRun->mStats[inContext->mIndex].mCompositeCount++;
         aRun->mStats[inContext->mIndex].mHeapRuntimeCost += heapCost;
         aRun->mStats[inContext->mIndex].mSize += size;
         aRun->mStats[inContext->mIndex].mTimeval64 += timeval64;
         aRun->mStats[inContext->mIndex].mWeight64 += weight64;
         /*
          ** Use the first event of the allocation to update the parent
          **  callsites.
          ** This has positive effect of not updating realloc callsites
          **  with the same data over and over again.
          */
         if (updateParent && 0 < aAllocation->mEventCount) {
             tmcallsite *callsite = aAllocation->mEvents[0].mCallsite;
             STRun *callsiteRun = NULL;
             /*
              ** Go up parents till we drop.
              */
             while (NULL != callsite && NULL != callsite->method) {
                 callsiteRun = CALLSITE_RUN(callsite);
                 if (NULL != callsiteRun) {
                     /*
                      ** Do we init it?
                      */
                     if (callsiteRun->mStats[inContext->mIndex].mStamp !=
                         aRun->mStats[inContext->mIndex].mStamp) {
                         memset(&callsiteRun->mStats[inContext->mIndex], 0,
                                sizeof(STCallsiteStats));
                         callsiteRun->mStats[inContext->mIndex].mStamp =
                             aRun->mStats[inContext->mIndex].mStamp;
                     }
                     /*
                      ** Add the values.
                      ** Note that if the allocation was ever realloced,
                      **  we are actually recording the final size.
                      ** Also, the composite count does not include
                      **  calls to realloc (or free for that matter),
                      **  but rather is simply a count of actual heap
                      **  allocation objects, from which someone will
                      **  draw conclusions regarding number of malloc
                      **  and free calls.
                      ** It is possible to generate the exact number
                      **  of calls to free/malloc/realloc should the
                      **  absolute need arise to count them individually,
                      **  but I fear it will take mucho memory and this
                      **  is perhaps good enough for now.
                      */
                     callsiteRun->mStats[inContext->mIndex].mCompositeCount++;
                     callsiteRun->mStats[inContext->mIndex].mHeapRuntimeCost +=
                         heapCost;
                     callsiteRun->mStats[inContext->mIndex].mSize += size;
                     callsiteRun->mStats[inContext->mIndex].mTimeval64 +=
                         timeval64;
                     callsiteRun->mStats[inContext->mIndex].mWeight64 +=
                         weight64;
                 }
                 callsite = callsite->parent;
             }
         }
     }
     return 0;
 }
 /*
 ** appendAllocation
 **
 ** Given a run, append the allocation to it.
 ** No DUP checks are done.
 ** Also, we might want to update the parent callsites with stats.
 ** We decide to do this heavy duty work only if the run we are appending
 **  to has a non ZERO mStats[].mStamp, meaning that it is asking to track
 **  such information when it was created.
 ** Returns !0 on success.
 */
 int
 appendAllocation(STOptions * inOptions, STContext * inContext,
                  STRun * aRun, STAllocation * aAllocation)
 {
     int retval = 0;
     if (NULL != aRun && NULL != aAllocation && NULL != inOptions) {
         STAllocation **expand = NULL;
         /*
          ** Expand the size of the array if needed.
          */
         expand = (STAllocation **) realloc(aRun->mAllocations,
                                            sizeof(STAllocation *) *
                                            (aRun->mAllocationCount + 1));
         if (NULL != expand) {
             /*
              ** Reassign in case of pointer move.
              */
             aRun->mAllocations = expand;
             /*
              ** Stick the allocation in.
              */
             aRun->mAllocations[aRun->mAllocationCount] = aAllocation;
             /*
              ** If this is the global run, we need to let the allocation
              **  track the index back to us.
              */
             if (&globals.mRun == aRun) {
                 aAllocation->mRunIndex = aRun->mAllocationCount;
             }
             /*
              ** Increase the count.
              */
             aRun->mAllocationCount++;
             /*
              ** We're good.
              */
             retval = __LINE__;
             /*
              ** update allocation cost
              */
             recalculateAllocationCost(inOptions, inContext, aRun, aAllocation,
                                       PR_TRUE);
         }
         else {
             REPORT_ERROR(__LINE__, appendAllocation);
         }
     }
     else {
         REPORT_ERROR(__LINE__, appendAllocation);
     }
     return retval;
 }
 /*
 ** hasCallsiteMatch
 **
 ** Determine if the callsite or the other callsites has the matching text.
 **
 ** Returns 0 if there is no match.
 */
 int
 hasCallsiteMatch(tmcallsite * aCallsite, const char *aMatch, int aDirection)
 {
     int retval = 0;
     if (NULL != aCallsite && NULL != aCallsite->method &&
         NULL != aMatch && '\0' != *aMatch) {
         const char *methodName = NULL;
         do {
             methodName = tmmethodnode_name(aCallsite->method);
             if (NULL != methodName && NULL != strstr(methodName, aMatch)) {
                 /*
                  ** Contains the text.
                  */
                 retval = __LINE__;
                 break;
             }
             else {
                 switch (aDirection) {
                 case ST_FOLLOW_SIBLINGS:
                     aCallsite = aCallsite->siblings;
                     break;
                 case ST_FOLLOW_PARENTS:
                     aCallsite = aCallsite->parent;
                     break;
                 default:
                     aCallsite = NULL;
                     REPORT_ERROR(__LINE__, hasCallsiteMatch);
                     break;
                 }
             }
         }
         while (NULL != aCallsite && NULL != aCallsite->method);
     }
     else {
         REPORT_ERROR(__LINE__, hasCallsiteMatch);
     }
     return retval;
 }
 /*
 ** harvestRun
 **
 ** Provide a simply way to go over a run, and yield the relevant allocations.
 ** The restrictions are easily set via the options page or the command
 **  line switches.
 **
 ** On any match, add the allocation to the provided run.
 **
 ** This makes it much easier for all the code to respect the options in
 **  force.
 **
 ** Returns !0 on error, though aOutRun may contain a partial data set.
 */
 int
 harvestRun(const STRun * aInRun, STRun * aOutRun,
            STOptions * aOptions, STContext * inContext)
 {
     int retval = 0;
 #if defined(DEBUG_dp)
     PRIntervalTime start = PR_IntervalNow();
     fprintf(stderr, "DEBUG: harvesting run...\n");
 #endif
     if (NULL != aInRun && NULL != aOutRun && aInRun != aOutRun
         && NULL != aOptions && NULL != inContext) {
         uint32_t traverse = 0;
         STAllocation *current = NULL;
         for (traverse = 0;
 == retval && traverse < aInRun->mAllocationCount; traverse++) {
             current = aInRun->mAllocations[traverse];
             if (NULL != current) {
                 uint32_t lifetime = 0;
                 uint32_t bytesize = 0;
                 uint64_t weight64 = 0;
                 uint64_t bytesize64 = 0;
                 uint64_t lifetime64 = 0;
                 int appendRes = 0;
                 int looper = 0;
                 PRBool matched = PR_FALSE;
                 /*
                  ** Use this as an opportune time to fixup a memory
                  **  leaked timeval, so as to not completely skew
                  **  the weights.
                  */
                 if (ST_TIMEVAL_MAX == current->mMaxTimeval) {
                     current->mMaxTimeval = globals.mMaxTimeval;
                 }
                 /*
                  ** Check allocation timeval restrictions.
                  ** We have to slide the recorded timevals to be zero
                  **  based, so that the comparisons make sense.
                  */
                 if ((aOptions->mAllocationTimevalMin >
                      (current->mMinTimeval - globals.mMinTimeval)) ||
                     (aOptions->mAllocationTimevalMax <
                      (current->mMinTimeval - globals.mMinTimeval))) {
                     continue;
                 }
                 /*
                  ** Check timeval restrictions.
                  ** We have to slide the recorded timevals to be zero
                  **  based, so that the comparisons make sense.
                  */
                 if ((aOptions->mTimevalMin >
                      (current->mMinTimeval - globals.mMinTimeval)) ||
                     (aOptions->mTimevalMax <
                      (current->mMinTimeval - globals.mMinTimeval))) {
                     continue;
                 }
                 /*
                  ** Check lifetime restrictions.
                  */
                 lifetime = current->mMaxTimeval - current->mMinTimeval;
                 if ((lifetime < aOptions->mLifetimeMin) ||
                     (lifetime > aOptions->mLifetimeMax)) {
                     continue;
                 }
                 /*
                  ** Check byte size restrictions.
                  */
                 bytesize = byteSize(aOptions, current);
                 if ((bytesize < aOptions->mSizeMin) ||
                     (bytesize > aOptions->mSizeMax)) {
                     continue;
                 }
                 /*
                  ** Check weight restrictions.
                  */
                 weight64 = (uint64_t)(bytesize * lifetime);
                 if (weight64 < aOptions->mWeightMin64 ||
                     weight64 > aOptions->mWeightMax64) {
                     continue;
                 }
                 /*
                  ** Possibly restrict the callsite by text.
                  ** Do this last, as it is a heavier check.
                  **
                  ** One day, we may need to expand the logic to check for
                  **  events beyond the initial allocation event.
                  */
                 for (looper = 0; ST_SUBSTRING_MATCH_MAX > looper; looper++) {
                     if ('\0' != aOptions->mRestrictText[looper][0]) {
                         if (0 ==
                             hasCallsiteMatch(current->mEvents[0].mCallsite,
                                              aOptions->mRestrictText[looper],
                                              ST_FOLLOW_PARENTS)) {
                             break;
                         }
                     }
                     else {
                         matched = PR_TRUE;
                         break;
                     }
                 }
                 if (ST_SUBSTRING_MATCH_MAX == looper) {
                     matched = PR_TRUE;
                 }
                 if (PR_FALSE == matched) {
                     continue;
                 }
                 /*
                  ** You get here, we add to the run.
                  */
                 appendRes =
                     appendAllocation(aOptions, inContext, aOutRun, current);
                 if (0 == appendRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, appendAllocation);
                 }
             }
         }
     }
 #if defined(DEBUG_dp)
     fprintf(stderr, "DEBUG: harvesting ends: %dms [%d allocations]\n",
             PR_IntervalToMilliseconds(PR_IntervalNow() - start),
             aInRun->mAllocationCount);
 #endif
     return retval;
 }
 /*
 ** recalculateRunCost
 **
 ** Goes over all allocations of a run and recalculates and propagates
 ** the allocation costs - weight, heapcount, size
 */
 int
 recalculateRunCost(STOptions * inOptions, STContext * inContext, STRun * aRun)
 {
     uint32_t traverse = 0;
     STAllocation *current = NULL;
 #if defined(DEBUG_dp)
     PRIntervalTime start = PR_IntervalNow();
     fprintf(stderr, "DEBUG: recalculateRunCost...\n");
 #endif
     if (NULL == aRun)
         return -1;
     /* reset stats of this run to 0 to begin recalculation */
     memset(&aRun->mStats[inContext->mIndex], 0, sizeof(STCallsiteStats));
     /* reset timestamp to force propogation of cost */
     aRun->mStats[inContext->mIndex].mStamp = PR_IntervalNow();
     for (traverse = 0; traverse < aRun->mAllocationCount; traverse++) {
         current = aRun->mAllocations[traverse];
         if (NULL != current) {
             recalculateAllocationCost(inOptions, inContext, aRun, current,
                                       PR_TRUE);
         }
     }
 #if defined(DEBUG_dp)
     fprintf(stderr, "DEBUG: recalculateRunCost ends: %dms [%d allocations]\n",
             PR_IntervalToMilliseconds(PR_IntervalNow() - start),
             aRun->mAllocationCount);
 #endif
     return 0;
 }
 /*
 ** compareAllocations
 **
 ** qsort callback.
 ** Compare the allocations as specified by the options.
 */
 int
 compareAllocations(const void *aAlloc1, const void *aAlloc2, void *aContext)
 {
     int retval = 0;
     STOptions *inOptions = (STOptions *) aContext;
     if (NULL != aAlloc1 && NULL != aAlloc2 && NULL != inOptions) {
         STAllocation *alloc1 = *((STAllocation **) aAlloc1);
         STAllocation *alloc2 = *((STAllocation **) aAlloc2);
         if (NULL != alloc1 && NULL != alloc2) {
             /*
              ** Logic determined by pref/option.
              */
             switch (inOptions->mOrderBy) {
             case ST_COUNT:
                 /*
                  ** "By count" on a single allocation means nothing,
                  **  fall through to weight.
                  */
             case ST_WEIGHT:
                 {
                     uint64_t weight164 = 0;
                     uint64_t weight264 = 0;
                     uint64_t bytesize164 = 0;
                     uint64_t bytesize264 = 0;
                     uint64_t timeval164 = 0;
                     uint64_t timeval264 = 0;
                     bytesize164 = byteSize(inOptions, alloc1);
                     timeval164 = alloc1->mMaxTimeval - alloc1->mMinTimeval;
                     weight164 = bytesize164 * timeval164;
                     bytesize264 = byteSize(inOptions, alloc2);
                     timeval264 = alloc2->mMaxTimeval - alloc2->mMinTimeval;
                     weight264 = bytesize264 * timeval264;
                     if (weight164 < weight264) {
                         retval = __LINE__;
                     }
                     else if (weight164 > weight264) {
                         retval = -__LINE__;
                     }
                 }
                 break;
             case ST_SIZE:
                 {
                     uint32_t size1 = byteSize(inOptions, alloc1);
                     uint32_t size2 = byteSize(inOptions, alloc2);
                     if (size1 < size2) {
                         retval = __LINE__;
                     }
                     else if (size1 > size2) {
                         retval = -__LINE__;
                     }
                 }
                 break;
             case ST_TIMEVAL:
                 {
                     uint32_t timeval1 =
                         (alloc1->mMaxTimeval - alloc1->mMinTimeval);
                     uint32_t timeval2 =
                         (alloc2->mMaxTimeval - alloc2->mMinTimeval);
                     if (timeval1 < timeval2) {
                         retval = __LINE__;
                     }
                     else if (timeval1 > timeval2) {
                         retval = -__LINE__;
                     }
                 }
                 break;
             case ST_HEAPCOST:
                 {
                     uint32_t cost1 = alloc1->mHeapRuntimeCost;
                     uint32_t cost2 = alloc2->mHeapRuntimeCost;
                     if (cost1 < cost2) {
                         retval = __LINE__;
                     }
                     else if (cost1 > cost2) {
                         retval = -__LINE__;
                     }
                 }
                 break;
             default:
                 {
                     REPORT_ERROR(__LINE__, compareAllocations);
                 }
                 break;
             }
         }
     }
     return retval;
 }
 /*
 ** sortRun
 **
 ** Given a run, sort it in the manner specified by the options.
 ** Returns !0 on failure.
 */
 int
 sortRun(STOptions * inOptions, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun && NULL != inOptions) {
         if (NULL != aRun->mAllocations && 0 < aRun->mAllocationCount) {
             NS_QuickSort(aRun->mAllocations, aRun->mAllocationCount,
                          sizeof(STAllocation *), compareAllocations,
                          inOptions);
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, sortRun);
     }
     return retval;
 }
 /*
 ** createRun
 **
 ** Returns a newly allocated run, properly initialized.
 ** Must call freeRun() with the new STRun.
 **
 ** ONLY PASS IN A NON_ZERO STAMP IF YOU KNOW WHAT YOU ARE DOING!!!
 ** A non zero stamp in a run has side effects all over the
 **  callsites of the allocations added to the run and their
 **  parents.
 **
 ** Returns NULL on failure.
 */
 STRun *
 createRun(STContext * inContext, uint32_t aStamp)
 {
     STRun *retval = NULL;
     retval = (STRun *) calloc(1, sizeof(STRun));
     if (NULL != retval) {
         retval->mStats =
             (STCallsiteStats *) calloc(globals.mCommandLineOptions.mContexts,
                                        sizeof(STCallsiteStats));
         if (NULL != retval->mStats) {
             if (NULL != inContext) {
                 retval->mStats[inContext->mIndex].mStamp = aStamp;
             }
         }
         else {
             free(retval);
             retval = NULL;
         }
     }
     return retval;
 }
 /*
 ** freeRun
 **
 ** Free off the run and the associated data.
 */
 void
 freeRun(STRun * aRun)
 {
     if (NULL != aRun) {
         if (NULL != aRun->mAllocations) {
             /*
              ** We do not free the allocations themselves.
              ** They are likely pointed to by at least 2 other existing
              **  runs.
              */
             free(aRun->mAllocations);
             aRun->mAllocations = NULL;
         }
         if (NULL != aRun->mStats) {
             free(aRun->mStats);
             aRun->mStats = NULL;
         }
         free(aRun);
         aRun = NULL;
     }
 }
 /*
 ** createRunFromGlobal
 **
 ** Harvest the global run, then sort it.
 ** Returns NULL on failure.
 ** Must call freeRun() with the new STRun.
 */
 STRun *
 createRunFromGlobal(STOptions * inOptions, STContext * inContext)
 {
     STRun *retval = NULL;
     if (NULL != inOptions && NULL != inContext) {
         /*
          ** We stamp the run.
          ** As things are appended to it, it realizes that it should stamp the
          **  callsite backtrace with the information as well.
          ** In this manner, we can provide meaningful callsite data.
          */
         retval = createRun(inContext, PR_IntervalNow());
         if (NULL != retval) {
             STCategoryNode *node = NULL;
             int failure = 0;
             int harvestRes =
                 harvestRun(&globals.mRun, retval, inOptions, inContext);
             if (0 == harvestRes) {
                 int sortRes = sortRun(inOptions, retval);
                 if (0 != sortRes) {
                     failure = __LINE__;
                 }
             }
             else {
                 failure = __LINE__;
             }
             if (0 != failure) {
                 freeRun(retval);
                 retval = NULL;
                 REPORT_ERROR(failure, createRunFromGlobal);
             }
             /*
              ** Categorize the run.
              */
             failure = categorizeRun(inOptions, inContext, retval, &globals);
             if (0 != failure) {
                 REPORT_ERROR(__LINE__, categorizeRun);
             }
             /*
              ** if we are focussing on a category, return that run instead of
              ** the harvested run. Make sure to recalculate cost.
              */
             node = findCategoryNode(inOptions->mCategoryName, &globals);
             if (node) {
                 /* Recalculate cost of run */
                 recalculateRunCost(inOptions, inContext,
                                    node->runs[inContext->mIndex]);
                 retval = node->runs[inContext->mIndex];
             }
         }
     }
     else {
         REPORT_ERROR(__LINE__, createRunFromGlobal);
     }
     return retval;
 }
 /*
 ** getLiveAllocationByHeapID
 **
 ** Go through a run and find the right heap ID.
 ** At the time of the call to this function, the allocation must be LIVE,
 **   meaning that it can not be freed.
 ** Go through the run backwards, in hopes of finding it near the end.
 **
 ** Returns the allocation on success, otherwise NULL.
 */
 STAllocation *
 getLiveAllocationByHeapID(STRun * aRun, uint32_t aHeapID)
 {
     STAllocation *retval = NULL;
     if (NULL != aRun && 0 != aHeapID) {
         uint32_t traverse = aRun->mAllocationCount;
         STAllocation *eval = NULL;
         /*
          ** Go through in reverse order.
          ** Stop when we have a return value.
          */
         while (0 < traverse && NULL == retval) {
             /*
              ** Back up one to align with zero based index.
              */
             traverse--;
             /*
              ** Take the pointer math out of further operations.
              */
             eval = aRun->mAllocations[traverse];
             /*
              ** Take a look at the events in reverse order.
              ** Basically the last event must NOT be a free.
              ** The last event must NOT be a realloc of size zero (free).
              ** Otherwise, try to match up the heapID of the event.
              */
             if (0 != eval->mEventCount) {
                 STAllocEvent *event = eval->mEvents + (eval->mEventCount - 1);
                 switch (event->mEventType) {
                 case TM_EVENT_FREE:
                     {
                         /*
                          ** No freed allocation can match.
                          */
                     }
                     break;
                 case TM_EVENT_REALLOC:
                 case TM_EVENT_CALLOC:
                 case TM_EVENT_MALLOC:
                     {
                         /*
                          ** Heap IDs must match.
                          */
                         if (aHeapID == event->mHeapID) {
                             retval = eval;
                         }
                     }
                     break;
                 default:
                     {
                         REPORT_ERROR(__LINE__, getAllocationByHeapID);
                     }
                     break;
                 }
             }
         }
     }
     else {
         REPORT_ERROR(__LINE__, getAllocationByHeapID);
     }
     return retval;
 }
 /*
 ** appendEvent
 **
 ** Given an allocation, append a new event to its lifetime.
 ** Returns the new event on success, otherwise NULL.
 */
 STAllocEvent *
 appendEvent(STAllocation * aAllocation, uint32_t aTimeval, char aEventType,
             uint32_t aHeapID, uint32_t aHeapSize, tmcallsite * aCallsite)
 {
     STAllocEvent *retval = NULL;
     if (NULL != aAllocation && NULL != aCallsite) {
         STAllocEvent *expand = NULL;
         /*
          ** Expand the allocation's event array.
          */
         expand =
             (STAllocEvent *) realloc(aAllocation->mEvents,
                                      sizeof(STAllocEvent) *
                                      (aAllocation->mEventCount + 1));
         if (NULL != expand) {
             /*
              ** Reassign in case of pointer move.
              */
             aAllocation->mEvents = expand;
             /*
              ** Remove the pointer math from rest of code.
              */
             retval = aAllocation->mEvents + aAllocation->mEventCount;
             /*
              ** Increase event array count.
              */
             aAllocation->mEventCount++;
             /*
              ** Fill in the event.
              */
             retval->mTimeval = aTimeval;
             retval->mEventType = aEventType;
             retval->mHeapID = aHeapID;
             retval->mHeapSize = aHeapSize;
             retval->mCallsite = aCallsite;
             /*
              ** Allocation may need to update idea of lifetime.
              ** See allocationTracker to see mMinTimeval inited to ST_TIMEVAL_MAX.
              */
             if (aAllocation->mMinTimeval > aTimeval) {
                 aAllocation->mMinTimeval = aTimeval;
             }
             /*
              ** This a free event?
              ** Can only set max timeval on a free.
              ** Otherwise, mMaxTimeval remains  ST_TIMEVAL_MAX.
              ** Set in allocationTracker.
              */
             if (TM_EVENT_FREE == aEventType) {
                 aAllocation->mMaxTimeval = aTimeval;
             }
         }
         else {
             REPORT_ERROR(__LINE__, appendEvent);
         }
     }
     else {
         REPORT_ERROR(__LINE__, appendEvent);
     }
     return retval;
 }
 /*
 ** hasAllocation
 **
 ** Determine if a given run has an allocation.
 ** This is really nothing more than a pointer comparison loop.
 ** Returns !0 if the run has the allocation.
 */
 int
 hasAllocation(STRun * aRun, STAllocation * aTestFor)
 {
     int retval = 0;
     if (NULL != aRun && NULL != aTestFor) {
         uint32_t traverse = aRun->mAllocationCount;
         /*
          ** Go through reverse, in the hopes it exists nearer the end.
          */
         while (0 < traverse) {
             /*
              ** Back up.
              */
             traverse--;
             if (aTestFor == aRun->mAllocations[traverse]) {
                 retval = __LINE__;
                 break;
             }
         }
     }
     else {
         REPORT_ERROR(__LINE__, hasAllocation);
     }
     return retval;
 }
 /*
 ** allocationTracker
 **
 ** Important to keep track of all allocations unique so as to determine
 **  their lifetimes.
 **
 ** Returns a pointer to the allocation on success.
 ** Return NULL on failure.
 */
 STAllocation *
 allocationTracker(uint32_t aTimeval, char aType, uint32_t aHeapRuntimeCost,
                   tmcallsite * aCallsite, uint32_t aHeapID, uint32_t aSize,
                   tmcallsite * aOldCallsite, uint32_t aOldHeapID,
                   uint32_t aOldSize)
 {
     STAllocation *retval = NULL;
     static int compactor = 1;
     const int frequency = 10000;
     uint32_t actualSize, actualOldSize = 0;
     actualSize = actualByteSize(&globals.mCommandLineOptions, aSize);
     if (aOldSize)
         actualOldSize =
             actualByteSize(&globals.mCommandLineOptions, aOldSize);
     if (NULL != aCallsite) {
         int newAllocation = 0;
         tmcallsite *searchCallsite = NULL;
         uint32_t searchHeapID = 0;
         STAllocation *allocation = NULL;
         /*
          ** Global operation ID increases.
          */
         globals.mOperationCount++;
         /*
          ** Fix up the timevals if needed.
          */
         if (aTimeval < globals.mMinTimeval) {
             globals.mMinTimeval = aTimeval;
         }
         if (aTimeval > globals.mMaxTimeval) {
             globals.mMaxTimeval = aTimeval;
         }
         switch (aType) {
         case TM_EVENT_FREE:
             {
                 /*
                  ** Update the global counter.
                  */
                 globals.mFreeCount++;
                 /*
                  ** Update our peak memory used counter
                  */
                 globals.mMemoryUsed -= actualSize;
                 /*
                  ** Not a new allocation, will need to search passed in site
                  **  for the original allocation.
                  */
                 searchCallsite = aCallsite;
                 searchHeapID = aHeapID;
             }
             break;
         case TM_EVENT_MALLOC:
             {
                 /*
                  ** Update the global counter.
                  */
                 globals.mMallocCount++;
                 /*
                  ** Update our peak memory used counter
                  */
                 globals.mMemoryUsed += actualSize;
                 if (globals.mMemoryUsed > globals.mPeakMemoryUsed) {
                     globals.mPeakMemoryUsed = globals.mMemoryUsed;
                 }
                 /*
                  ** This will be a new allocation.
                  */
                 newAllocation = __LINE__;
             }
             break;
         case TM_EVENT_CALLOC:
             {
                 /*
                  ** Update the global counter.
                  */
                 globals.mCallocCount++;
                 /*
                  ** Update our peak memory used counter
                  */
                 globals.mMemoryUsed += actualSize;
                 if (globals.mMemoryUsed > globals.mPeakMemoryUsed) {
                     globals.mPeakMemoryUsed = globals.mMemoryUsed;
                 }
                 /*
                  ** This will be a new allocation.
                  */
                 newAllocation = __LINE__;
             }
             break;
         case TM_EVENT_REALLOC:
             {
                 /*
                  ** Update the global counter.
                  */
                 globals.mReallocCount++;
                 /*
                  ** Update our peak memory used counter
                  */
                 globals.mMemoryUsed += actualSize - actualOldSize;
                 if (globals.mMemoryUsed > globals.mPeakMemoryUsed) {
                     globals.mPeakMemoryUsed = globals.mMemoryUsed;
                 }
                 /*
                  ** This might be a new allocation.
                  */
                 if (NULL == aOldCallsite) {
                     newAllocation = __LINE__;
                 }
                 else {
                     /*
                      ** Need to search for the original callsite for the
                      **  index to the allocation.
                      */
                     searchCallsite = aOldCallsite;
                     searchHeapID = aOldHeapID;
                 }
             }
             break;
         default:
             {
                 REPORT_ERROR(__LINE__, allocationTracker);
             }
             break;
         }
         /*
          ** We are either modifying an existing allocation or we are creating
          **  a new one.
          */
         if (0 != newAllocation) {
             allocation = (STAllocation *) calloc(1, sizeof(STAllocation));
             if (NULL != allocation) {
                 /*
                  ** Fixup the min timeval so if logic later will just work.
                  */
                 allocation->mMinTimeval = ST_TIMEVAL_MAX;
                 allocation->mMaxTimeval = ST_TIMEVAL_MAX;
             }
         }
         else if (NULL != searchCallsite
                  && NULL != CALLSITE_RUN(searchCallsite)
                  && 0 != searchHeapID) {
             /*
              ** We know what to search for, and we reduce what we search
              **  by only looking for those allocations at a known callsite.
              */
             allocation =
                 getLiveAllocationByHeapID(CALLSITE_RUN(searchCallsite),
                                           searchHeapID);
         }
         else {
             REPORT_ERROR(__LINE__, allocationTracker);
         }
         if (NULL != allocation) {
             STAllocEvent *appendResult = NULL;
             /*
              ** Record the amount of time this allocation event took.
              */
             allocation->mHeapRuntimeCost += aHeapRuntimeCost;
             /*
              ** Now that we have an allocation, we need to make sure it has
              **  the proper event.
              */
             appendResult =
                 appendEvent(allocation, aTimeval, aType, aHeapID, aSize,
                             aCallsite);
             if (NULL != appendResult) {
                 if (0 != newAllocation) {
                     int runAppendResult = 0;
                     int callsiteAppendResult = 0;
                     /*
                      ** A new allocation needs to be added to the global run.
                      ** A new allocation needs to be added to the callsite.
                      */
                     runAppendResult =
                         appendAllocation(&globals.mCommandLineOptions, NULL,
                                          &globals.mRun, allocation);
                     callsiteAppendResult =
                         appendAllocation(&globals.mCommandLineOptions, NULL,
                                          CALLSITE_RUN(aCallsite), allocation);
                     if (0 != runAppendResult && 0 != callsiteAppendResult) {
                         /*
                          ** Success.
                          */
                         retval = allocation;
                     }
                     else {
                         REPORT_ERROR(__LINE__, appendAllocation);
                     }
                 }
                 else {
                     /*
                      ** An existing allocation, if a realloc situation,
                      **  may need to be added to the new callsite.
                      ** This can only occur if the new and old callsites
                      **  differ.
                      ** Even then, a brute force check will need to be made
                      **  to ensure the allocation was not added twice;
                      **  consider a realloc scenario where two different
                      **  call stacks bump the allocation back and forth.
                      */
                     if (aCallsite != searchCallsite) {
                         int found = 0;
                         found =
                             hasAllocation(CALLSITE_RUN(aCallsite),
                                           allocation);
                         if (0 == found) {
                             int appendResult = 0;
                             appendResult =
                                 appendAllocation(&globals.mCommandLineOptions,
                                                  NULL,
                                                  CALLSITE_RUN(aCallsite),
                                                  allocation);
                             if (0 != appendResult) {
                                 /*
                                  ** Success.
                                  */
                                 retval = allocation;
                             }
                             else {
                                 REPORT_ERROR(__LINE__, appendAllocation);
                             }
                         }
                         else {
                             /*
                              ** Already there.
                              */
                             retval = allocation;
                         }
                     }
                     else {
                         /*
                          ** Success.
                          */
                         retval = allocation;
                     }
                 }
             }
             else {
                 REPORT_ERROR(__LINE__, appendEvent);
             }
         }
         else {
             REPORT_ERROR(__LINE__, allocationTracker);
         }
     }
     else {
         REPORT_ERROR(__LINE__, allocationTracker);
     }
     /*
      ** Compact the heap a bit if you can.
      */
     compactor++;
     if (0 == (compactor % frequency)) {
         heapCompact();
     }
     return retval;
 }
 /*
 ** trackEvent
 **
 ** An allocation event has dropped in on us.
 ** We need to do the right thing and track it.
 */
 void
 trackEvent(uint32_t aTimeval, char aType, uint32_t aHeapRuntimeCost,
            tmcallsite * aCallsite, uint32_t aHeapID, uint32_t aSize,
            tmcallsite * aOldCallsite, uint32_t aOldHeapID, uint32_t aOldSize)
 {
     if (NULL != aCallsite) {
         /*
          ** Verify the old callsite just in case.
          */
         if (NULL != CALLSITE_RUN(aCallsite)
             && (NULL == aOldCallsite || NULL != CALLSITE_RUN(aOldCallsite))) {
             STAllocation *allocation = NULL;
             /*
              ** Add to the allocation tracking code.
              */
             allocation =
                 allocationTracker(aTimeval, aType, aHeapRuntimeCost,
                                   aCallsite, aHeapID, aSize, aOldCallsite,
                                   aOldHeapID, aOldSize);
             if (NULL == allocation) {
                 REPORT_ERROR(__LINE__, allocationTracker);
             }
         }
         else {
             REPORT_ERROR(__LINE__, trackEvent);
         }
     }
     else {
         REPORT_ERROR(__LINE__, trackEvent);
     }
 }
 /*
 ** tmEventHandler
 **
 ** Callback from the tmreader_eventloop function.
 ** Simply tries to sort out what we desire to know.
 */
 static const char spinner_chars[] = { '/', '-', '\\', '|' };
 #define SPINNER_UPDATE_FREQUENCY 4096
 #define SPINNER_CHAR_COUNT (sizeof(spinner_chars) / sizeof(spinner_chars[0]))
 #define SPINNER_CHAR(_x) spinner_chars[(_x / SPINNER_UPDATE_FREQUENCY) % SPINNER_CHAR_COUNT]
 void
 tmEventHandler(tmreader * aReader, tmevent * aEvent)
 {
     static int event_count = 0;     /* for spinner */
     if ((event_count++ % SPINNER_UPDATE_FREQUENCY) == 0)
         printf("\rReading... %c", SPINNER_CHAR(event_count));
     if (NULL != aReader && NULL != aEvent) {
         switch (aEvent->type) {
             /*
              ** Events we ignore.
              */
         case TM_EVENT_LIBRARY:
         case TM_EVENT_METHOD:
         case TM_EVENT_STATS:
         case TM_EVENT_TIMESTAMP:
         case TM_EVENT_FILENAME:
             break;
             /*
              ** Allocation events need to be tracked.
              */
         case TM_EVENT_MALLOC:
         case TM_EVENT_CALLOC:
         case TM_EVENT_REALLOC:
         case TM_EVENT_FREE:
             {
                 uint32_t oldptr = 0;
                 uint32_t oldsize = 0;
                 tmcallsite *callsite = NULL;
                 tmcallsite *oldcallsite = NULL;
                 if (TM_EVENT_REALLOC == aEvent->type) {
                     /*
                      ** Only care about old arguments if there were any.
                      */
                     if (0 != aEvent->u.alloc.oldserial) {
                         oldptr = aEvent->u.alloc.oldptr;
                         oldsize = aEvent->u.alloc.oldsize;
                         oldcallsite =
                             tmreader_callsite(aReader,
                                               aEvent->u.alloc.oldserial);
                         if (NULL == oldcallsite) {
                             REPORT_ERROR(__LINE__, tmreader_callsite);
                         }
                     }
                 }
                 callsite = tmreader_callsite(aReader, aEvent->serial);
                 if (NULL != callsite) {
                     /*
                      ** Verify a callsite run is there.
                      ** If not, we are ignoring this callsite.
                      */
                     if (NULL != CALLSITE_RUN(callsite)) {
                         char eventType = aEvent->type;
                         uint32_t eventSize = aEvent->u.alloc.size;
                         /*
                          ** Play a nasty trick on reallocs of size zero.
                          ** They are to become free events, adjust the size accordingly.
                          ** This allows me to avoid all types of special case code.
                          */
                         if (0 == aEvent->u.alloc.size
                             && TM_EVENT_REALLOC == aEvent->type) {
                             eventType = TM_EVENT_FREE;
                             if (0 != aEvent->u.alloc.oldserial) {
                                 eventSize = aEvent->u.alloc.oldsize;
                             }
                         }
                         trackEvent(ticks2msec
                                    (aReader, aEvent->u.alloc.interval),
                                    eventType, ticks2usec(aReader,
                                                          aEvent->u.alloc.
                                                          cost), callsite,
                                    aEvent->u.alloc.ptr, eventSize,
                                    oldcallsite, oldptr, oldsize);
                     }
                 }
                 else {
                     REPORT_ERROR(__LINE__, tmreader_callsite);
                 }
             }
             break;
             /*
              ** Callsite, set up the callsite run if it does not exist.
              */
         case TM_EVENT_CALLSITE:
             {
                 tmcallsite *callsite =
                     tmreader_callsite(aReader, aEvent->serial);
                 if (NULL != callsite) {
                     if (NULL == CALLSITE_RUN(callsite)) {
                         int createrun = __LINE__;
 #if defined(MOZILLA_CLIENT)
                         /*
                          ** For a mozilla spacetrace, ignore this particular
                          **  callsite as it is just noise, and causes us to
                          **  use a lot of memory.
                          **
                          ** This callsite is present on the linux build,
                          **  not sure if the other platforms have it.
                          */
                         if (0 !=
                             hasCallsiteMatch(callsite, "g_main_is_running",
                                              ST_FOLLOW_PARENTS)) {
                             createrun = 0;
                         }
 #endif /* MOZILLA_CLIENT */
                         if (0 != createrun) {
                             callsite->data = createRun(NULL, 0);
                         }
                     }
                 }
                 else {
                     REPORT_ERROR(__LINE__, tmreader_callsite);
                 }
             }
             break;
             /*
              ** Unhandled events should not be allowed.
              */
         default:
             {
                 REPORT_ERROR(__LINE__, tmEventHandler);
             }
             break;
         }
     }
 }
 /*
 **  optionGetDataOut
 **
 **  Output option get data.
 */
 void
 optionGetDataOut(PRFileDesc * inFD, STOptions * inOptions)
 {
     if (NULL != inFD && NULL != inOptions) {
         int mark = 0;
 #define ST_WEB_OPTION_BOOL(option_name, option_genre, option_help) \
     PR_fprintf(inFD, "%s%s=%d", (0 == mark++) ? "?" : "&", #option_name, inOptions->m##option_name);
 #define ST_WEB_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     PR_fprintf(inFD, "%s%s=%s", (0 == mark++) ? "?" : "&", #option_name, inOptions->m##option_name);
 #define ST_WEB_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     { \
         uint32_t loop = 0; \
         \
         for(loop = 0; loop < array_size; loop++) \
         { \
             PR_fprintf(inFD, "%s%s=%s", (0 == mark++) ? "?" : "&", #option_name, inOptions->m##option_name[loop]); \
         } \
     }
 #define ST_WEB_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help)  /* no implementation */
 #define ST_WEB_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     PR_fprintf(inFD, "%s%s=%u", (0 == mark++) ? "?" : "&", #option_name, inOptions->m##option_name / multiplier);
 #define ST_WEB_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     { \
         uint64_t def64 = default_value; \
         uint64_t mul64 = multiplier; \
         uint64_t div64; \
         \
         div64 = inOptions->m##option_name##64 / mul64; \
         PR_fprintf(inFD, "%s%s=%llu", (0 == mark++) ? "?" : "&", #option_name, div64); \
     }
 #include "stoptions.h"
     }
 }
 /*
 ** htmlAnchor
 **
 ** Output an HTML anchor, or just the text depending on the mode.
 */
 void
 htmlAnchor(STRequest * inRequest,
            const char *aHref,
            const char *aText,
            const char *aTarget, const char *aClass, STOptions * inOptions)
 {
     if (NULL != aHref && '\0' != *aHref && NULL != aText && '\0' != *aText) {
         int anchorLive = 1;
         /*
          ** In batch mode, we need to verify the anchor is live.
          */
         if (0 != inRequest->mOptions.mBatchRequestCount) {
             uint32_t loop = 0;
             int comparison = 1;
             for (loop = 0; loop < inRequest->mOptions.mBatchRequestCount;
                  loop++) {
                 comparison =
                     strcmp(aHref, inRequest->mOptions.mBatchRequest[loop]);
                 if (0 == comparison) {
                     break;
                 }
             }
             /*
              ** Did we find it?
              */
             if (0 == comparison) {
                 anchorLive = 0;
             }
         }
         /*
          ** In any mode, don't make an href to the current page.
          */
         if (0 != anchorLive && NULL != inRequest->mGetFileName) {
             if (0 == strcmp(aHref, inRequest->mGetFileName)) {
                 anchorLive = 0;
             }
         }
         /*
          **  Do the right thing.
          */
         if (0 != anchorLive) {
             PR_fprintf(inRequest->mFD, "<a class=\"%s\" ", aClass);
             if (NULL != aTarget && '\0' != *aTarget) {
                 PR_fprintf(inRequest->mFD, "target=\"%s\" ", aTarget);
             }
             PR_fprintf(inRequest->mFD, "href=\"./%s", aHref);
             /*
              **  The options, if desired, get appended as form data.
              */
             optionGetDataOut(inRequest->mFD, inOptions);
             PR_fprintf(inRequest->mFD, "\">%s</a>\n", aText);
         }
         else {
             PR_fprintf(inRequest->mFD, "<span class=\"%s\">%s</span>\n",
                        aClass, aText);
         }
     }
     else {
         REPORT_ERROR(__LINE__, htmlAnchor);
     }
 }
 /*
 ** htmlAllocationAnchor
 **
 ** Output an html achor that will resolve to the allocation in question.
 */
 void
 htmlAllocationAnchor(STRequest * inRequest, STAllocation * aAllocation,
                      const char *aText)
 {
     if (NULL != aAllocation && NULL != aText && '\0' != *aText) {
         char buffer[128];
         /*
          ** This is a total hack.
          ** The filename contains the index of the allocation in globals.mRun.
          ** Safer than using the raw pointer value....
          */
         PR_snprintf(buffer, sizeof(buffer), "allocation_%u.html",
                     aAllocation->mRunIndex);
         htmlAnchor(inRequest, buffer, aText, NULL, "allocation",
                    &inRequest->mOptions);
     }
     else {
         REPORT_ERROR(__LINE__, htmlAllocationAnchor);
     }
 }
 /*
 ** resolveSourceFile
 **
 ** Easy way to get a readable/short name.
 ** NULL if not present, not resolvable.
 */
 const char *
 resolveSourceFile(tmmethodnode * aMethod)
 {
     const char *retval = NULL;
     if (NULL != aMethod) {
         const char *methodSays = NULL;
         methodSays = aMethod->sourcefile;
         if (NULL != methodSays && '\0' != methodSays[0]
             && 0 != strcmp("noname", methodSays)) {
             retval = strrchr(methodSays, '/');
             if (NULL != retval) {
                 retval++;
             }
             else {
                 retval = methodSays;
             }
         }
     }
     return retval;
 }
 /*
 ** htmlCallsiteAnchor
 **
 ** Output an html anchor that will resolve to the callsite in question.
 ** If no text is provided, we provide our own.
 **
 ** RealName determines whether or not we crawl our parents until the point
 **  we no longer match stats.
 */
 void
 htmlCallsiteAnchor(STRequest * inRequest, tmcallsite * aCallsite,
                    const char *aText, int aRealName)
 {
     if (NULL != aCallsite) {
         char textBuf[512];
         char hrefBuf[128];
         tmcallsite *namesite = aCallsite;
         /*
          ** Should we use a different name?
          */
         if (0 == aRealName && NULL != namesite->parent
             && NULL != namesite->parent->method) {
             STRun *myRun = NULL;
             STRun *upRun = NULL;
             do {
                 myRun = CALLSITE_RUN(namesite);
                 upRun = CALLSITE_RUN(namesite->parent);
                 if (0 !=
                     memcmp(&myRun->mStats[inRequest->mContext->mIndex],
                            &upRun->mStats[inRequest->mContext->mIndex],
                            sizeof(STCallsiteStats))) {
                     /*
                      ** Doesn't match, stop.
                      */
                     break;
                 }
                 else {
                     /*
                      ** Matches, keep going up.
                      */
                     namesite = namesite->parent;
                 }
             }
             while (NULL != namesite->parent
                    && NULL != namesite->parent->method);
         }
         /*
          ** If no text, provide our own.
          */
         if (NULL == aText || '\0' == *aText) {
             const char *methodName = NULL;
             const char *sourceFile = NULL;
             if (NULL != namesite->method) {
                 methodName = tmmethodnode_name(namesite->method);
             }
             else {
                 methodName = "==NONAME==";
             }
             /*
              ** Decide which format to use to identify the callsite.
              ** If we can detect availability, hook up the filename with lxr information.
              */
             sourceFile = resolveSourceFile(namesite->method);
             if (NULL != sourceFile
                 && 0 == strncmp("mozilla/", namesite->method->sourcefile,
 )) {
                 char lxrHREFBuf[512];
                 PR_snprintf(lxrHREFBuf, sizeof(lxrHREFBuf),
                             " [<a href=\"http://lxr.mozilla.org/mozilla/source/%s#%u\" class=\"lxr\" target=\"_st_lxr\">%s:%u</a>]",
                             namesite->method->sourcefile + 8,
                             namesite->method->linenumber, sourceFile,
                             namesite->method->linenumber);
                 PR_snprintf(textBuf, sizeof(textBuf),
                             "<span class=\"source mozilla-source\">%s</span>%s",
                             methodName, lxrHREFBuf);
             }
             else if (NULL != sourceFile) {
                 PR_snprintf(textBuf, sizeof(textBuf),
                             "<span class=\"source external-source\">%s [<span class=\"source-extra\">%s:%u</span>]</span>",
                             methodName, sourceFile,
                             namesite->method->linenumber);
             }
             else {
                 PR_snprintf(textBuf, sizeof(textBuf),
                             "<span class=\"source binary-source\">%s [<span class=\"source-extra\">+%u(%u)</span>]</span>",
                             methodName, namesite->offset,
                             (uint32_t) namesite->entry.key);
             }
             aText = textBuf;
         }
         PR_snprintf(hrefBuf, sizeof(hrefBuf), "callsite_%u.html",
                     (uint32_t) aCallsite->entry.key);
         htmlAnchor(inRequest, hrefBuf, aText, NULL, "callsite",
                    &inRequest->mOptions);
     }
     else {
         REPORT_ERROR(__LINE__, htmlCallsiteAnchor);
     }
 }
 /*
 ** htmlHeader
 **
 ** Output a standard header in the report files.
 */
 void
 htmlHeader(STRequest * inRequest, const char *aTitle)
 {
     PR_fprintf(inRequest->mFD,
                "<html>\n"
                "<head>\n"
                "<title>%s</title>\n"
                "<link rel=\"stylesheet\" href=\"spacetrace.css\" type=\"text/css\""
                "</head>\n"
                "<body>\n"
                "<div class=spacetrace-header>\n"
                "<span class=spacetrace-title>Spacetrace</span>"
                "<span class=navigate>\n"
                "<span class=\"category-title header-text\">Category:</span>\n"
                "<span class=\"current-category\">%s</span>\n",
                aTitle, inRequest->mOptions.mCategoryName);
     PR_fprintf(inRequest->mFD, "<span class=\"header-item\">");
     htmlAnchor(inRequest, "index.html", "Index", NULL, "header-menuitem",
                &inRequest->mOptions);
     PR_fprintf(inRequest->mFD, "</span>\n");
     PR_fprintf(inRequest->mFD, "<span class=\"header-item\">");
     htmlAnchor(inRequest, "options.html", "Options", NULL, "header-menuitem",
                &inRequest->mOptions);
     PR_fprintf(inRequest->mFD, "</span>\n");
     PR_fprintf(inRequest->mFD, "</span>\n");    /* class=navigate */
     PR_fprintf(inRequest->mFD,
                "</div>\n\n<div class=\"header-separator\"></div>\n\n");
 }
 /*
 ** htmlFooter
 **
 ** Output a standard footer in the report file.
 */
 void
 htmlFooter(STRequest * inRequest)
 {
     PR_fprintf(inRequest->mFD,
                "<div class=\"footer-separator\"></div>\n\n"
                "<div class=\"footer\">\n"
                "<span class=\"footer-text\">SpaceTrace</span>\n"
                "</div>\n\n" "</body>\n" "</html>\n");
 }
 /*
 ** htmlNotFound
 **
 ** Not found message.
 */
 void
 htmlNotFound(STRequest * inRequest)
 {
     htmlHeader(inRequest, "File Not Found");
     PR_fprintf(inRequest->mFD, "File Not Found\n");
     htmlFooter(inRequest);
 }
 void
 htmlStartTable(STRequest* inRequest,
                const char* table_class,
                const char* id,
                const char* caption,
                const char * const headers[], uint32_t header_length)
 {
         uint32_t i;
         PR_fprintf(inRequest->mFD,
                    "<div id=\"%s\"><table class=\"data %s\">\n"
                    "  <caption>%s</caption>"
                    "  <thead>\n"
                    "    <tr class=\"row-header\">\n", id,
                    table_class ? table_class : "",
                    caption);
         for (i=0; i< header_length; i++)
             PR_fprintf(inRequest->mFD,
                        "      <th>%s</th>\n", headers[i]);
         PR_fprintf(inRequest->mFD, "    </tr>  </thead>  <tbody>\n");
 }
 /*
 ** callsiteArrayFromCallsite
 **
 ** Simply return an array of the callsites divulged from the site passed in,
 **  including the site passed in.
 ** Do not worry about dups, or the order of the items.
 **
 ** Returns the number of items in the array.
 ** If the same as aExistingCount, then nothing happened.
 */
 uint32_t
 callsiteArrayFromCallsite(tmcallsite *** aArray, uint32_t aExistingCount,
                           tmcallsite * aSite, int aFollow)
 {
     uint32_t retval = 0;
     if (NULL != aArray && NULL != aSite) {
         tmcallsite **expand = NULL;
         /*
          ** If we have an existing count, we just keep expanding this.
          */
         retval = aExistingCount;
         /*
          ** Go through every allocation.
          */
         do {
             /*
              ** expand the array.
              */
             expand =
                 (tmcallsite **) realloc(*aArray,
                                         sizeof(tmcallsite *) * (retval + 1));
             if (NULL != expand) {
                 /*
                  ** Set the callsite in case of pointer move.
                  */
                 *aArray = expand;
                 /*
                  ** Assign the value.
                  */
                 (*aArray)[retval] = aSite;
                 retval++;
             }
             else {
                 REPORT_ERROR(__LINE__, realloc);
                 break;
             }
             /*
              ** What do we follow?
              */
             switch (aFollow) {
             case ST_FOLLOW_SIBLINGS:
                 aSite = aSite->siblings;
                 break;
             case ST_FOLLOW_PARENTS:
                 aSite = aSite->parent;
                 break;
             default:
                 aSite = NULL;
                 REPORT_ERROR(__LINE__, callsiteArrayFromCallsite);
                 break;
             }
         }
         while (NULL != aSite && NULL != aSite->method);
     }
     return retval;
 }
 /*
 ** callsiteArrayFromRun
 **
 ** Simply return an array of the callsites from the run allocations.
 ** We only pay attention to callsites that were not free callsites.
 ** Do not worry about dups, or the order of the items.
 **
 ** Returns the number of items in the array.
 ** If the same as aExistingCount, then nothing happened.
 */
 uint32_t
 callsiteArrayFromRun(tmcallsite *** aArray, uint32_t aExistingCount,
                      STRun * aRun)
 {
     uint32_t retval = 0;
     if (NULL != aArray && NULL != aRun && 0 < aRun->mAllocationCount) {
         uint32_t allocLoop = 0;
         uint32_t eventLoop = 0;
         int stopLoops = 0;
         /*
          ** If we have an existing count, we just keep expanding this.
          */
         retval = aExistingCount;
         /*
          ** Go through every allocation.
          */
         for (allocLoop = 0;
 == stopLoops && allocLoop < aRun->mAllocationCount;
              allocLoop++) {
             /*
              ** Go through every event.
              */
             for (eventLoop = 0;
 == stopLoops
                  && eventLoop < aRun->mAllocations[allocLoop]->mEventCount;
                  eventLoop++) {
                 /*
                  ** Skip the free events.
                  */
                 if (TM_EVENT_FREE !=
                     aRun->mAllocations[allocLoop]->mEvents[eventLoop].
                     mEventType) {
                     tmcallsite **expand = NULL;
                     /*
                      ** expand the array.
                      */
                     expand =
                         (tmcallsite **) realloc(*aArray,
                                                 sizeof(tmcallsite *) *
                                                 (retval + 1));
                     if (NULL != expand) {
                         /*
                          ** Set the callsite in case of pointer move.
                          */
                         *aArray = expand;
                         /*
                          ** Assign the value.
                          */
                         (*aArray)[retval] =
                             aRun->mAllocations[allocLoop]->mEvents[eventLoop].
                             mCallsite;
                         retval++;
                     }
                     else {
                         REPORT_ERROR(__LINE__, realloc);
                         stopLoops = __LINE__;
                     }
                 }
             }
         }
     }
     return retval;
 }
 /*
 ** getDataPRUint*
 **
 ** Helper to avoid cut and paste code.
 ** Failure to find aCheckFor does not mean failure.
 ** In case of dups, specify an index on non "1" to get others.
 ** Do not touch storage space unless a find is made.
 ** Returns !0 on failure.
 */
 int
 getDataPRUint32Base(const FormData * aGetData, const char *aCheckFor,
                     int inIndex, void *aStoreResult, uint32_t aBits)
 {
     int retval = 0;
     if (NULL != aGetData && NULL != aCheckFor && 0 != inIndex
         && NULL != aStoreResult) {
         unsigned finder = 0;
         /*
          **  Loop over the names, looking for an exact string match.
          **  Skip over initial finds, decrementing inIndex, until "1".
          */
         for (finder = 0; finder < aGetData->mNVCount; finder++) {
             if (0 == strcmp(aCheckFor, aGetData->mNArray[finder])) {
                 inIndex--;
                 if (0 == inIndex) {
                     int32_t scanRes = 0;
                     if (64 == aBits) {
                         scanRes =
                             PR_sscanf(aGetData->mVArray[finder], "%llu",
                                       aStoreResult);
                     }
                     else {
                         scanRes =
                             PR_sscanf(aGetData->mVArray[finder], "%u",
                                       aStoreResult);
                     }
                     if (1 != scanRes) {
                         retval = __LINE__;
                         REPORT_ERROR(__LINE__, PR_sscanf);
                     }
                     break;
                 }
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, getDataPRUint32Base);
     }
     return retval;
 }
 int
 getDataPRUint32(const FormData * aGetData, const char *aCheckFor, int inIndex,
                 uint32_t * aStoreResult, uint32_t aConversion)
 {
     int retval = 0;
     retval =
         getDataPRUint32Base(aGetData, aCheckFor, inIndex, aStoreResult, 32);
     *aStoreResult *= aConversion;
     return retval;
 }
 int
 getDataPRUint64(const FormData * aGetData, const char *aCheckFor, int inIndex,
                 uint64_t * aStoreResult64, uint64_t aConversion64)
 {
     int retval = 0;
     uint64_t value64 = 0;
     retval = getDataPRUint32Base(aGetData, aCheckFor, inIndex, &value64, 64);
     *aStoreResult64 = value64 * aConversion64;
     return retval;
 }
 /*
 ** getDataString
 **
 ** Pull out the string data, if specified.
 ** In case of dups, specify an index on non "1" to get others.
 ** Do not touch storage space unless a find is made.
 ** Return !0 on failure.
 */
 int
 getDataString(const FormData * aGetData, const char *aCheckFor, int inIndex,
               char *aStoreResult, int inStoreResultLength)
 {
     int retval = 0;
     if (NULL != aGetData && NULL != aCheckFor && 0 != inIndex
         && NULL != aStoreResult && 0 != inStoreResultLength) {
         unsigned finder = 0;
         /*
          **  Loop over the names, looking for an exact string match.
          **  Skip over initial finds, decrementing inIndex, until "1".
          */
         for (finder = 0; finder < aGetData->mNVCount; finder++) {
             if (0 == strcmp(aCheckFor, aGetData->mNArray[finder])) {
                 inIndex--;
                 if (0 == inIndex) {
                     PR_snprintf(aStoreResult, inStoreResultLength, "%s",
                                 aGetData->mVArray[finder]);
                     break;
                 }
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, getDataPRUint32);
     }
     return retval;
 }
 /*
 ** displayTopAllocations
 **
 ** Present the top allocations.
 ** The run must be passed in, and it must be pre-sorted.
 **
 ** Returns !0 on failure.
 */
 int
 displayTopAllocations(STRequest * inRequest, STRun * aRun,
                       const char* id,
                       const char* caption,
                       int aWantCallsite)
 {
     int retval = 0;
     if (NULL != aRun) {
         if (0 < aRun->mAllocationCount) {
             uint32_t loop = 0;
             STAllocation *current = NULL;
             static const char* const headers[] = {
                 "Rank", "Index", "Byte Size", "Lifespan (sec)",
                 "Weight", "Heap Op (sec)"
             };
             static const char* const headers_callsite[] = {
                 "Rank", "Index", "Byte Size", "Lifespan (sec)",
                 "Weight", "Heap Op (sec)", "Origin Callsite"
             };
             if (aWantCallsite)
                 htmlStartTable(inRequest, NULL, id,
                                caption,
                                headers_callsite,
                                sizeof(headers_callsite) / sizeof(headers_callsite[0]));
             else
                 htmlStartTable(inRequest, NULL, id, caption,
                                headers,
                                sizeof(headers) / sizeof(headers[0]));
             /*
              ** Loop over the items, up to some limit or until the end.
              */
             for (loop = 0;
                  loop < inRequest->mOptions.mListItemMax
                  && loop < aRun->mAllocationCount; loop++) {
                 current = aRun->mAllocations[loop];
                 if (NULL != current) {
                     uint32_t lifespan =
                         current->mMaxTimeval - current->mMinTimeval;
                     uint32_t size = byteSize(&inRequest->mOptions, current);
                     uint32_t heapCost = current->mHeapRuntimeCost;
                     uint64_t weight64 = 0;
                     char buffer[32];
                     weight64 =(uint64_t)(size * lifespan);
                     PR_fprintf(inRequest->mFD, "<tr>\n");
                     /*
                      ** Rank.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%u</td>\n",
                                loop + 1);
                     /*
                      ** Index.
                      */
                     PR_snprintf(buffer, sizeof(buffer), "%u",
                                 current->mRunIndex);
                     PR_fprintf(inRequest->mFD, "<td align=right>\n");
                     htmlAllocationAnchor(inRequest, current, buffer);
                     PR_fprintf(inRequest->mFD, "</td>\n");
                     /*
                      ** Byte Size.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%u</td>\n",
                                size);
                     /*
                      ** Lifespan.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td align=right>" ST_TIMEVAL_FORMAT "</td>\n",
                                ST_TIMEVAL_PRINTABLE(lifespan));
                     /*
                      ** Weight.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%llu</td>\n",
                                weight64);
                     /*
                      ** Heap operation cost.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td align=right>" ST_MICROVAL_FORMAT
                                "</td>\n", ST_MICROVAL_PRINTABLE(heapCost));
                     if (0 != aWantCallsite) {
                         /*
                          ** Callsite.
                          */
                         PR_fprintf(inRequest->mFD, "<td>");
                         htmlCallsiteAnchor(inRequest,
                                            current->mEvents[0].mCallsite,
                                            NULL, 0);
                         PR_fprintf(inRequest->mFD, "</td>\n");
                     }
                     PR_fprintf(inRequest->mFD, "</tr>\n");
                 }
             }
             PR_fprintf(inRequest->mFD, "</tbody>\n</table></div>\n\n");
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayTopAllocations);
     }
     return retval;
 }
 /*
 ** displayMemoryLeaks
 **
 ** Present the top memory leaks.
 ** The run must be passed in, and it must be pre-sorted.
 **
 ** Returns !0 on failure.
 */
 int
 displayMemoryLeaks(STRequest * inRequest, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun) {
         uint32_t loop = 0;
         uint32_t displayed = 0;
         STAllocation *current = NULL;
         static const char * headers[] = {
             "Rank", "Index", "Byte Size", "Lifespan (sec)",
             "Weight", "Heap Op (sec)", "Origin Callsite"
         };
         htmlStartTable(inRequest, NULL, "memory-leaks", "Memory Leaks", headers,
                        sizeof(headers) / sizeof(headers[0]));
         /*
          ** Loop over all of the items, or until we've displayed enough.
          */
         for (loop = 0;
              displayed < inRequest->mOptions.mListItemMax
              && loop < aRun->mAllocationCount; loop++) {
             current = aRun->mAllocations[loop];
             if (NULL != current && 0 != current->mEventCount) {
                 /*
                  ** In order to be a leak, the last event of its life must
                  **  NOT be a free operation.
                  **
                  ** A free operation is just that, a free.
                  */
                 if (TM_EVENT_FREE !=
                     current->mEvents[current->mEventCount - 1].mEventType) {
                     uint32_t lifespan =
                         current->mMaxTimeval - current->mMinTimeval;
                     uint32_t size = byteSize(&inRequest->mOptions, current);
                     uint32_t heapCost = current->mHeapRuntimeCost;
                     uint64_t weight64 = 0;
                     char buffer[32];
                     weight64 =(uint64_t)(size * lifespan);
                     /*
                      ** One more shown.
                      */
                     displayed++;
                     PR_fprintf(inRequest->mFD, "<tr>\n");
                     /*
                      ** Rank.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%u</td>\n",
                                displayed);
                     /*
                      ** Index.
                      */
                     PR_snprintf(buffer, sizeof(buffer), "%u",
                                 current->mRunIndex);
                     PR_fprintf(inRequest->mFD, "<td align=right>\n");
                     htmlAllocationAnchor(inRequest, current, buffer);
                     PR_fprintf(inRequest->mFD, "</td>\n");
                     /*
                      ** Byte Size.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%u</td>\n",
                                size);
                     /*
                      ** Lifespan.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td align=right>" ST_TIMEVAL_FORMAT "</td>\n",
                                ST_TIMEVAL_PRINTABLE(lifespan));
                     /*
                      ** Weight.
                      */
                     PR_fprintf(inRequest->mFD, "<td align=right>%llu</td>\n",
                                weight64);
                     /*
                      ** Heap Operation Seconds.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td align=right>" ST_MICROVAL_FORMAT
                                "</td>\n", ST_MICROVAL_PRINTABLE(heapCost));
                     /*
                      ** Callsite.
                      */
                     PR_fprintf(inRequest->mFD, "<td>");
                     htmlCallsiteAnchor(inRequest,
                                        current->mEvents[0].mCallsite, NULL,
 );
                     PR_fprintf(inRequest->mFD, "</td>\n");
                     PR_fprintf(inRequest->mFD, "</tr>\n");
                 }
             }
         }
         PR_fprintf(inRequest->mFD, "</tbody></table></div>\n\n");
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayMemoryLeaks);
     }
     return retval;
 }
 /*
 ** displayCallsites
 **
 ** Display a table of callsites.
 ** If the stamp is non zero, then must match that stamp.
 ** If the stamp is zero, then must match the global sorted run stamp.
 ** Return !0 on error.
 */
 int
 displayCallsites(STRequest * inRequest, tmcallsite * aCallsite, int aFollow,
                  uint32_t aStamp,
                  const char* id,
                  const char* caption,
                  int aRealNames)
 {
     int retval = 0;
     if (NULL != aCallsite && NULL != aCallsite->method) {
         int headerDisplayed = 0;
         STRun *run = NULL;
         /*
          ** Correct the stamp if need be.
          */
         if (0 == aStamp && NULL != inRequest->mContext->mSortedRun) {
             aStamp =
                 inRequest->mContext->mSortedRun->mStats[inRequest->mContext->
                                                         mIndex].mStamp;
         }
         /*
          ** Loop over the callsites looking for a stamp match.
          ** A stamp guarantees there is something interesting to look at too.
          ** If found, output it.
          */
         while (NULL != aCallsite && NULL != aCallsite->method) {
             run = CALLSITE_RUN(aCallsite);
             if (NULL != run) {
                 if (aStamp == run->mStats[inRequest->mContext->mIndex].mStamp) {
                     /*
                      ** We got a header?
                      */
                     if (0 == headerDisplayed) {
                         static const char* const headers[] = {
                             "Callsite",
                             "<abbr title=\"Composite Size\">C. Size</abbr>",
                             "<abbr title=\"Composite Seconds\">C. Seconds</abbr>",
                             "<abbr title=\"Composite Weight\">C. Weight</abbr>",
                             "<abbr title=\"Heap Object Count\">H.O. Count</abbr>",
                             "<abbr title=\"Composite Heap Operation Seconds\">C.H. Operation (sec)</abbr>"
                         };
                         headerDisplayed = __LINE__;
                         htmlStartTable(inRequest, NULL, id, caption, headers,
                                        sizeof(headers)/sizeof(headers[0]));
                     }
                     /*
                      ** Output the information.
                      */
                     PR_fprintf(inRequest->mFD, "<tr>\n");
                     /*
                      ** Method name.
                      */
                     PR_fprintf(inRequest->mFD, "<td>");
                     htmlCallsiteAnchor(inRequest, aCallsite, NULL,
                                        aRealNames);
                     PR_fprintf(inRequest->mFD, "</td>");
                     /*
                      ** Byte Size.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td valign=top align=right>%u</td>\n",
                                run->mStats[inRequest->mContext->mIndex].
                                mSize);
                     /*
                      ** Seconds.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td valign=top align=right>" ST_TIMEVAL_FORMAT
                                "</td>\n",
                                ST_TIMEVAL_PRINTABLE64(run->
                                                       mStats[inRequest->
                                                              mContext->
                                                              mIndex].
                                                       mTimeval64));
                     /*
                      ** Weight.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td valign=top align=right>%llu</td>\n",
                                run->mStats[inRequest->mContext->mIndex].
                                mWeight64);
                     /*
                      ** Allocation object count.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td valign=top align=right>%u</td>\n",
                                run->mStats[inRequest->mContext->mIndex].
                                mCompositeCount);
                     /*
                      ** Heap Operation Seconds.
                      */
                     PR_fprintf(inRequest->mFD,
                                "<td valign=top align=right>"
                                ST_MICROVAL_FORMAT "</td>\n",
                                ST_MICROVAL_PRINTABLE(run->
                                                      mStats[inRequest->
                                                             mContext->mIndex].
                                                      mHeapRuntimeCost));
                     PR_fprintf(inRequest->mFD, "</tr>\n");
                 }
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, displayCallsites);
                 break;
             }
             /*
              ** What do we follow?
              */
             switch (aFollow) {
             case ST_FOLLOW_SIBLINGS:
                 aCallsite = aCallsite->siblings;
                 break;
             case ST_FOLLOW_PARENTS:
                 aCallsite = aCallsite->parent;
                 break;
             default:
                 aCallsite = NULL;
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, displayCallsites);
                 break;
             }
         }
         /*
          ** Terminate the table if we should.
          */
         if (0 != headerDisplayed) {
             PR_fprintf(inRequest->mFD, "</tbody></table></div>\n\n");
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayCallsites);
     }
     return retval;
 }
 /*
 ** displayAllocationDetails
 **
 ** Report what we know about the allocation.
 **
 ** Returns !0 on error.
 */
 int
 displayAllocationDetails(STRequest * inRequest, STAllocation * aAllocation)
 {
     int retval = 0;
     if (NULL != aAllocation) {
         uint32_t traverse = 0;
         uint32_t bytesize = byteSize(&inRequest->mOptions, aAllocation);
         uint32_t timeval =
             aAllocation->mMaxTimeval - aAllocation->mMinTimeval;
         uint32_t heapCost = aAllocation->mHeapRuntimeCost;
         uint64_t weight64 = 0;
         uint32_t cacheval = 0;
         int displayRes = 0;
         weight64 = (uint64_t)(bytesize * timeval);
         PR_fprintf(inRequest->mFD, "<p>Allocation %u Details:</p>\n",
                    aAllocation->mRunIndex);
         PR_fprintf(inRequest->mFD, "<div id=\"allocation-details\"><table class=\"data summary\">\n");
         PR_fprintf(inRequest->mFD,
                    "<tr><td align=left>Final Size:</td><td align=right>%u</td></tr>\n",
                    bytesize);
         PR_fprintf(inRequest->mFD,
                    "<tr><td align=left>Lifespan Seconds:</td><td align=right>"
                    ST_TIMEVAL_FORMAT "</td></tr>\n",
                    ST_TIMEVAL_PRINTABLE(timeval));
         PR_fprintf(inRequest->mFD,
                    "<tr><td align=left>Weight:</td><td align=right>%llu</td></tr>\n",
                    weight64);
         PR_fprintf(inRequest->mFD,
                    "<tr><td align=left>Heap Operation Seconds:</td><td align=right>"
                    ST_MICROVAL_FORMAT "</td></tr>\n",
                    ST_MICROVAL_PRINTABLE(heapCost));
         PR_fprintf(inRequest->mFD, "</table></div>\n");
         /*
          ** The events.
          */
         {
             static const char* const headers[] = {
                 "Operation", "Size", "Seconds", ""
             };
             char caption[100];
             PR_snprintf(caption, sizeof(caption), "%u Life Event(s)",
                        aAllocation->mEventCount);
             htmlStartTable(inRequest, NULL, "allocation-details", caption, headers,
                            sizeof(headers) / sizeof(headers[0]));
         }
         for (traverse = 0;
              traverse < aAllocation->mEventCount
              && traverse < inRequest->mOptions.mListItemMax; traverse++) {
             PR_fprintf(inRequest->mFD, "<tr>\n");
             /*
              ** count.
              */
             PR_fprintf(inRequest->mFD,
                        "<td valign=top align=right>%u.</td>\n", traverse + 1);
             /*
              ** Operation.
              */
             PR_fprintf(inRequest->mFD, "<td valign=top>");
             switch (aAllocation->mEvents[traverse].mEventType) {
             case TM_EVENT_CALLOC:
                 PR_fprintf(inRequest->mFD, "calloc");
                 break;
             case TM_EVENT_FREE:
                 PR_fprintf(inRequest->mFD, "free");
                 break;
             case TM_EVENT_MALLOC:
                 PR_fprintf(inRequest->mFD, "malloc");
                 break;
             case TM_EVENT_REALLOC:
                 PR_fprintf(inRequest->mFD, "realloc");
                 break;
             default:
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, displayAllocationDetails);
                 break;
             }
             PR_fprintf(inRequest->mFD, "</td>");
             /*
              ** Size.
              */
             PR_fprintf(inRequest->mFD, "<td valign=top align=right>%u</td>\n",
                        aAllocation->mEvents[traverse].mHeapSize);
             /*
              ** Timeval.
              */
             cacheval =
                 aAllocation->mEvents[traverse].mTimeval - globals.mMinTimeval;
             PR_fprintf(inRequest->mFD,
                        "<td valign=top align=right>" ST_TIMEVAL_FORMAT
                        "</td>\n", ST_TIMEVAL_PRINTABLE(cacheval));
             /*
              ** Callsite backtrace.
              ** Only relevant backtrace is for event 0 for now until
              **  trace-malloc outputs proper callsites for all others.
              */
             PR_fprintf(inRequest->mFD, "<td valign=top>\n");
             if (0 == traverse) {
                 displayRes =
                     displayCallsites(inRequest,
                                      aAllocation->mEvents[traverse].mCallsite,
                                      ST_FOLLOW_PARENTS, 0, "event-stack", "", __LINE__);
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayCallsite);
                 }
             }
             PR_fprintf(inRequest->mFD, "</td>\n");
             PR_fprintf(inRequest->mFD, "</tr>\n");
         }
         PR_fprintf(inRequest->mFD, "</table></div>\n");
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayAllocationDetails);
     }
     return retval;
 }
 /*
 ** compareCallsites
 **
 ** qsort callback.
 ** Compare the callsites as specified by the options.
 ** There must be NO equal callsites, unless they really are duplicates,
 **  this is so that a duplicate detector loop can
 **  simply skip sorted items until the callsite is different.
 */
 int
 compareCallsites(const void *aSite1, const void *aSite2, void *aContext)
 {
     int retval = 0;
     STRequest *inRequest = (STRequest *) aContext;
     if (NULL != aSite1 && NULL != aSite2) {
         tmcallsite *site1 = *((tmcallsite **) aSite1);
         tmcallsite *site2 = *((tmcallsite **) aSite2);
         if (NULL != site1 && NULL != site2) {
             STRun *run1 = CALLSITE_RUN(site1);
             STRun *run2 = CALLSITE_RUN(site2);
             if (NULL != run1 && NULL != run2) {
                 STCallsiteStats *stats1 =
                     &(run1->mStats[inRequest->mContext->mIndex]);
                 STCallsiteStats *stats2 =
                     &(run2->mStats[inRequest->mContext->mIndex]);
                 /*
                  ** Logic determined by pref/option.
                  */
                 switch (inRequest->mOptions.mOrderBy) {
                 case ST_WEIGHT:
                     {
                         uint64_t weight164 = stats1->mWeight64;
                         uint64_t weight264 = stats2->mWeight64;
                         if (weight164 < weight264) {
                             retval = __LINE__;
                         }
                         else if (weight164 > weight264) {
                             retval = -__LINE__;
                         }
                     }
                     break;
                 case ST_SIZE:
                     {
                         uint32_t size1 = stats1->mSize;
                         uint32_t size2 = stats2->mSize;
                         if (size1 < size2) {
                             retval = __LINE__;
                         }
                         else if (size1 > size2) {
                             retval = -__LINE__;
                         }
                     }
                     break;
                 case ST_TIMEVAL:
                     {
                         uint64_t timeval164 = stats1->mTimeval64;
                         uint64_t timeval264 = stats2->mTimeval64;
                         if (timeval164 < timeval264) {
                             retval = __LINE__;
                         }
                         else if (timeval164 > timeval264) {
                             retval = -__LINE__;
                         }
                     }
                     break;
                 case ST_COUNT:
                     {
                         uint32_t count1 = stats1->mCompositeCount;
                         uint32_t count2 = stats2->mCompositeCount;
                         if (count1 < count2) {
                             retval = __LINE__;
                         }
                         else if (count1 > count2) {
                             retval = -__LINE__;
                         }
                     }
                     break;
                 case ST_HEAPCOST:
                     {
                         uint32_t cost1 = stats1->mHeapRuntimeCost;
                         uint32_t cost2 = stats2->mHeapRuntimeCost;
                         if (cost1 < cost2) {
                             retval = __LINE__;
                         }
                         else if (cost1 > cost2) {
                             retval = -__LINE__;
                         }
                     }
                     break;
                 default:
                     {
                         REPORT_ERROR(__LINE__, compareAllocations);
                     }
                     break;
                 }
                 /*
                  ** If the return value is still zero, do a pointer compare.
                  ** This makes sure we return zero, only iff the same object.
                  */
                 if (0 == retval) {
                     if (stats1 < stats2) {
                         retval = __LINE__;
                     }
                     else if (stats1 > stats2) {
                         retval = -__LINE__;
                     }
                 }
             }
         }
     }
     return retval;
 }
 /*
 ** displayTopCallsites
 **
 ** Given a list of callsites, sort it, and output skipping dups.
 ** The passed in callsite array is side effected, as in that it will come
 **  back sorted.  This function will not release the array.
 **
 ** Note:  If the stamp passed in is non zero, then all callsites must match.
 **  If the stamp is zero, all callsites must match global sorted run stamp.
 **
 ** Returns !0 on error.
 */
 int
 displayTopCallsites(STRequest * inRequest, tmcallsite ** aCallsites,
                     uint32_t aCallsiteCount, uint32_t aStamp,
                     const char* id,
                     const char* caption,
                     int aRealName)
 {
     int retval = 0;
     if (NULL != aCallsites && 0 < aCallsiteCount) {
         uint32_t traverse = 0;
         STRun *run = NULL;
         tmcallsite *site = NULL;
         int headerDisplayed = 0;
         uint32_t displayed = 0;
         /*
          ** Fixup the stamp.
          */
         if (0 == aStamp && NULL != inRequest->mContext->mSortedRun) {
             aStamp =
                 inRequest->mContext->mSortedRun->mStats[inRequest->mContext->
                                                         mIndex].mStamp;
         }
         /*
          ** Sort the things.
          */
         NS_QuickSort(aCallsites, aCallsiteCount, sizeof(tmcallsite *),
                      compareCallsites, inRequest);
         /*
          ** Time for output.
          */
         for (traverse = 0;
              traverse < aCallsiteCount
              && inRequest->mOptions.mListItemMax > displayed; traverse++) {
             site = aCallsites[traverse];
             run = CALLSITE_RUN(site);
             /*
              ** Only if the same stamp....
              */
             if (aStamp == run->mStats[inRequest->mContext->mIndex].mStamp) {
                 /*
                  ** We got a header yet?
                  */
                 if (0 == headerDisplayed) {
                     static const char* const headers[] = {
                         "Rank",
                         "Callsite",
                         "<abbr title=\"Composite Size\">Size</abbr>",
                         "<abbr title=\"Composite Seconds\">Seconds</abbr>",
                         "<abbr title=\"Composite Weight\">Weight</abbr>",
                         "<abbr title=\"Heap Object Count\">Object Count</abbr>",
                         "<abbr title=\"Composite Heap Operation Seconds\">C.H. Operation (sec)</abbr>"
                     };
                     headerDisplayed = __LINE__;
                     htmlStartTable(inRequest, NULL, id, caption, headers,
                                    sizeof(headers) / sizeof(headers[0]));
                 }
                 displayed++;
                 PR_fprintf(inRequest->mFD, "<tr>\n");
                 /*
                  ** Rank.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>%u</td>\n", displayed);
                 /*
                  ** Method.
                  */
                 PR_fprintf(inRequest->mFD, "<td>");
                 htmlCallsiteAnchor(inRequest, site, NULL, aRealName);
                 PR_fprintf(inRequest->mFD, "</td>\n");
                 /*
                  ** Size.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>%u</td>\n",
                            run->mStats[inRequest->mContext->mIndex].mSize);
                 /*
                  ** Timeval.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>" ST_TIMEVAL_FORMAT
                            "</td>\n",
                            ST_TIMEVAL_PRINTABLE64(run->
                                                   mStats[inRequest->mContext->
                                                          mIndex].mTimeval64));
                 /*
                  ** Weight.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>%llu</td>\n",
                            run->mStats[inRequest->mContext->mIndex].
                            mWeight64);
                 /*
                  ** Allocation object count.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>%u</td>\n",
                            run->mStats[inRequest->mContext->mIndex].
                            mCompositeCount);
                 /*
                  ** Heap operation seconds.
                  */
                 PR_fprintf(inRequest->mFD,
                            "<td align=right valign=top>" ST_MICROVAL_FORMAT
                            "</td>\n",
                            ST_MICROVAL_PRINTABLE(run->
                                                  mStats[inRequest->mContext->
                                                         mIndex].
                                                  mHeapRuntimeCost));
                 PR_fprintf(inRequest->mFD, "</tr>\n");
                 if (inRequest->mOptions.mListItemMax > displayed) {
                     /*
                      ** Skip any dups.
                      */
                     while (((traverse + 1) < aCallsiteCount)
                            && (site == aCallsites[traverse + 1])) {
                         traverse++;
                     }
                 }
             }
         }
         /*
          ** We need to terminate anything?
          */
         if (0 != headerDisplayed) {
             PR_fprintf(inRequest->mFD, "</table></div>\n");
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayTopCallsites);
     }
     return retval;
 }
 /*
 ** displayCallsiteDetails
 **
 ** The callsite specific report.
 ** Try to report what we know.
 ** This one hits a little harder than the rest.
 **
 ** Returns !0 on error.
 */
 int
 displayCallsiteDetails(STRequest * inRequest, tmcallsite * aCallsite)
 {
     int retval = 0;
     if (NULL != aCallsite && NULL != aCallsite->method) {
         STRun *sortedRun = NULL;
         STRun *thisRun = CALLSITE_RUN(aCallsite);
         const char *sourceFile = NULL;
         sourceFile = resolveSourceFile(aCallsite->method);
         PR_fprintf(inRequest->mFD, "<div class=\"callsite-header\">\n");
         if (sourceFile) {
             PR_fprintf(inRequest->mFD, "<b>%s</b>",
                        tmmethodnode_name(aCallsite->method));
             PR_fprintf(inRequest->mFD,
                        " [<a href=\"http://lxr.mozilla.org/mozilla/source/%s#%u\" class=\"lxr\" target=\"_st_lxr\">%s:%u</a>]",
                        aCallsite->method->sourcefile,
                        aCallsite->method->linenumber, sourceFile,
                        aCallsite->method->linenumber);
         }
         else {
             PR_fprintf(inRequest->mFD,
                        "<p><b>%s</b>+%u(%u) Callsite Details:</p>\n",
                        tmmethodnode_name(aCallsite->method),
                        aCallsite->offset, (uint32_t) aCallsite->entry.key);
         }
         PR_fprintf(inRequest->mFD, "</div>\n\n");
         PR_fprintf(inRequest->mFD, "<div id=\"callsite-details\"><table class=\"data summary\">\n");
         PR_fprintf(inRequest->mFD,
                    "<tr><td>Composite Byte Size:</td><td align=right>%u</td></tr>\n",
                    thisRun->mStats[inRequest->mContext->mIndex].mSize);
         PR_fprintf(inRequest->mFD,
                    "<tr><td>Composite Seconds:</td><td align=right>"
                    ST_TIMEVAL_FORMAT "</td></tr>\n",
                    ST_TIMEVAL_PRINTABLE64(thisRun->
                                           mStats[inRequest->mContext->mIndex].
                                           mTimeval64));
         PR_fprintf(inRequest->mFD,
                    "<tr><td>Composite Weight:</td><td align=right>%llu</td></tr>\n",
                    thisRun->mStats[inRequest->mContext->mIndex].mWeight64);
         PR_fprintf(inRequest->mFD,
                    "<tr><td>Heap Object Count:</td><td align=right>%u</td></tr>\n",
                    thisRun->mStats[inRequest->mContext->mIndex].
                    mCompositeCount);
         PR_fprintf(inRequest->mFD,
                    "<tr><td>Heap Operation Seconds:</td><td align=right>"
                    ST_MICROVAL_FORMAT "</td></tr>\n",
                    ST_MICROVAL_PRINTABLE(thisRun->
                                          mStats[inRequest->mContext->mIndex].
                                          mHeapRuntimeCost));
         PR_fprintf(inRequest->mFD, "</table></div>\n\n");
         /*
          ** Kids (callsites we call):
          */
         if (NULL != aCallsite->kids && NULL != aCallsite->kids->method) {
             int displayRes = 0;
             uint32_t siteCount = 0;
             tmcallsite **sites = NULL;
             /*
              ** Collect the kid sibling callsites.
              ** Doing it this way sorts them for relevance.
              */
             siteCount =
                 callsiteArrayFromCallsite(&sites, 0, aCallsite->kids,
                                           ST_FOLLOW_SIBLINGS);
             if (0 != siteCount && NULL != sites) {
                 /*
                  ** Got something to show.
                  */
                 displayRes =
                     displayTopCallsites(inRequest, sites, siteCount, 0,
                                         "callsites",
                                         "Children Callsites",
                                         __LINE__);
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayTopCallsites);
                 }
                 /*
                  ** Done with array.
                  */
                 free(sites);
                 sites = NULL;
             }
         }
         /*
          ** Parents (those who call us):
          */
         if (NULL != aCallsite->parent && NULL != aCallsite->parent->method) {
             int displayRes = 0;
             displayRes =
                 displayCallsites(inRequest, aCallsite->parent,
                                  ST_FOLLOW_PARENTS, 0, "caller-stack", "Caller stack",
                                  __LINE__);
             if (0 != displayRes) {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, displayCallsites);
             }
         }
         /*
          ** Allocations we did.
          ** Simply harvest our own run.
          */
         sortedRun = createRun(inRequest->mContext, 0);
         if (NULL != sortedRun) {
             int harvestRes = 0;
             harvestRes =
                 harvestRun(CALLSITE_RUN(aCallsite), sortedRun,
                            &inRequest->mOptions, inRequest->mContext);
             if (0 == harvestRes) {
                 if (0 != sortedRun->mAllocationCount) {
                     int sortRes = 0;
                     sortRes = sortRun(&inRequest->mOptions, sortedRun);
                     if (0 == sortRes) {
                         int displayRes = 0;
                         displayRes =
                             displayTopAllocations(inRequest, sortedRun,
                                                   "allocations",
                                                   "Allocations",
 );
                         if (0 != displayRes) {
                             retval = __LINE__;
                             REPORT_ERROR(__LINE__, displayTopAllocations);
                         }
                     }
                     else {
                         retval = __LINE__;
                         REPORT_ERROR(__LINE__, sortRun);
                     }
                 }
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, harvestRun);
             }
             /*
              ** Done with the run.
              */
             freeRun(sortedRun);
             sortedRun = NULL;
         }
         else {
             retval = __LINE__;
             REPORT_ERROR(__LINE__, createRun);
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, displayCallsiteDetails);
     }
     return retval;
 }
 #if ST_WANT_GRAPHS
 /*
 ** graphFootprint
 **
 ** Output a PNG graph of the memory usage of the run.
 **
 ** Draw the graph within these boundaries.
 **  STGD_MARGIN,STGD_MARGIN,STGD_WIDTH-STGD_MARGIN,STGD_HEIGHT-STGD_MARGIN
 **
 ** Returns !0 on failure.
 */
 int
 graphFootprint(STRequest * inRequest, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun) {
         uint32_t *YData = NULL;
         uint32_t YDataArray[STGD_SPACE_X];
         uint32_t traverse = 0;
         uint32_t timeval = 0;
         uint32_t loop = 0;
         PRBool underLock = PR_FALSE;
         /*
          ** Decide if this is custom or we should use the cache.
          */
         if (aRun == inRequest->mContext->mSortedRun) {
             YData = inRequest->mContext->mFootprintYData;
             underLock = PR_TRUE;
         }
         else {
             YData = YDataArray;
         }
         /*
          **  Protect the shared data so that only one client has access to it
          **      at any given time.
          */
         if (PR_FALSE != underLock) {
             PR_Lock(inRequest->mContext->mImageLock);
         }
         /*
          ** Only do the computations if we aren't cached already.
          */
         if (YData != inRequest->mContext->mFootprintYData
             || PR_FALSE == inRequest->mContext->mFootprintCached) {
             memset(YData, 0, sizeof(uint32_t) * STGD_SPACE_X);
             /*
              ** Initialize our Y data.
              ** Pretty brutal loop here....
              */
             for (traverse = 0; 0 == retval && traverse < STGD_SPACE_X;
                  traverse++) {
                 /*
                  ** Compute what timeval this Y data lands in.
                  */
                 timeval =
                     ((traverse *
                       (globals.mMaxTimeval -
                        globals.mMinTimeval)) / STGD_SPACE_X) +
                     globals.mMinTimeval;
                 /*
                  ** Loop over the run.
                  ** Should an allocation contain said Timeval, we're good.
                  */
                 for (loop = 0; loop < aRun->mAllocationCount; loop++) {
                     if (timeval >= aRun->mAllocations[loop]->mMinTimeval
                         && timeval <= aRun->mAllocations[loop]->mMaxTimeval) {
                         YData[traverse] +=
                             byteSize(&inRequest->mOptions,
                                      aRun->mAllocations[loop]);
                     }
                 }
             }
             /*
              ** Did we cache this?
              */
             if (YData == inRequest->mContext->mFootprintYData) {
                 inRequest->mContext->mFootprintCached = PR_TRUE;
             }
         }
         /*
          **  Done with the lock.
          */
         if (PR_FALSE != underLock) {
             PR_Unlock(inRequest->mContext->mImageLock);
         }
         if (0 == retval) {
             uint32_t minMemory = (uint32_t) - 1;
             uint32_t maxMemory = 0;
             int transparent = 0;
             gdImagePtr graph = NULL;
             /*
              ** Go through and find the minimum and maximum sizes.
              */
             for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                 if (YData[traverse] < minMemory) {
                     minMemory = YData[traverse];
                 }
                 if (YData[traverse] > maxMemory) {
                     maxMemory = YData[traverse];
                 }
             }
             /*
              ** We can now draw the graph.
              */
             graph = createGraph(&transparent);
             if (NULL != graph) {
                 gdSink theSink;
                 int red = 0;
                 int x1 = 0;
                 int y1 = 0;
                 int x2 = 0;
                 int y2 = 0;
                 uint32_t percents[11] =
                     { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
                 char *timevals[11];
                 char *bytes[11];
                 char timevalSpace[11][32];
                 char byteSpace[11][32];
                 int legendColors[1];
                 const char *legends[1] = { "Memory in Use" };
                 uint32_t cached = 0;
                 /*
                  ** Figure out what the labels will say.
                  */
                 for (traverse = 0; traverse < 11; traverse++) {
                     timevals[traverse] = timevalSpace[traverse];
                     bytes[traverse] = byteSpace[traverse];
                     cached =
                         ((globals.mMaxTimeval -
                           globals.mMinTimeval) * percents[traverse]) / 100;
                     PR_snprintf(timevals[traverse], 32, ST_TIMEVAL_FORMAT,
                                 ST_TIMEVAL_PRINTABLE(cached));
                     PR_snprintf(bytes[traverse], 32, "%u",
                                 ((maxMemory -
                                   minMemory) * percents[traverse]) / 100);
                 }
                 red = gdImageColorAllocate(graph, 255, 0, 0);
                 legendColors[0] = red;
                 drawGraph(graph, -1, "Memory Footprint Over Time", "Seconds",
                           "Bytes", 11, percents, (const char **) timevals, 11,
                           percents, (const char **) bytes, 1, legendColors,
                           legends);
                 if (maxMemory != minMemory) {
                     int64_t in64 = 0;
                     int64_t ydata64 = 0;
                     int64_t spacey64 = 0;
                     int64_t mem64 = 0;
                     int32_t in32 = 0;
                     /*
                      ** Go through our Y data and mark it up.
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
                         /*
                          ** Need to do this math in 64 bits.
                          */
                         ydata64 = (int64_t)YData[traverse];
                         spacey64 = (int64_t)STGD_SPACE_Y;
                         mem64 = (int64_t)(maxMemory - minMemory);
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
                         x2 = x1;
                         y2 = y1 - in32;
                         gdImageLine(graph, x1, y1, x2, y2, red);
                     }
                 }
                 theSink.context = inRequest->mFD;
                 theSink.sink = pngSink;
                 gdImagePngToSink(graph, &theSink);
                 gdImageDestroy(graph);
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, createGraph);
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, graphFootprint);
     }
     return retval;
 }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
 /*
 ** graphTimeval
 **
 ** Output a PNG graph of when the memory is allocated.
 **
 ** Draw the graph within these boundaries.
 **  STGD_MARGIN,STGD_MARGIN,STGD_WIDTH-STGD_MARGIN,STGD_HEIGHT-STGD_MARGIN
 **
 ** Returns !0 on failure.
 */
 int
 graphTimeval(STRequest * inRequest, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun) {
         uint32_t *YData = NULL;
         uint32_t YDataArray[STGD_SPACE_X];
         uint32_t traverse = 0;
         uint32_t timeval = globals.mMinTimeval;
         uint32_t loop = 0;
         PRBool underLock = PR_FALSE;
         /*
          ** Decide if this is custom or we should use the global cache.
          */
         if (aRun == inRequest->mContext->mSortedRun) {
             YData = inRequest->mContext->mTimevalYData;
             underLock = PR_TRUE;
         }
         else {
             YData = YDataArray;
         }
         /*
          **  Protect the shared data so that only one client has access to it
          **      at any given time.
          */
         if (PR_FALSE != underLock) {
             PR_Lock(inRequest->mContext->mImageLock);
         }
         /*
          ** Only do the computations if we aren't cached already.
          */
         if (YData != inRequest->mContext->mTimevalYData
             || PR_FALSE == inRequest->mContext->mTimevalCached) {
             uint32_t prevTimeval = 0;
             memset(YData, 0, sizeof(uint32_t) * STGD_SPACE_X);
             /*
              ** Initialize our Y data.
              ** Pretty brutal loop here....
              */
             for (traverse = 0; 0 == retval && traverse < STGD_SPACE_X;
                  traverse++) {
                 /*
                  ** Compute what timeval this Y data lands in.
                  */
                 prevTimeval = timeval;
                 timeval =
                     ((traverse *
                       (globals.mMaxTimeval -
                        globals.mMinTimeval)) / STGD_SPACE_X) +
                     globals.mMinTimeval;
                 /*
                  ** Loop over the run.
                  ** Should an allocation have been allocated between
                  **  prevTimeval and timeval....
                  */
                 for (loop = 0; loop < aRun->mAllocationCount; loop++) {
                     if (prevTimeval < aRun->mAllocations[loop]->mMinTimeval
                         && timeval >= aRun->mAllocations[loop]->mMinTimeval) {
                         YData[traverse] +=
                             byteSize(&inRequest->mOptions,
                                      aRun->mAllocations[loop]);
                     }
                 }
             }
             /*
              ** Did we cache this?
              */
             if (YData == inRequest->mContext->mTimevalYData) {
                 inRequest->mContext->mTimevalCached = PR_TRUE;
             }
         }
         /*
          **  Done with the lock.
          */
         if (PR_FALSE != underLock) {
             PR_Unlock(inRequest->mContext->mImageLock);
         }
         if (0 == retval) {
             uint32_t minMemory = (uint32_t) - 1;
             uint32_t maxMemory = 0;
             int transparent = 0;
             gdImagePtr graph = NULL;
             /*
              ** Go through and find the minimum and maximum sizes.
              */
             for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                 if (YData[traverse] < minMemory) {
                     minMemory = YData[traverse];
                 }
                 if (YData[traverse] > maxMemory) {
                     maxMemory = YData[traverse];
                 }
             }
             /*
              ** We can now draw the graph.
              */
             graph = createGraph(&transparent);
             if (NULL != graph) {
                 gdSink theSink;
                 int red = 0;
                 int x1 = 0;
                 int y1 = 0;
                 int x2 = 0;
                 int y2 = 0;
                 uint32_t percents[11] =
                     { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
                 char *timevals[11];
                 char *bytes[11];
                 char timevalSpace[11][32];
                 char byteSpace[11][32];
                 int legendColors[1];
                 const char *legends[1] = { "Memory Allocated" };
                 uint32_t cached = 0;
                 /*
                  ** Figure out what the labels will say.
                  */
                 for (traverse = 0; traverse < 11; traverse++) {
                     timevals[traverse] = timevalSpace[traverse];
                     bytes[traverse] = byteSpace[traverse];
                     cached =
                         ((globals.mMaxTimeval -
                           globals.mMinTimeval) * percents[traverse]) / 100;
                     PR_snprintf(timevals[traverse], 32, ST_TIMEVAL_FORMAT,
                                 ST_TIMEVAL_PRINTABLE(cached));
                     PR_snprintf(bytes[traverse], 32, "%u",
                                 ((maxMemory -
                                   minMemory) * percents[traverse]) / 100);
                 }
                 red = gdImageColorAllocate(graph, 255, 0, 0);
                 legendColors[0] = red;
                 drawGraph(graph, -1, "Allocation Times", "Seconds", "Bytes",
 , percents, (const char **) timevals, 11,
                           percents, (const char **) bytes, 1, legendColors,
                           legends);
                 if (maxMemory != minMemory) {
                     int64_t in64 = 0;
                     int64_t ydata64 = 0;
                     int64_t spacey64 = 0;
                     int64_t mem64 = 0;
                     int32_t in32 = 0;
                     /*
                      ** Go through our Y data and mark it up.
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
                         /*
                          ** Need to do this math in 64 bits.
                          */
                         ydata64 = (int64_t)YData[traverse];
                         spacey64 = (int64_t)STGD_SPACE_Y;
                         mem64 = (int64_t)(maxMemory - minMemory);
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
                         x2 = x1;
                         y2 = y1 - in32;
                         gdImageLine(graph, x1, y1, x2, y2, red);
                     }
                 }
                 theSink.context = inRequest->mFD;
                 theSink.sink = pngSink;
                 gdImagePngToSink(graph, &theSink);
                 gdImageDestroy(graph);
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, createGraph);
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, graphTimeval);
     }
     return retval;
 }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
 /*
 ** graphLifespan
 **
 ** Output a PNG graph of how long memory lived.
 **
 ** Draw the graph within these boundaries.
 **  STGD_MARGIN,STGD_MARGIN,STGD_WIDTH-STGD_MARGIN,STGD_HEIGHT-STGD_MARGIN
 **
 ** Returns !0 on failure.
 */
 int
 graphLifespan(STRequest * inRequest, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun) {
         uint32_t *YData = NULL;
         uint32_t YDataArray[STGD_SPACE_X];
         uint32_t traverse = 0;
         uint32_t timeval = 0;
         uint32_t loop = 0;
         PRBool underLock = PR_FALSE;
         /*
          ** Decide if this is custom or we should use the global cache.
          */
         if (aRun == inRequest->mContext->mSortedRun) {
             YData = inRequest->mContext->mLifespanYData;
             underLock = PR_TRUE;
         }
         else {
             YData = YDataArray;
         }
         /*
          **  Protect the shared data so that only one client has access to it
          **      at any given time.
          */
         if (PR_FALSE != underLock) {
             PR_Lock(inRequest->mContext->mImageLock);
         }
         /*
          ** Only do the computations if we aren't cached already.
          */
         if (YData != inRequest->mContext->mLifespanYData
             || PR_FALSE == inRequest->mContext->mLifespanCached) {
             uint32_t prevTimeval = 0;
             uint32_t lifespan = 0;
             memset(YData, 0, sizeof(uint32_t) * STGD_SPACE_X);
             /*
              ** Initialize our Y data.
              ** Pretty brutal loop here....
              */
             for (traverse = 0; 0 == retval && traverse < STGD_SPACE_X;
                  traverse++) {
                 /*
                  ** Compute what timeval this Y data lands in.
                  */
                 prevTimeval = timeval;
                 timeval =
                     (traverse * (globals.mMaxTimeval - globals.mMinTimeval)) /
                     STGD_SPACE_X;
                 /*
                  ** Loop over the run.
                  ** Should an allocation have lived between
                  **  prevTimeval and timeval....
                  */
                 for (loop = 0; loop < aRun->mAllocationCount; loop++) {
                     lifespan =
                         aRun->mAllocations[loop]->mMaxTimeval -
                         aRun->mAllocations[loop]->mMinTimeval;
                     if (prevTimeval < lifespan && timeval >= lifespan) {
                         YData[traverse] +=
                             byteSize(&inRequest->mOptions,
                                      aRun->mAllocations[loop]);
                     }
                 }
             }
             /*
              ** Did we cache this?
              */
             if (YData == inRequest->mContext->mLifespanYData) {
                 inRequest->mContext->mLifespanCached = PR_TRUE;
             }
         }
         /*
          **  Done with the lock.
          */
         if (PR_FALSE != underLock) {
             PR_Unlock(inRequest->mContext->mImageLock);
         }
         if (0 == retval) {
             uint32_t minMemory = (uint32_t) - 1;
             uint32_t maxMemory = 0;
             int transparent = 0;
             gdImagePtr graph = NULL;
             /*
              ** Go through and find the minimum and maximum sizes.
              */
             for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                 if (YData[traverse] < minMemory) {
                     minMemory = YData[traverse];
                 }
                 if (YData[traverse] > maxMemory) {
                     maxMemory = YData[traverse];
                 }
             }
             /*
              ** We can now draw the graph.
              */
             graph = createGraph(&transparent);
             if (NULL != graph) {
                 gdSink theSink;
                 int red = 0;
                 int x1 = 0;
                 int y1 = 0;
                 int x2 = 0;
                 int y2 = 0;
                 uint32_t percents[11] =
                     { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
                 char *timevals[11];
                 char *bytes[11];
                 char timevalSpace[11][32];
                 char byteSpace[11][32];
                 int legendColors[1];
                 const char *legends[1] = { "Live Memory" };
                 uint32_t cached = 0;
                 /*
                  ** Figure out what the labels will say.
                  */
                 for (traverse = 0; traverse < 11; traverse++) {
                     timevals[traverse] = timevalSpace[traverse];
                     bytes[traverse] = byteSpace[traverse];
                     cached =
                         ((globals.mMaxTimeval -
                           globals.mMinTimeval) * percents[traverse]) / 100;
                     PR_snprintf(timevals[traverse], 32, ST_TIMEVAL_FORMAT,
                                 ST_TIMEVAL_PRINTABLE(cached));
                     PR_snprintf(bytes[traverse], 32, "%u",
                                 ((maxMemory -
                                   minMemory) * percents[traverse]) / 100);
                 }
                 red = gdImageColorAllocate(graph, 255, 0, 0);
                 legendColors[0] = red;
                 drawGraph(graph, -1, "Allocation Lifespans", "Lifespan",
                           "Bytes", 11, percents, (const char **) timevals, 11,
                           percents, (const char **) bytes, 1, legendColors,
                           legends);
                 if (maxMemory != minMemory) {
                     int64_t in64 = 0;
                     int64_t ydata64 = 0;
                     int64_t spacey64 = 0;
                     int64_t mem64 = 0;
                     int32_t in32 = 0;
                     /*
                      ** Go through our Y data and mark it up.
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
                         /*
                          ** Need to do this math in 64 bits.
                          */
                         ydata64 = (int64_t)YData[traverse];
                         spacey64 = (int64_t)STGD_SPACE_Y;
                         mem64 = (int64_t)(maxMemory - minMemory);
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
                         x2 = x1;
                         y2 = y1 - in32;
                         gdImageLine(graph, x1, y1, x2, y2, red);
                     }
                 }
                 theSink.context = inRequest->mFD;
                 theSink.sink = pngSink;
                 gdImagePngToSink(graph, &theSink);
                 gdImageDestroy(graph);
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, createGraph);
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, graphLifespan);
     }
     return retval;
 }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
 /*
 ** graphWeight
 **
 ** Output a PNG graph of Allocations by Weight
 **
 ** Draw the graph within these boundaries.
 **  STGD_MARGIN,STGD_MARGIN,STGD_WIDTH-STGD_MARGIN,STGD_HEIGHT-STGD_MARGIN
 **
 ** Returns !0 on failure.
 */
 int
 graphWeight(STRequest * inRequest, STRun * aRun)
 {
     int retval = 0;
     if (NULL != aRun) {
         uint64_t *YData64 = NULL;
         uint64_t YDataArray64[STGD_SPACE_X];
         uint32_t traverse = 0;
         uint32_t timeval = globals.mMinTimeval;
         uint32_t loop = 0;
         PRBool underLock = PR_FALSE;
         /*
          ** Decide if this is custom or we should use the global cache.
          */
         if (aRun == inRequest->mContext->mSortedRun) {
             YData64 = inRequest->mContext->mWeightYData64;
             underLock = PR_TRUE;
         }
         else {
             YData64 = YDataArray64;
         }
         /*
          **  Protect the shared data so that only one client has access to it
          **      at any given time.
          */
         if (PR_FALSE != underLock) {
             PR_Lock(inRequest->mContext->mImageLock);
         }
         /*
          ** Only do the computations if we aren't cached already.
          */
         if (YData64 != inRequest->mContext->mWeightYData64
             || PR_FALSE == inRequest->mContext->mWeightCached) {
             uint32_t prevTimeval = 0;
             memset(YData64, 0, sizeof(uint64_t) * STGD_SPACE_X);
             /*
              ** Initialize our Y data.
              ** Pretty brutal loop here....
              */
             for (traverse = 0; 0 == retval && traverse < STGD_SPACE_X;
                  traverse++) {
                 /*
                  ** Compute what timeval this Y data lands in.
                  */
                 prevTimeval = timeval;
                 timeval =
                     ((traverse *
                       (globals.mMaxTimeval -
                        globals.mMinTimeval)) / STGD_SPACE_X) +
                     globals.mMinTimeval;
                 /*
                  ** Loop over the run.
                  ** Should an allocation have been allocated between
                  **  prevTimeval and timeval....
                  */
                 for (loop = 0; loop < aRun->mAllocationCount; loop++) {
                     if (prevTimeval < aRun->mAllocations[loop]->mMinTimeval
                         && timeval >= aRun->mAllocations[loop]->mMinTimeval) {
                         uint64_t size64 = 0;
                         uint64_t lifespan64 = 0;
                         uint64_t weight64 = 0;
                         size64 = byteSize(&inRequest->mOptions,
                                           aRun->mAllocations[loop]);
                         lifespan64 = aRun->mAllocations[loop]->mMaxTimeval -
                                      aRun->mAllocations[loop]->mMinTimeval;
                         weight64 = size64 * lifespan64;
                         YData64[traverse] += weight64;
                     }
                 }
             }
             /*
              ** Did we cache this?
              */
             if (YData64 == inRequest->mContext->mWeightYData64) {
                 inRequest->mContext->mWeightCached = PR_TRUE;
             }
         }
         /*
          **  Done with the lock.
          */
         if (PR_FALSE != underLock) {
             PR_Unlock(inRequest->mContext->mImageLock);
         }
         if (0 == retval) {
             uint64_t minWeight64 = (0xFFFFFFFFLL << 32) + 0xFFFFFFFFLL;
             uint64_t maxWeight64 = 0;
             int transparent = 0;
             gdImagePtr graph = NULL;
             /*
              ** Go through and find the minimum and maximum weights.
              */
             for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                 if (YData64[traverse] < minWeight64) {
                     minWeight64 = YData64[traverse];
                 }
                 if (YData64[traverse] > maxWeight64) {
                     maxWeight64 = YData64[traverse];
                 }
             }
             /*
              ** We can now draw the graph.
              */
             graph = createGraph(&transparent);
             if (NULL != graph) {
                 gdSink theSink;
                 int red = 0;
                 int x1 = 0;
                 int y1 = 0;
                 int x2 = 0;
                 int y2 = 0;
                 uint32_t percents[11] =
                     { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
                 char *timevals[11];
                 char *bytes[11];
                 char timevalSpace[11][32];
                 char byteSpace[11][32];
                 int legendColors[1];
                 const char *legends[1] = { "Memory Weight" };
                 uint64_t percent64 = 0;
                 uint64_t result64 = 0;
                 uint32_t cached = 0;
                 uint64_t hundred64 = 100;
                 /*
                  ** Figure out what the labels will say.
                  */
                 for (traverse = 0; traverse < 11; traverse++) {
                     timevals[traverse] = timevalSpace[traverse];
                     bytes[traverse] = byteSpace[traverse];
                     cached =
                         ((globals.mMaxTimeval -
                           globals.mMinTimeval) * percents[traverse]) / 100;
                     PR_snprintf(timevals[traverse], 32, ST_TIMEVAL_FORMAT,
                                 ST_TIMEVAL_PRINTABLE(cached));
                     result64 = (maxWeight64 - minWeight64) * percents[traverse];
                     result64 /= hundred64;
                     PR_snprintf(bytes[traverse], 32, "%llu", result64);
                 }
                 red = gdImageColorAllocate(graph, 255, 0, 0);
                 legendColors[0] = red;
                 drawGraph(graph, -1, "Allocation Weights", "Seconds",
                           "Weight", 11, percents, (const char **) timevals,
 , percents, (const char **) bytes, 1,
                           legendColors, legends);
                 if (maxWeight64 != minWeight64) {
                     int64_t in64 = 0;
                     int64_t spacey64 = 0;
                     int64_t weight64 = 0;
                     int32_t in32 = 0;
                     /*
                      ** Go through our Y data and mark it up.
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
                         /*
                          ** Need to do this math in 64 bits.
                          */
                         spacey64 = (int64_t)STGD_SPACE_Y;
                         weight64 = maxWeight64 - minWeight64;
                         in64 = YData64[traverse] * spacey64;
                         in64 /= weight64;
                         in32 = int32_t(in64);
                         x2 = x1;
                         y2 = y1 - in32;
                         gdImageLine(graph, x1, y1, x2, y2, red);
                     }
                 }
                 theSink.context = inRequest->mFD;
                 theSink.sink = pngSink;
                 gdImagePngToSink(graph, &theSink);
                 gdImageDestroy(graph);
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, createGraph);
             }
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, graphWeight);
     }
     return retval;
 }
 #endif /* ST_WANT_GRAPHS */
 #define ST_WEB_OPTION_BOOL(option_name, option_genre, option_help) \
     { \
         uint32_t convert = (uint32_t)outOptions->m##option_name; \
         \
         getDataPRUint32(inFormData, #option_name, 1, &convert, 1); \
         outOptions->m##option_name = (PRBool)convert; \
     }
 #define ST_WEB_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     getDataString(inFormData, #option_name, 1, outOptions->m##option_name, sizeof(outOptions->m##option_name));
 #define ST_WEB_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     { \
         uint32_t loop = 0; \
         uint32_t found = 0; \
         char buffer[ST_OPTION_STRING_MAX]; \
         \
         for(loop = 0; loop < array_size; loop++) \
         { \
             buffer[0] = '\0'; \
             getDataString(inFormData, #option_name, (loop + 1), buffer, sizeof(buffer)); \
             \
             if('\0' != buffer[0]) \
             { \
                 PR_snprintf(outOptions->m##option_name[found], sizeof(outOptions->m##option_name[found]), "%s", buffer); \
                 found++; \
             } \
         } \
         \
         for(; found < array_size; found++) \
         { \
             outOptions->m##option_name[found][0] = '\0'; \
         } \
     }
 #define ST_WEB_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help)  /* no implementation */
 #define ST_WEB_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     getDataPRUint32(inFormData, #option_name, 1, &outOptions->m##option_name, multiplier);
 #define ST_WEB_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     { \
         uint64_t mul64 = multiplier; \
         \
         getDataPRUint64(inFormData, #option_name, 1, &outOptions->m##option_name##64, mul64); \
     }
 /*
 **  fillOptions
 **
 **  Given an appropriate hexcaped string, distill the option values
 **      and fill the given STOption struct.
 **
 **  Note that the options passed in are not touched UNLESS there is
 **      a replacement found in the form data.
 */
 void
 fillOptions(STOptions * outOptions, const FormData * inFormData)
 {
     if (NULL != outOptions && NULL != inFormData) {
 #include "stoptions.h"
         /*
          **  Special sanity check here for some options that need data validation.
          */
         if (!outOptions->mCategoryName[0]
             || !findCategoryNode(outOptions->mCategoryName, &globals)) {
             PR_snprintf(outOptions->mCategoryName,
                         sizeof(outOptions->mCategoryName), "%s",
                         ST_ROOT_CATEGORY_NAME);
         }
     }
 }
 void
 displayOptionString(STRequest * inRequest,
                     const char *option_name,
                     const char *option_genre,
                     const char *default_value,
                     const char *option_help, const char *value)
 {
 #if 0
     PR_fprintf(inRequest->mFD, "<input type=submit value=%s>\n", option_name);
 #endif
     PR_fprintf(inRequest->mFD, "<div class=option-box>\n");
     PR_fprintf(inRequest->mFD, "<p class=option-name>%s</p>\n", option_name);
     PR_fprintf(inRequest->mFD,
                "<input type=text name=\"%s\" value=\"%s\">\n",
                option_name, value);
     PR_fprintf(inRequest->mFD,
                "<p class=option-default>Default value is \"%s\".</p>\n<p class=option-help>%s</p>\n",
                default_value, option_help);
     PR_fprintf(inRequest->mFD, "</div>\n");
 }
 static void
 displayOptionStringArray(STRequest * inRequest,
                          const char *option_name,
                          const char *option_genre,
                          uint32_t array_size,
                          const char *option_help, const char values[5]
                          [ST_OPTION_STRING_MAX])
 {
     /* values should not be a fixed length! */
     PR_ASSERT(array_size == 5);
 #if 0
     PR_fprintf(inRequest->mFD, "<input type=submit value=%s>\n", option_name);
 #endif
     PR_fprintf(inRequest->mFD, "<div class=\"option-box\">\n");
     PR_fprintf(inRequest->mFD, "<p class=option-name>%s</p>\n", option_name); {
         uint32_t loop = 0;
         for (loop = 0; loop < array_size; loop++) {
             PR_fprintf(inRequest->mFD,
                        "<input type=text name=\"%s\" value=\"%s\"><br>\n",
                        option_name, values[loop]);
         }
     }
     PR_fprintf(inRequest->mFD,
                "<p class=option-default>Up to %u occurrences allowed.</p>\n<p class=option-help>%s</p>\n",
                array_size, option_help);
     PR_fprintf(inRequest->mFD, "</div>\n");
 }
 static void
 displayOptionInt(STRequest * inRequest,
                  const char *option_name,
                  const char *option_genre,
                  uint32_t default_value,
                  uint32_t multiplier, const char *option_help, uint32_t value)
 {
 #if 0
     PR_fprintf(inRequest->mFD, "<input type=submit value=%s>\n", option_name);
 #endif
     PR_fprintf(inRequest->mFD, "<div class=\"option-box\">\n");
     PR_fprintf(inRequest->mFD, "<p class=option-name>%s</p>\n", option_name);
     PR_fprintf(inRequest->mFD,
                "<input type=text name=%s value=%u>\n", option_name,
                value / multiplier);
     PR_fprintf(inRequest->mFD,
                "<p class=option-default>Default value is %u.</p>\n<p class=option-help>%s</p>\n",
                default_value, option_help);
     PR_fprintf(inRequest->mFD, "</div>\n");
 }
 static void
 displayOptionInt64(STRequest * inRequest,
                    const char *option_name,
                    const char *option_genre,
                    uint64_t default_value,
                    uint64_t multiplier,
                    const char *option_help, uint64_t value)
 {
 #if 0
     PR_fprintf(inRequest->mFD, "<input type=submit value=%s>\n", option_name);
 #endif
     PR_fprintf(inRequest->mFD, "<div class=\"option-box\">\n");
     PR_fprintf(inRequest->mFD, "<p class=option-name>%s</p>\n", option_name); {
         uint64_t def64 = default_value;
         uint64_t mul64 = multiplier;
         uint64_t div64;
         div64 = value / mul64;
         PR_fprintf(inRequest->mFD,
                    "<input type=text name=%s value=%llu>\n",
                    option_name, div64);
         PR_fprintf(inRequest->mFD,
                    "<p class=option-default>Default value is %llu.</p>\n<p class=option-help>%s</p>\n",
                    def64, option_help);
     }
     PR_fprintf(inRequest->mFD, "</div>\n");
 }
 /*
 **  displaySettings
 **
 **  Present the settings for change during execution.
 */
 void
 displaySettings(STRequest * inRequest)
 {
     int applyRes = 0;
     /*
      ** We've got a form to create.
      */
     PR_fprintf(inRequest->mFD, "<form method=get action=\"./index.html\">\n");
     /*
      **  Respect newlines in help text.
      */
 #if 0
     PR_fprintf(inRequest->mFD, "<pre>\n");
 #endif
 #define ST_WEB_OPTION_BOOL(option_name, option_genre, option_help) \
     displayOptionBool(option_name, option_genre, option_help)
 #define ST_WEB_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     displayOptionString(inRequest, #option_name, #option_genre, default_value, option_help, inRequest->mOptions.m##option_name);
 #define ST_WEB_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     displayOptionStringArray(inRequest, #option_name, #option_genre, array_size, option_help, inRequest->mOptions.m##option_name);
 #define ST_WEB_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help)  /* no implementation */
 #define ST_WEB_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     displayOptionInt(inRequest, #option_name, #option_genre, default_value, multiplier, option_help, inRequest->mOptions.m##option_name);
 #define ST_WEB_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     displayOptionInt64(inRequest, #option_name, #option_genre, default_value, multiplier, option_help, inRequest->mOptions.m##option_name##64);
 #include "stoptions.h"
     /*
      **  Give a submit/reset button, obligatory.
      **  Done respecting newlines in help text.
      */
     PR_fprintf(inRequest->mFD,
                "<input type=submit value=\"Save Options\"> <input type=reset>\n");
 #if 0
     PR_fprintf(inRequest->mFD, "</pre>\n");
 #endif
     /*
      ** Done with form.
      */
     PR_fprintf(inRequest->mFD, "</form>\n");
 }
 int
 handleLocalFile(STRequest * inRequest, const char *aFilename)
 {
     static const char *const local_files[] = {
         "spacetrace.css",
     };
     static const size_t local_file_count =
         sizeof(local_files) / sizeof(local_files[0]);
     size_t i;
     for (i = 0; i < local_file_count; i++) {
         if (0 == strcmp(local_files[i], aFilename))
             return 1;
     }
     return 0;
 }
 /*
 ** displayFile
 **
 ** reads a file from disk, and streams it to the request
 */
 int
 displayFile(STRequest * inRequest, const char *aFilename)
 {
     PRFileDesc *inFd;
     const char *filepath =
         PR_smprintf("res%c%s", PR_GetDirectorySeparator(), aFilename);
     char buffer[2048];
     int32_t readRes;
     inFd = PR_Open(filepath, PR_RDONLY, PR_IRUSR);
     if (!inFd)
         return -1;
     while ((readRes = PR_Read(inFd, buffer, sizeof(buffer))) > 0) {
         PR_Write(inRequest->mFD, buffer, readRes);
     }
     if (readRes != 0)
         return -1;
     PR_Close(inFd);
     return 0;
 }
 /*
 ** displayIndex
 **
 ** Present a list of the reports you can drill down into.
 ** Returns !0 on failure.
 */
 int
 displayIndex(STRequest * inRequest)
 {
     int retval = 0;
     STOptions *options = &inRequest->mOptions;
     /*
      ** Present reports in a list format.
      */
     PR_fprintf(inRequest->mFD, "<ul>");
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "root_callsites.html", "Root Callsites",
                NULL, "mainmenu", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "categories_summary.html",
                "Categories Report", NULL, "mainmenu", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "top_callsites.html",
                "Top Callsites Report", NULL, "mainmenu", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "top_allocations.html",
                "Top Allocations Report", NULL, "mainmenu", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "memory_leaks.html",
                "Memory Leak Report", NULL, "mainmenu", options);
 #if ST_WANT_GRAPHS
     PR_fprintf(inRequest->mFD, "\n<li>Graphs");
     PR_fprintf(inRequest->mFD, "<ul>");
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "footprint_graph.html", "Footprint",
                NULL, "mainmenu graph", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "lifespan_graph.html",
                "Allocation Lifespans", NULL, "mainmenu graph", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "times_graph.html", "Allocation Times",
                NULL, "mainmenu graph", options);
     PR_fprintf(inRequest->mFD, "\n<li>");
     htmlAnchor(inRequest, "weight_graph.html",
                "Allocation Weights", NULL, "mainmenu graph", options);
     PR_fprintf(inRequest->mFD, "\n</ul>\n");
 #endif /* ST_WANT_GRAPHS */
     PR_fprintf(inRequest->mFD, "\n</ul>\n");
     return retval;
 }
 /*
 **  initRequestOptions
 **
 **  Given the request, set the options that are specific to the request.
 **  These can generally be determined in the following manner:
 **      Copy over global options.
 **      If getData present, attempt to use options therein.
 */
 void
 initRequestOptions(STRequest * inRequest)
 {
     if (NULL != inRequest) {
         /*
          **  Copy of global options.
          */
         memcpy(&inRequest->mOptions, &globals.mCommandLineOptions,
                sizeof(globals.mCommandLineOptions));
         /*
          **  Decide what will override global options if anything.
          */
         if (NULL != inRequest->mGetData) {
             fillOptions(&inRequest->mOptions, inRequest->mGetData);
         }
     }
 }
 STContext *
 contextLookup(STOptions * inOptions)
 /*
 **  Lookup a context that matches the options.
 **  The lookup may block, especially if the context needs to be created.
 **  Callers of this API must eventually call contextRelease with the
 **      return value;  failure to do so will cause this applications
 **      to eventually not work as advertised.
 **
 **  inOptions   The options determine which context is relevant.
 **  returns     The fully completed context on success.
 **              The context is read only in practice, so please do not
 **                  write to it or anything it points to.
 **              NULL on failure.
 */
 {
     STContext *retval = NULL;
     STContextCache *inCache = &globals.mContextCache;
     if (NULL != inOptions && NULL != inCache) {
         uint32_t loop = 0;
         STContext *categoryException = NULL;
         PRBool newContext = PR_FALSE;
         PRBool evictContext = PR_FALSE;
         PRBool changeCategoryContext = PR_FALSE;
         /*
          **  Own the context cache while we are in here.
          */
         PR_Lock(inCache->mLock);
         /*
          **  Loop until successful.
          **  Waiting on the condition variable makes sure we don't hog the
          **      lock below.
          */
         while (1) {
             /*
              **  Go over the cache items.
              **  At this point we are looking for a cache hit, with multiple
              **      readers.
              */
             for (loop = 0; loop < inCache->mItemCount; loop++) {
                 /*
                  **  Must be in use.
                  */
                 if (PR_FALSE != inCache->mItems[loop].mInUse) {
                     int delta[(STOptionGenre) MaxGenres];
                     /*
                      **  Compare the relevant options, figure out if different
                      **      in any genre that we care about.
                      */
                     memset(&delta, 0, sizeof(delta));
 #define ST_WEB_OPTION_BOOL(option_name, option_genre, option_help) \
     if(inOptions->m##option_name != inCache->mItems[loop].mOptions.m##option_name) \
     { \
         delta[(STOptionGenre)option_genre]++; \
     }
 #define ST_WEB_OPTION_STRING(option_name, option_genre, default_value, option_help) \
     if(0 != strcmp(inOptions->m##option_name, inCache->mItems[loop].mOptions.m##option_name)) \
     { \
         delta[(STOptionGenre)option_genre]++; \
     }
 #define ST_WEB_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \
     { \
         uint32_t macro_loop = 0; \
         \
         for(macro_loop = 0; macro_loop < array_size; macro_loop++) \
         { \
             if(0 != strcmp(inOptions->m##option_name[macro_loop], inCache->mItems[loop].mOptions.m##option_name[macro_loop])) \
             { \
                 break; \
             } \
         } \
         \
         if(macro_loop != array_size) \
         { \
             delta[(STOptionGenre)option_genre]++; \
         } \
     }
 #define ST_WEB_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help)  /* no implementation */
 #define ST_WEB_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \
     if(inOptions->m##option_name != inCache->mItems[loop].mOptions.m##option_name) \
     { \
         delta[(STOptionGenre)option_genre]++; \
     }
 #define ST_WEB_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \
     if(inOptions->m##option_name##64 != inCache->mItems[loop].mOptions.m##option_name##64) \
     { \
         delta[(STOptionGenre)option_genre]++; \
     }
 #include "stoptions.h"
                     /*
                      **  If there is no genre out of alignment, we accept this as the context.
                      */
                     if (0 == delta[CategoryGenre] &&
 == delta[DataSortGenre] &&
 == delta[DataSetGenre] && 0 == delta[DataSizeGenre]
                         ) {
                         retval = &inCache->mItems[loop].mContext;
                         break;
                     }
                     /*
                      **  A special exception to the rule here.
                      **  If all that is different is the category genre, and there
                      **      is no one looking at the context (zero ref count),
                      **      then there is some magic we can perform.
                      */
                     if (NULL == retval &&
 == inCache->mItems[loop].mReferenceCount &&
 != delta[CategoryGenre] &&
 == delta[DataSortGenre] &&
 == delta[DataSetGenre] && 0 == delta[DataSizeGenre]
                         ) {
                         categoryException = &inCache->mItems[loop].mContext;
                     }
                 }
             }
             /*
              **  Pick up our category exception if relevant.
              */
             if (NULL == retval && NULL != categoryException) {
                 retval = categoryException;
                 categoryException = NULL;
                 changeCategoryContext = PR_TRUE;
             }
             /*
              **  If we don't have a cache hit, then we need to check for an empty
              **      spot to take over.
              */
             if (NULL == retval) {
                 for (loop = 0; loop < inCache->mItemCount; loop++) {
                     /*
                      **  Must NOT be in use, then it will be the context.
                      */
                     if (PR_FALSE == inCache->mItems[loop].mInUse) {
                         retval = &inCache->mItems[loop].mContext;
                         newContext = PR_TRUE;
                         break;
                     }
                 }
             }
             /*
              **  If we still don't have a return value, then we need to see if
              **      there are any old items with zero ref counts that we
              **      can take over.
              */
             if (NULL == retval) {
                 for (loop = 0; loop < inCache->mItemCount; loop++) {
                     /*
                      **  Must be in use.
                      */
                     if (PR_FALSE != inCache->mItems[loop].mInUse) {
                         /*
                          **  Must have a ref count of zero.
                          */
                         if (0 == inCache->mItems[loop].mReferenceCount) {
                             /*
                              **  Must be older than any other we know of.
                              */
                             if (NULL != retval) {
                                 if (inCache->mItems[loop].mLastAccessed <
                                     inCache->mItems[retval->mIndex].
                                     mLastAccessed) {
                                     retval = &inCache->mItems[loop].mContext;
                                 }
                             }
                             else {
                                 retval = &inCache->mItems[loop].mContext;
                             }
                         }
                     }
                 }
                 if (NULL != retval) {
                     evictContext = PR_TRUE;
                 }
             }
             /*
              **  If we still don't have a return value, then we can not avoid
              **      waiting around until someone gives us the chance.
              **  The chance, in specific, comes when a cache item reference
              **      count returns to zero, upon which we can try to take
              **      it over again.
              */
             if (NULL == retval) {
                 /*
                  **  This has the side effect of release the context lock.
                  **  This is a good thing so that other clients can continue
                  **      to connect and hopefully have cache hits.
                  **  If they do not have cache hits, then we will end up
                  **      with a bunch of waiters here....
                  */
                 PR_WaitCondVar(inCache->mCacheMiss, PR_INTERVAL_NO_TIMEOUT);
             }
             /*
              **  If we have a return value, improve the reference count here.
              */
             if (NULL != retval) {
                 /*
                  **  Decide if there are any changes to be made.
                  **  Do as little as possible, then fall through the context
                  **      cache lock to finish up.
                  **  This way, lengthy init operations will not block
                  **      other clients, only matches to this context.
                  */
                 if (PR_FALSE != newContext ||
                     PR_FALSE != evictContext ||
                     PR_FALSE != changeCategoryContext) {
                     /*
                      **  Overwrite the prefs for this context.
                      **  They are changing.
                      */
                     memcpy(&inCache->mItems[retval->mIndex].mOptions,
                            inOptions,
                            sizeof(inCache->mItems[retval->mIndex].mOptions));
                     /*
                      **  As we are going to be changing the context, we need to write lock it.
                      **  This makes sure no readers are allowed while we are making our changes.
                      */
                     PR_RWLock_Wlock(retval->mRWLock);
                 }
                 /*
                  **  NOTE, ref count gets incremented here, inside content
                  **      cache lock so it can not be flushed once lock
                  **      released.
                  */
                 inCache->mItems[retval->mIndex].mInUse = PR_TRUE;
                 inCache->mItems[retval->mIndex].mReferenceCount++;
                 /*
                  **  That's all folks.
                  */
                 break;
             }
         }                       /* while(1), try again */
         /*
          **  Done with context cache.
          */
         PR_Unlock(inCache->mLock);
         /*
          **  Now that the context cached is free to continue accepting other
          **      requests, we have a little more work to do.
          */
         if (NULL != retval) {
             PRBool unlock = PR_FALSE;
             /*
              **  If evicting, we need to free off the old stuff.
              */
             if (PR_FALSE != evictContext) {
                 unlock = PR_TRUE;
                 /*
                  **  We do not free the sorted run.
                  **  The category code takes care of this.
                  */
                 retval->mSortedRun = NULL;
 #if ST_WANT_GRAPHS
                 /*
                  **  There is no need to
                  **      PR_Lock(retval->mImageLock)
                  **  We are already under write lock for the entire structure.
                  */
                 retval->mFootprintCached = PR_FALSE;
                 retval->mTimevalCached = PR_FALSE;
                 retval->mLifespanCached = PR_FALSE;
                 retval->mWeightCached = PR_FALSE;
 #endif
             }
             /*
              **  If new or recently evicted, we need to fully init.
              */
             if (PR_FALSE != newContext || PR_FALSE != evictContext) {
                 unlock = PR_TRUE;
                 retval->mSortedRun =
                     createRunFromGlobal(&inCache->mItems[retval->mIndex].
                                         mOptions,
                                         &inCache->mItems[retval->mIndex].
                                         mContext);
             }
             /*
              **  If changing category, we need to do some sneaky stuff.
              */
             if (PR_FALSE != changeCategoryContext) {
                 STCategoryNode *node = NULL;
                 unlock = PR_TRUE;
                 /*
                  ** Just a category change. We don't need to harvest. Just find the
                  ** right node and set the cache.mSortedRun. We need to recompute
                  ** cost though. But that is cheap.
                  */
                 node =
                     findCategoryNode(inCache->mItems[retval->mIndex].mOptions.
                                      mCategoryName, &globals);
                 if (node) {
                     /* Recalculate cost of run */
                     recalculateRunCost(&inCache->mItems[retval->mIndex].
                                        mOptions, retval,
                                        node->runs[retval->mIndex]);
                     retval->mSortedRun = node->runs[retval->mIndex];
                 }
 #if ST_WANT_GRAPHS
                 /*
                  **  There is no need to
                  **      PR_Lock(retval->mImageLock)
                  **  We are already under write lock for the entire structure.
                  */
                 retval->mFootprintCached = PR_FALSE;
                 retval->mTimevalCached = PR_FALSE;
                 retval->mLifespanCached = PR_FALSE;
                 retval->mWeightCached = PR_FALSE;
 #endif
             }
             /*
              **  Release the write lock if we took one to make changes.
              */
             if (PR_FALSE != unlock) {
                 PR_RWLock_Unlock(retval->mRWLock);
             }
             /*
              **  Last thing possible, take a read lock on our return value.
              **  This will cause us to block if the context is not fully
              **      initialized in another thread holding the write lock.
              */
             PR_RWLock_Rlock(retval->mRWLock);
         }
     }
     return retval;
 }
 void
 contextRelease(STContext * inContext)
 /*
 **  After a successful call to contextLookup, one should call this API when
 **      done with the context.
 **  This effectively removes the usage of the client on a cached item.
 */
 {
     STContextCache *inCache = &globals.mContextCache;
     if (NULL != inContext && NULL != inCache) {
         /*
          **  Own the context cache while in here.
          */
         PR_Lock(inCache->mLock);
         /*
          **  Give up the read lock on the context.
          */
         PR_RWLock_Unlock(inContext->mRWLock);
         /*
          **  Decrement the reference count on the context.
          **  If it was the last reference, notify that a new item is
          **      available for eviction.
          **  A waiting thread will wake up and eat it.
          **  Also set when it was last accessed so the oldest unused item
          **      can be targeted for eviction.
          */
         inCache->mItems[inContext->mIndex].mReferenceCount--;
         if (0 == inCache->mItems[inContext->mIndex].mReferenceCount) {
             PR_NotifyCondVar(inCache->mCacheMiss);
             inCache->mItems[inContext->mIndex].mLastAccessed =
                 PR_IntervalNow();
         }
         /*
          **  Done with context cache.
          */
         PR_Unlock(inCache->mLock);
     }
 }
 /*
 ** handleRequest
 **
 ** Based on what file they are asking for, perform some processing.
 ** Output the results to aFD.
 **
 ** Returns !0 on error.
 */
 int
 handleRequest(tmreader * aTMR, PRFileDesc * aFD,
               const char *aFileName, const FormData * aGetData)
 {
     int retval = 0;
     if (NULL != aTMR && NULL != aFD && NULL != aFileName
         && '\0' != *aFileName) {
         STRequest request;
         /*
          ** Init the request.
          */
         memset(&request, 0, sizeof(request));
         request.mFD = aFD;
         request.mGetFileName = aFileName;
         request.mGetData = aGetData;
         /*
          **  Set local options for this request.
          */
         initRequestOptions(&request);
         /*
          **  Get our cached context for this client.
          **  Simply based on the options.
          */
         request.mContext = contextLookup(&request.mOptions);
         if (NULL != request.mContext) {
             /*
              ** Attempt to find the file of interest.
              */
             if (handleLocalFile(&request, aFileName)) {
                 displayFile(&request, aFileName);
             }
             else if (0 == strcmp("index.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Index");
                 displayRes = displayIndex(&request);
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayIndex);
                 }
                 htmlFooter(&request);
             }
             else if (0 == strcmp("settings.html", aFileName) ||
 == strcmp("options.html", aFileName)) {
                 htmlHeader(&request, "SpaceTrace Options");
                 displaySettings(&request);
                 htmlFooter(&request);
             }
             else if (0 == strcmp("top_allocations.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Top Allocations Report");
                 displayRes =
                     displayTopAllocations(&request,
                                           request.mContext->mSortedRun,
                                           "top-allocations",
                                           "SpaceTrace Top Allocations Report",
 );
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayTopAllocations);
                 }
                 htmlFooter(&request);
             }
             else if (0 == strcmp("top_callsites.html", aFileName)) {
                 int displayRes = 0;
                 tmcallsite **array = NULL;
                 uint32_t arrayCount = 0;
                 /*
                  ** Display header after we figure out if we are going to focus
                  ** on a category.
                  */
                 htmlHeader(&request, "SpaceTrace Top Callsites Report");
                 if (NULL != request.mContext->mSortedRun
                     && 0 < request.mContext->mSortedRun->mAllocationCount) {
                     arrayCount =
                         callsiteArrayFromRun(&array, 0,
                                              request.mContext->mSortedRun);
                     if (0 != arrayCount && NULL != array) {
                         displayRes =
                             displayTopCallsites(&request, array, arrayCount,
 ,
                                                 "top-callsites",
                                                 "Top Callsites Report",
 );
                         if (0 != displayRes) {
                             retval = __LINE__;
                             REPORT_ERROR(__LINE__, displayTopCallsites);
                         }
                         /*
                          ** Done with the array.
                          */
                         free(array);
                         array = NULL;
                     }
                 }
                 else {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, handleRequest);
                 }
                 htmlFooter(&request);
             }
             else if (0 == strcmp("memory_leaks.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Memory Leaks Report");
                 displayRes =
                     displayMemoryLeaks(&request,
                                        request.mContext->mSortedRun);
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayMemoryLeaks);
                 }
                 htmlFooter(&request);
             }
             else if (0 == strncmp("allocation_", aFileName, 11)) {
                 int scanRes = 0;
                 uint32_t allocationIndex = 0;
                 /*
                  ** Oh, what a hack....
                  ** The index to the allocation structure in the global run
                  **   is in the filename.  Better than the pointer value....
                  */
                 scanRes = PR_sscanf(aFileName + 11, "%u", &allocationIndex);
                 if (1 == scanRes
                     && globals.mRun.mAllocationCount > allocationIndex
                     && NULL != globals.mRun.mAllocations[allocationIndex]) {
                     STAllocation *allocation =
                         globals.mRun.mAllocations[allocationIndex];
                     char buffer[128];
                     int displayRes = 0;
                     PR_snprintf(buffer, sizeof(buffer),
                                 "SpaceTrace Allocation %u Details Report",
                                 allocationIndex);
                     htmlHeader(&request, buffer);
                     displayRes =
                         displayAllocationDetails(&request, allocation);
                     if (0 != displayRes) {
                         retval = __LINE__;
                         REPORT_ERROR(__LINE__, displayAllocationDetails);
                     }
                     htmlFooter(&request);
                 }
                 else {
                     htmlNotFound(&request);
                 }
             }
             else if (0 == strncmp("callsite_", aFileName, 9)) {
                 int scanRes = 0;
                 uint32_t callsiteSerial = 0;
                 tmcallsite *resolved = NULL;
                 /*
                  ** Oh, what a hack....
                  ** The serial(key) to the callsite structure in the hash table
                  **   is in the filename.  Better than the pointer value....
                  */
                 scanRes = PR_sscanf(aFileName + 9, "%u", &callsiteSerial);
                 if (1 == scanRes && 0 != callsiteSerial
                     && NULL != (resolved =
                                 tmreader_callsite(aTMR, callsiteSerial))) {
                     char buffer[128];
                     int displayRes = 0;
                     PR_snprintf(buffer, sizeof(buffer),
                                 "SpaceTrace Callsite %u Details Report",
                                 callsiteSerial);
                     htmlHeader(&request, buffer);
                     displayRes = displayCallsiteDetails(&request, resolved);
                     if (0 != displayRes) {
                         retval = __LINE__;
                         REPORT_ERROR(__LINE__, displayAllocationDetails);
                     }
                     htmlFooter(&request);
                 }
                 else {
                     htmlNotFound(&request);
                 }
             }
             else if (0 == strcmp("root_callsites.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Root Callsites");
                 displayRes =
                     displayCallsites(&request, aTMR->calltree_root.kids,
                                      ST_FOLLOW_SIBLINGS, 0,
                                      "callsites-root",
                                      "SpaceTrace Root Callsites",
                                      __LINE__);
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayCallsites);
                 }
                 htmlFooter(&request);
             }
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("footprint_graph.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Memory Footprint Report");
                 PR_fprintf(request.mFD, "<div align=center>\n");
                 PR_fprintf(request.mFD, "<img src=\"./footprint.png");
                 optionGetDataOut(request.mFD, &request.mOptions);
                 PR_fprintf(request.mFD, "\">\n");
                 PR_fprintf(request.mFD, "</div>\n");
                 htmlFooter(&request);
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("times_graph.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Allocation Times Report");
                 PR_fprintf(request.mFD, "<div align=center>\n");
                 PR_fprintf(request.mFD, "<img src=\"./times.png");
                 optionGetDataOut(request.mFD, &request.mOptions);
                 PR_fprintf(request.mFD, "\">\n");
                 PR_fprintf(request.mFD, "</div>\n");
                 htmlFooter(&request);
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("lifespan_graph.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request,
                            "SpaceTrace Allocation Lifespans Report");
                 PR_fprintf(request.mFD, "<div align=center>\n");
                 PR_fprintf(request.mFD, "<img src=\"./lifespan.png");
                 optionGetDataOut(request.mFD, &request.mOptions);
                 PR_fprintf(request.mFD, "\">\n");
                 PR_fprintf(request.mFD, "</div>\n");
                 htmlFooter(&request);
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("weight_graph.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "SpaceTrace Allocation Weights Report");
                 PR_fprintf(request.mFD, "<div align=center>\n");
                 PR_fprintf(request.mFD, "<img src=\"./weight.png");
                 optionGetDataOut(request.mFD, &request.mOptions);
                 PR_fprintf(request.mFD, "\">\n");
                 PR_fprintf(request.mFD, "</div>\n");
                 htmlFooter(&request);
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("footprint.png", aFileName)) {
                 int graphRes = 0;
                 graphRes =
                     graphFootprint(&request, request.mContext->mSortedRun);
                 if (0 != graphRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, graphFootprint);
                 }
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("times.png", aFileName)) {
                 int graphRes = 0;
                 graphRes =
                     graphTimeval(&request, request.mContext->mSortedRun);
                 if (0 != graphRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, graphTimeval);
                 }
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("lifespan.png", aFileName)) {
                 int graphRes = 0;
                 graphRes =
                     graphLifespan(&request, request.mContext->mSortedRun);
                 if (0 != graphRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, graphLifespan);
                 }
             }
 #endif /* ST_WANT_GRAPHS */
 #if ST_WANT_GRAPHS
             else if (0 == strcmp("weight.png", aFileName)) {
                 int graphRes = 0;
                 graphRes =
                     graphWeight(&request, request.mContext->mSortedRun);
                 if (0 != graphRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, graphWeight);
                 }
             }
 #endif /* ST_WANT_GRAPHS */
             else if (0 == strcmp("categories_summary.html", aFileName)) {
                 int displayRes = 0;
                 htmlHeader(&request, "Category Report");
                 displayRes =
                     displayCategoryReport(&request, &globals.mCategoryRoot,
 );
                 if (0 != displayRes) {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, displayMemoryLeaks);
                 }
                 htmlFooter(&request);
             }
             else {
                 htmlNotFound(&request);
             }
             /*
              **  Release the context we obtained earlier.
              */
             contextRelease(request.mContext);
             request.mContext = NULL;
         }
         else {
             retval = __LINE__;
             REPORT_ERROR(__LINE__, contextObtain);
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, handleRequest);
     }
     /*
      ** Compact a little if you can after each request.
      */
     heapCompact();
     return retval;
 }
 /*
 ** handleClient
 **
 **  main() of the new client thread.
 ** Read the fd for the request.
 ** Output the results.
 */
 void
 handleClient(void *inArg)
 {
     PRFileDesc *aFD = NULL;
     aFD = (PRFileDesc *) inArg;
     if (NULL != aFD) {
         PRStatus closeRes = PR_SUCCESS;
         char aBuffer[2048];
         int32_t readRes = 0;
         readRes = PR_Read(aFD, aBuffer, sizeof(aBuffer));
         if (0 <= readRes) {
             const char *sanityCheck = "GET /";
             if (0 == strncmp(sanityCheck, aBuffer, 5)) {
                 char *eourl = NULL;
                 char *start = &aBuffer[5];
                 char *getData = NULL;
                 int realFun = 0;
                 const char *crlf = "\015\012";
                 char *eoline = NULL;
                 FormData *fdGet = NULL;
                 /*
                  ** Truncate the line if possible.
                  ** Only want first one.
                  */
                 eoline = strstr(aBuffer, crlf);
                 if (NULL != eoline) {
                     *eoline = '\0';
                 }
                 /*
                  ** Find the whitespace.
                  ** That is either end of line or the " HTTP/1.x" suffix.
                  ** We do not care.
                  */
                 for (eourl = start; 0 == isspace(*eourl) && '\0' != *eourl;
                      eourl++) {
                     /*
                      ** No body.
                      */
                 }
                 /*
                  ** Cap it off.
                  ** Convert empty '/' to index.html.
                  */
                 *eourl = '\0';
                 if ('\0' == *start) {
                     strcpy(start, "index.html");
                 }
                 /*
                  ** Have we got any GET form data?
                  */
                 getData = strchr(start, '?');
                 if (NULL != getData) {
                     /*
                      ** Whack it off.
                      */
                     *getData = '\0';
                     getData++;
                 }
                 /*
                  **  Convert get data into a more useful format.
                  */
                 fdGet = FormData_Create(getData);
                 /*
                  ** This is totally a hack, but oh well....
                  **
                  ** Send that the request was OK, regardless.
                  **
                  ** If we have any get data, then it is a set of options
                  **      we attempt to apply.
                  **
                  ** Other code will tell the user they were wrong or if
                  **      there was an error.
                  ** If the filename contains a ".png", then send the image
                  **      mime type, otherwise, say it is text/html.
                  */
                 PR_fprintf(aFD, "HTTP/1.1 200 OK%s", crlf);
                 PR_fprintf(aFD, "Server: %s%s",
                            "$Id: spacetrace.c,v 1.54 2006/11/01 23:02:17 timeless%mozdev.org Exp $",
                            crlf);
                 PR_fprintf(aFD, "Content-type: ");
                 if (NULL != strstr(start, ".png")) {
                     PR_fprintf(aFD, "image/png");
                 }
                 else if (NULL != strstr(start, ".jpg")) {
                     PR_fprintf(aFD, "image/jpeg");
                 }
                 else if (NULL != strstr(start, ".txt")) {
                     PR_fprintf(aFD, "text/plain");
                 }
                 else if (NULL != strstr(start, ".css")) {
                     PR_fprintf(aFD, "text/css");
                 }
                 else {
                     PR_fprintf(aFD, "text/html");
                 }
                 PR_fprintf(aFD, crlf);
                 /*
                  ** One more to separate headers from content.
                  */
                 PR_fprintf(aFD, crlf);
                 /*
                  ** Ready for the real fun.
                  */
                 realFun = handleRequest(globals.mTMR, aFD, start, fdGet);
                 if (0 != realFun) {
                     REPORT_ERROR(__LINE__, handleRequest);
                 }
                 /*
                  **  Free off get data if around.
                  */
                 FormData_Destroy(fdGet);
                 fdGet = NULL;
             }
             else {
                 REPORT_ERROR(__LINE__, handleClient);
             }
         }
         else {
             REPORT_ERROR(__LINE__, lineReader);
         }
         /*
          ** Done with the connection.
          */
         closeRes = PR_Close(aFD);
         if (PR_SUCCESS != closeRes) {
             REPORT_ERROR(__LINE__, PR_Close);
         }
     }
     else {
         REPORT_ERROR(__LINE__, handleClient);
     }
 }
 /*
 ** serverMode
 **
 ** List on a port as a httpd.
 ** Output results interactively on demand.
 **
 ** Returns !0 on error.
 */
 int
 serverMode(void)
 {
     int retval = 0;
     PRFileDesc *socket = NULL;
     /*
      ** Create a socket.
      */
     socket = PR_NewTCPSocket();
     if (NULL != socket) {
         PRStatus closeRes = PR_SUCCESS;
         PRNetAddr bindAddr;
         PRStatus bindRes = PR_SUCCESS;
         /*
          ** Bind it to an interface/port.
          ** Any interface.
          */
         bindAddr.inet.family = PR_AF_INET;
         bindAddr.inet.port =
             PR_htons((uint16_t) globals.mCommandLineOptions.mHttpdPort);
         bindAddr.inet.ip = PR_htonl(PR_INADDR_ANY);
         bindRes = PR_Bind(socket, &bindAddr);
         if (PR_SUCCESS == bindRes) {
             PRStatus listenRes = PR_SUCCESS;
             const int backlog = 0x20;
             /*
              ** Start listening for clients.
              ** Give a decent backlog, some of our processing will take
              **  a bit.
              */
             listenRes = PR_Listen(socket, backlog);
             if (PR_SUCCESS == listenRes) {
                 PRFileDesc *connection = NULL;
                 int failureSum = 0;
                 char message[80];
                 /*
                  ** Output a little message saying we are receiving.
                  */
                 PR_snprintf(message, sizeof(message),
                             "server accepting connections at http://localhost:%u/",
                             globals.mCommandLineOptions.mHttpdPort);
                 REPORT_INFO(message);
                 PR_fprintf(PR_STDOUT, "Peak memory used: %s bytes\n",
                            FormatNumber(globals.mPeakMemoryUsed));
                 PR_fprintf(PR_STDOUT, "Allocations     : %s total\n",
                            FormatNumber(globals.mMallocCount +
                                         globals.mCallocCount +
                                         globals.mReallocCount),
                            FormatNumber(globals.mFreeCount));
                 PR_fprintf(PR_STDOUT, "Breakdown       : %s malloc\n",
                            FormatNumber(globals.mMallocCount));
                 PR_fprintf(PR_STDOUT, "                  %s calloc\n",
                            FormatNumber(globals.mCallocCount));
                 PR_fprintf(PR_STDOUT, "                  %s realloc\n",
                            FormatNumber(globals.mReallocCount));
                 PR_fprintf(PR_STDOUT, "                  %s free\n",
                            FormatNumber(globals.mFreeCount));
                 PR_fprintf(PR_STDOUT, "Leaks           : %s\n",
                            FormatNumber((globals.mMallocCount +
                                          globals.mCallocCount +
                                          globals.mReallocCount) -
                                         globals.mFreeCount));
                 /*
                  **  Keep accepting until we know otherwise.
                  **
                  **  We do a thread per connection.
                  **  Up to the thread to close the connection when done.
                  **
                  **  This is known by me to be suboptimal, and I would rather
                  **      do a thread pool if it ever becomes a resource issue.
                  **  Any issues would simply point to a need to get
                  **      more machines or a beefier machine to handle the
                  **      requests, as well as a need to do thread pooling and
                  **      avoid thread creation overhead.
                  **  The threads are not tracked, except possibly by NSPR
                  **      itself and PR_Cleanup will wait on them all to exit as
                  **      user threads so our shared data is valid.
                  */
                 while (0 == retval) {
                     connection =
                         PR_Accept(socket, NULL, PR_INTERVAL_NO_TIMEOUT);
                     if (NULL != connection) {
                         PRThread *clientThread = NULL;
                         /*
                          **  Thread per connection.
                          */
                         clientThread = PR_CreateThread(PR_USER_THREAD,  /* PR_Cleanup sync */
                                                        handleClient, (void *) connection, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, /* IO enabled */
                                                        PR_UNJOINABLE_THREAD,
 );
                         if (NULL == clientThread) {
                             PRStatus closeRes = PR_SUCCESS;
                             failureSum += __LINE__;
                             REPORT_ERROR(__LINE__, PR_Accept);
                             /*
                              **  Close the connection as well, no service
                              */
                             closeRes = PR_Close(connection);
                             if (PR_FAILURE == closeRes) {
                                 REPORT_ERROR(__LINE__, PR_Close);
                             }
                         }
                     }
                     else {
                         failureSum += __LINE__;
                         REPORT_ERROR(__LINE__, PR_Accept);
                     }
                 }
                 if (0 != failureSum) {
                     retval = __LINE__;
                 }
                 /*
                  ** Output a little message saying it is all over.
                  */
                 REPORT_INFO("server no longer accepting connections....");
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, PR_Listen);
             }
         }
         else {
             retval = __LINE__;
             REPORT_ERROR(__LINE__, PR_Bind);
         }
         /*
          ** Done with socket.
          */
         closeRes = PR_Close(socket);
         if (PR_SUCCESS != closeRes) {
             retval = __LINE__;
             REPORT_ERROR(__LINE__, PR_Close);
         }
         socket = NULL;
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, PR_NewTCPSocket);
     }
     return retval;
 }
 /*
 ** batchMode
 **
 ** Perform whatever batch requests we were asked to do.
 */
 int
 batchMode(void)
 {
     int retval = 0;
     if (0 != globals.mCommandLineOptions.mBatchRequestCount) {
         uint32_t loop = 0;
         int failureSum = 0;
         int handleRes = 0;
         char aFileName[1024];
         uint32_t sprintfRes = 0;
         /*
          ** Go through and process the various files requested.
          ** We do not stop on failure, as it is too costly to rerun the
          **  batch job.
          */
         for (loop = 0;
              loop < globals.mCommandLineOptions.mBatchRequestCount; loop++) {
             sprintfRes =
                 PR_snprintf(aFileName, sizeof(aFileName), "%s%c%s",
                             globals.mCommandLineOptions.mOutputDir,
                             PR_GetDirectorySeparator(),
                             globals.mCommandLineOptions.mBatchRequest[loop]);
             if ((uint32_t) - 1 != sprintfRes) {
                 PRFileDesc *outFile = NULL;
                 outFile = PR_Open(aFileName, ST_FLAGS, ST_PERMS);
                 if (NULL != outFile) {
                     PRStatus closeRes = PR_SUCCESS;
                     handleRes =
                         handleRequest(globals.mTMR, outFile,
                                       globals.mCommandLineOptions.
                                       mBatchRequest[loop], NULL);
                     if (0 != handleRes) {
                         failureSum += __LINE__;
                         REPORT_ERROR(__LINE__, handleRequest);
                     }
                     closeRes = PR_Close(outFile);
                     if (PR_SUCCESS != closeRes) {
                         failureSum += __LINE__;
                         REPORT_ERROR(__LINE__, PR_Close);
                     }
                 }
                 else {
                     failureSum += __LINE__;
                     REPORT_ERROR(__LINE__, PR_Open);
                 }
             }
             else {
                 failureSum += __LINE__;
                 REPORT_ERROR(__LINE__, PR_snprintf);
             }
         }
         if (0 != failureSum) {
             retval = __LINE__;
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, outputReports);
     }
     return retval;
 }
 /*
 ** doRun
 **
 ** Perform the actual processing this program requires.
 ** Returns !0 on failure.
 */
 int
 doRun(void)
 {
     int retval = 0;
     /*
      ** Create the new trace-malloc reader.
      */
     globals.mTMR = tmreader_new(globals.mProgramName, NULL);
     if (NULL != globals.mTMR) {
         int tmResult = 0;
         int outputResult = 0;
 #if defined(DEBUG_dp)
         PRIntervalTime start = PR_IntervalNow();
         fprintf(stderr, "DEBUG: reading tracemalloc data...\n");
 #endif
         tmResult =
             tmreader_eventloop(globals.mTMR,
                                globals.mCommandLineOptions.mFileName,
                                tmEventHandler);
         printf("\rReading... Done.\n");
 #if defined(DEBUG_dp)
         fprintf(stderr,
                 "DEBUG: reading tracemalloc data ends: %dms [%d allocations]\n",
                 PR_IntervalToMilliseconds(PR_IntervalNow() - start),
                 globals.mRun.mAllocationCount);
 #endif
         if (0 == tmResult) {
             REPORT_ERROR(__LINE__, tmreader_eventloop);
             retval = __LINE__;
         }
         if (0 == retval) {
             /*
              ** Decide if we're going into batch mode or server mode.
              */
             if (0 != globals.mCommandLineOptions.mBatchRequestCount) {
                 /*
                  ** Output in one big step while everything still exists.
                  */
                 outputResult = batchMode();
                 if (0 != outputResult) {
                     REPORT_ERROR(__LINE__, batchMode);
                     retval = __LINE__;
                 }
             }
             else {
                 int serverRes = 0;
                 /*
                  ** httpd time.
                  */
                 serverRes = serverMode();
                 if (0 != serverRes) {
                     REPORT_ERROR(__LINE__, serverMode);
                     retval = __LINE__;
                 }
             }
             /*
              ** Clear our categorization tree
              */
             freeCategories(&globals);
         }
     }
     else {
         REPORT_ERROR(__LINE__, tmreader_new);
         retval = __LINE__;
     }
     return retval;
 }
 int
 initCaches(void)
 /*
 **  Initialize the global caches.
 **  More involved since we have to allocated/create some objects.
 **
 **  returns     Zero if all is well.
 **              Non-zero on error.
 */
 {
     int retval = 0;
     STContextCache *inCache = &globals.mContextCache;
     if (NULL != inCache && 0 != globals.mCommandLineOptions.mContexts) {
         inCache->mLock = PR_NewLock();
         if (NULL != inCache->mLock) {
             inCache->mCacheMiss = PR_NewCondVar(inCache->mLock);
             if (NULL != inCache->mCacheMiss) {
                 inCache->mItems =
                     (STContextCacheItem *) calloc(globals.mCommandLineOptions.
                                                   mContexts,
                                                   sizeof(STContextCacheItem));
                 if (NULL != inCache->mItems) {
                     uint32_t loop = 0;
                     char buffer[64];
                     inCache->mItemCount =
                         globals.mCommandLineOptions.mContexts;
                     /*
                      **  Init each item as needed.
                      */
                     for (loop = 0; loop < inCache->mItemCount; loop++) {
                         inCache->mItems[loop].mContext.mIndex = loop;
                         PR_snprintf(buffer, sizeof(buffer),
                                     "Context Item %d RW Lock", loop);
                         inCache->mItems[loop].mContext.mRWLock =
                             PR_NewRWLock(PR_RWLOCK_RANK_NONE, buffer);
                         if (NULL == inCache->mItems[loop].mContext.mRWLock) {
                             break;
                         }
 #if ST_WANT_GRAPHS
                         inCache->mItems[loop].mContext.mImageLock =
                             PR_NewLock();
                         if (NULL == inCache->mItems[loop].mContext.mImageLock) {
                             break;
                         }
 #endif
                     }
                     if (loop != inCache->mItemCount) {
                         retval = __LINE__;
                         REPORT_ERROR(__LINE__, initCaches);
                     }
                 }
                 else {
                     retval = __LINE__;
                     REPORT_ERROR(__LINE__, calloc);
                 }
             }
             else {
                 retval = __LINE__;
                 REPORT_ERROR(__LINE__, PR_NewCondVar);
             }
         }
         else {
             retval = __LINE__;
             REPORT_ERROR(__LINE__, PR_NewLock);
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, initCaches);
     }
     return retval;
 }
 int
 destroyCaches(void)
 /*
 **  Clean up any global caches we have laying around.
 **
 **  returns     Zero if all is well.
 **              Non-zero on error.
 */
 {
     int retval = 0;
     STContextCache *inCache = &globals.mContextCache;
     if (NULL != inCache) {
         uint32_t loop = 0;
         /*
          **  Uninit item data one by one.
          */
         for (loop = 0; loop < inCache->mItemCount; loop++) {
             if (NULL != inCache->mItems[loop].mContext.mRWLock) {
                 PR_DestroyRWLock(inCache->mItems[loop].mContext.mRWLock);
                 inCache->mItems[loop].mContext.mRWLock = NULL;
             }
 #if ST_WANT_GRAPHS
             if (NULL != inCache->mItems[loop].mContext.mImageLock) {
                 PR_DestroyLock(inCache->mItems[loop].mContext.mImageLock);
                 inCache->mItems[loop].mContext.mImageLock = NULL;
             }
 #endif
         }
         inCache->mItemCount = 0;
         if (NULL != inCache->mItems) {
             free(inCache->mItems);
             inCache->mItems = NULL;
         }
         if (NULL != inCache->mCacheMiss) {
             PR_DestroyCondVar(inCache->mCacheMiss);
             inCache->mCacheMiss = NULL;
         }
         if (NULL != inCache->mLock) {
             PR_DestroyLock(inCache->mLock);
             inCache->mLock = NULL;
         }
     }
     else {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, destroyCaches);
     }
     return retval;
 }
 /*
 ** main
 **
 ** Process entry and exit.
 */
 int
 main(int aArgCount, char **aArgArray)
 {
     int retval = 0;
     int optionsResult = 0;
     PRStatus prResult = PR_SUCCESS;
     int showedHelp = 0;
     int looper = 0;
     int cacheResult = 0;
     /*
      ** NSPR init.
      */
     PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
     /*
      ** Initialize globals
      */
     memset(&globals, 0, sizeof(globals));
     /*
      ** Set the program name.
      */
     globals.mProgramName = aArgArray[0];
     /*
      ** Set the minimum timeval really high so other code
      **  that checks the timeval will get it right.
      */
     globals.mMinTimeval = ST_TIMEVAL_MAX;
     /*
      ** Handle initializing options.
      */
     optionsResult = initOptions(aArgCount, aArgArray);
     if (0 != optionsResult) {
         REPORT_ERROR(optionsResult, initOptions);
         retval = __LINE__;
     }
     /*
      **  Initialize our caches.
      */
     cacheResult = initCaches();
     if (0 != cacheResult) {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, initCaches);
     }
     /*
      **  Small alloc code init.
      */
     globals.mCategoryRoot.runs =
         (STRun **) calloc(globals.mCommandLineOptions.mContexts,
                           sizeof(STRun *));
     if (NULL == globals.mCategoryRoot.runs) {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, calloc);
     }
     /*
      ** Show help on usage if need be.
      */
     showedHelp = showHelp();
     /*
      ** Only perform the run if everything is checking out.
      */
     if (0 == showedHelp && 0 == retval) {
         int runResult = 0;
         runResult = doRun();
         if (0 != runResult) {
             REPORT_ERROR(runResult, doRun);
             retval = __LINE__;
         }
     }
     if (0 != retval) {
         REPORT_ERROR(retval, main);
     }
     /*
      **  Have NSPR join all client threads we started.
      */
     prResult = PR_Cleanup();
     if (PR_SUCCESS != prResult) {
         REPORT_ERROR(retval, PR_Cleanup);
         retval = __LINE__;
     }
     /*
      **  All threads are joined/done by this line.
      */
     /*
      **  Options allocated a little.
      */
 #define ST_CMD_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help) \
     if(NULL != globals.mCommandLineOptions.m##option_name) \
     { \
         free((void*)globals.mCommandLineOptions.m##option_name); \
         globals.mCommandLineOptions.m##option_name = NULL; \
         globals.mCommandLineOptions.m##option_name##Count = 0; \
     }
 #include "stoptions.h"
     /*
      **  globals has a small modification to clear up.
      */
     if (NULL != globals.mCategoryRoot.runs) {
         free(globals.mCategoryRoot.runs);
         globals.mCategoryRoot.runs = NULL;
     }
     /*
      **  Blow away our caches.
      */
     cacheResult = destroyCaches();
     if (0 != cacheResult) {
         retval = __LINE__;
         REPORT_ERROR(__LINE__, initCaches);
     }
     /*
      **  We are safe to kill our tmreader data.
      */
     if (NULL != globals.mTMR) {
         tmreader_destroy(globals.mTMR);
         globals.mTMR = NULL;
     }
     return retval;
 }

The Tor Browser / annotate

tools/trace-malloc/spacetrace.c@97036ab72558 (annotated)

tools/trace-malloc/spacetrace.c