tools/leaky/leaky.h

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is mozilla.org code.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Kipp E.B. Hickman.
  18  * Portions created by the Initial Developer are Copyright (C) 1999
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #ifndef __leaky_h_
  38 #define __leaky_h_
  39
  40 #include "config.h"
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <sys/types.h>
  44 #include "dict.h"
  45 #include "strset.h"
  46 #include "xpcom-config.h" // for CPP_NEW_THROW
  47
  48 typedef unsigned int u_int;
  49
  50 struct Symbol;
  51
  52 struct TreeNode {
  53   TreeNode(Symbol* aSymbol) {
  54     symbol = aSymbol;
  55     nextSibling = NULL;
  56     descendants = NULL;
  57     nextRoot = NULL;
  58     bytesLeaked = 0;
  59     descendantBytesLeaked = 0;
  60   }
  61
  62   TreeNode* GetDirectDescendant(Symbol* aSymbol);
  63
  64   bool HasDescendants() const {
  65     return NULL != descendants;
  66   }
  67
  68   TreeNode* AddDescendant(Symbol* aSymbol);
  69
  70   TreeNode* descendants;
  71   TreeNode* nextSibling;
  72   TreeNode* nextRoot;
  73   Symbol* symbol;
  74
  75   u_long bytesLeaked;
  76   u_long descendantBytesLeaked;
  77
  78   void* operator new(size_t size) CPP_THROW_NEW ;
  79   void operator delete(void* ptr);
  80
  81   static TreeNode* freeList;
  82 };
  83
  84 struct Symbol {
  85   char* name;
  86   u_long address;
  87   TreeNode* root;
  88
  89   void Init(const char* aName, u_long aAddress) {
  90     name = aName ? strdup(aName) : (char *)"";
  91     address = aAddress;
  92     root = NULL;
  93   }
  94 };
  95
  96 struct LoadMapEntry {
  97   char* name;                   // name of .so
  98   u_long address;               // base address where it was mapped in
  99   LoadMapEntry* next;
 100 };
 101
 102 struct leaky {
 103   leaky();
 104   ~leaky();
 105
 106   void initialize(int argc, char** argv);
 107   void open();
 108
 109   char*  applicationName;
 110   char*  logFile;
 111   char*  progFile;
 112
 113   int   dumpLeaks;
 114   int   dumpGraph;
 115   int   dumpHTML;
 116   int   quiet;
 117   int   dumpEntireLog;
 118   int   showAddress;
 119   bool  dumpRefcnts;
 120   u_int  stackDepth;
 121
 122   int   mappedLogFile;
 123   malloc_log_entry* firstLogEntry;
 124   malloc_log_entry* lastLogEntry;
 125   u_int  buckets;
 126   MallocDict*  dict;
 127   MallocDict*  refcntDict;
 128
 129   u_long  mallocs;
 130   u_long  reallocs;
 131   u_long  frees;
 132   u_long  totalMalloced;
 133   u_long  errors;
 134   u_long  totalLeaked;
 135
 136   int sfd;
 137   Symbol* externalSymbols;
 138   u_int usefulSymbols;
 139   u_int numExternalSymbols;
 140   StrSet exclusions;
 141   u_long lowestSymbolAddr;
 142   u_long highestSymbolAddr;
 143
 144   LoadMapEntry* loadMap;
 145
 146   TreeNode* rootList;
 147
 148   StrSet roots;
 149   StrSet includes;
 150
 151   void usageError();
 152
 153   void LoadMap();
 154
 155   void analyze();
 156
 157   void dumpLog();
 158   void dumpEntryToLog(malloc_log_entry* lep);
 159
 160 #if 0
 161   void dumpToTree();
 162   void dumpEntryToTree(FILE* fp, malloc_log_entry* lep);
 163 #endif
 164
 165   void insertAddress(u_long address, malloc_log_entry* lep);
 166   void removeAddress(u_long address, malloc_log_entry* lep);
 167
 168   void displayStackTrace(FILE* out, malloc_log_entry* lep);
 169
 170   void ReadSymbols(const char* fileName, u_long aBaseAddress);
 171   void ReadSharedLibrarySymbols();
 172   void setupSymbols(const char* fileName);
 173   Symbol* findSymbol(u_long address);
 174   bool excluded(malloc_log_entry* lep);
 175   bool included(malloc_log_entry* lep);
 176
 177   void buildLeakGraph();
 178   Symbol* findLeakGraphRoot(Symbol* aStart, Symbol* aEnd);
 179   void dumpLeakGraph();
 180   void dumpLeakTree(TreeNode* aNode, int aIndent);
 181
 182   bool ShowThisEntry(malloc_log_entry* lep);
 183
 184   bool IsRefcnt(malloc_log_entry* lep) const {
 185     return (lep->type == malloc_log_addref) ||
 186       (lep->type == malloc_log_release);
 187   }
 188
 189   static void indentBy(int aCount) {
 190     while (--aCount >= 0) fputs("  ", stdout);
 191   }
 192 };
 193
 194 #endif /* __leaky_h_ */