src/base/ftdbgmem.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftdbgmem.c                                                             */
   4 /*                                                                         */
   5 /*    Memory debugger (body).                                              */
   6 /*                                                                         */
   7 /*  Copyright 2001-2006, 2009, 2013 by                                     */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_CONFIG_CONFIG_H
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_MEMORY_H
  23 #include FT_SYSTEM_H
  24 #include FT_ERRORS_H
  25 #include FT_TYPES_H
  26
  27
  28 #ifdef FT_DEBUG_MEMORY
  29
  30 #define  KEEPALIVE /* `Keep alive' means that freed blocks aren't released
  31                     * to the heap.  This is useful to detect double-frees
  32                     * or weird heap corruption, but it uses large amounts of
  33                     * memory, however.
  34                     */
  35
  36 #include FT_CONFIG_STANDARD_LIBRARY_H
  37
  38   FT_BASE_DEF( const char* )  _ft_debug_file   = 0;
  39   FT_BASE_DEF( long )         _ft_debug_lineno = 0;
  40
  41   extern void
  42   FT_DumpMemory( FT_Memory  memory );
  43
  44
  45   typedef struct FT_MemSourceRec_*  FT_MemSource;
  46   typedef struct FT_MemNodeRec_*    FT_MemNode;
  47   typedef struct FT_MemTableRec_*   FT_MemTable;
  48
  49
  50 #define FT_MEM_VAL( addr )  ((FT_PtrDist)(FT_Pointer)( addr ))
  51
  52   /*
  53    *  This structure holds statistics for a single allocation/release
  54    *  site.  This is useful to know where memory operations happen the
  55    *  most.
  56    */
  57   typedef struct  FT_MemSourceRec_
  58   {
  59     const char*   file_name;
  60     long          line_no;
  61
  62     FT_Long       cur_blocks;   /* current number of allocated blocks */
  63     FT_Long       max_blocks;   /* max. number of allocated blocks    */
  64     FT_Long       all_blocks;   /* total number of blocks allocated   */
  65
  66     FT_Long       cur_size;     /* current cumulative allocated size */
  67     FT_Long       max_size;     /* maximum cumulative allocated size */
  68     FT_Long       all_size;     /* total cumulative allocated size   */
  69
  70     FT_Long       cur_max;      /* current maximum allocated size */
  71
  72     FT_UInt32     hash;
  73     FT_MemSource  link;
  74
  75   } FT_MemSourceRec;
  76
  77
  78   /*
  79    *  We don't need a resizable array for the memory sources, because
  80    *  their number is pretty limited within FreeType.
  81    */
  82 #define FT_MEM_SOURCE_BUCKETS  128
  83
  84   /*
  85    *  This structure holds information related to a single allocated
  86    *  memory block.  If KEEPALIVE is defined, blocks that are freed by
  87    *  FreeType are never released to the system.  Instead, their `size'
  88    *  field is set to -size.  This is mainly useful to detect double frees,
  89    *  at the price of large memory footprint during execution.
  90    */
  91   typedef struct  FT_MemNodeRec_
  92   {
  93     FT_Byte*      address;
  94     FT_Long       size;     /* < 0 if the block was freed */
  95
  96     FT_MemSource  source;
  97
  98 #ifdef KEEPALIVE
  99     const char*   free_file_name;
 100     FT_Long       free_line_no;
 101 #endif
 102
 103     FT_MemNode    link;
 104
 105   } FT_MemNodeRec;
 106
 107
 108   /*
 109    *  The global structure, containing compound statistics and all hash
 110    *  tables.
 111    */
 112   typedef struct  FT_MemTableRec_
 113   {
 114     FT_ULong         size;
 115     FT_ULong         nodes;
 116     FT_MemNode*      buckets;
 117
 118     FT_ULong         alloc_total;
 119     FT_ULong         alloc_current;
 120     FT_ULong         alloc_max;
 121     FT_ULong         alloc_count;
 122
 123     FT_Bool          bound_total;
 124     FT_ULong         alloc_total_max;
 125
 126     FT_Bool          bound_count;
 127     FT_ULong         alloc_count_max;
 128
 129     FT_MemSource     sources[FT_MEM_SOURCE_BUCKETS];
 130
 131     FT_Bool          keep_alive;
 132
 133     FT_Memory        memory;
 134     FT_Pointer       memory_user;
 135     FT_Alloc_Func    alloc;
 136     FT_Free_Func     free;
 137     FT_Realloc_Func  realloc;
 138
 139   } FT_MemTableRec;
 140
 141
 142 #define FT_MEM_SIZE_MIN  7
 143 #define FT_MEM_SIZE_MAX  13845163
 144
 145 #define FT_FILENAME( x )  ((x) ? (x) : "unknown file")
 146
 147
 148   /*
 149    *  Prime numbers are ugly to handle.  It would be better to implement
 150    *  L-Hashing, which is 10% faster and doesn't require divisions.
 151    */
 152   static const FT_UInt  ft_mem_primes[] =
 153   {
 154     7,
 155     11,
 156     19,
 157     37,
 158     73,
 159     109,
 160     163,
 161     251,
 162     367,
 163     557,
 164     823,
 165     1237,
 166     1861,
 167     2777,
 168     4177,
 169     6247,
 170     9371,
 171     14057,
 172     21089,
 173     31627,
 174     47431,
 175     71143,
 176     106721,
 177     160073,
 178     240101,
 179     360163,
 180     540217,
 181     810343,
 182     1215497,
 183     1823231,
 184     2734867,
 185     4102283,
 186     6153409,
 187     9230113,
 188     13845163,
 189   };
 190
 191
 192   static FT_ULong
 193   ft_mem_closest_prime( FT_ULong  num )
 194   {
 195     FT_UInt  i;
 196
 197
 198     for ( i = 0;
 199           i < sizeof ( ft_mem_primes ) / sizeof ( ft_mem_primes[0] ); i++ )
 200       if ( ft_mem_primes[i] > num )
 201         return ft_mem_primes[i];
 202
 203     return FT_MEM_SIZE_MAX;
 204   }
 205
 206
 207   extern void
 208   ft_mem_debug_panic( const char*  fmt,
 209                       ... )
 210   {
 211     va_list  ap;
 212
 213
 214     printf( "FreeType.Debug: " );
 215
 216     va_start( ap, fmt );
 217     vprintf( fmt, ap );
 218     va_end( ap );
 219
 220     printf( "\n" );
 221     exit( EXIT_FAILURE );
 222   }
 223
 224
 225   static FT_Pointer
 226   ft_mem_table_alloc( FT_MemTable  table,
 227                       FT_Long      size )
 228   {
 229     FT_Memory   memory = table->memory;
 230     FT_Pointer  block;
 231
 232
 233     memory->user = table->memory_user;
 234     block = table->alloc( memory, size );
 235     memory->user = table;
 236
 237     return block;
 238   }
 239
 240
 241   static void
 242   ft_mem_table_free( FT_MemTable  table,
 243                      FT_Pointer   block )
 244   {
 245     FT_Memory  memory = table->memory;
 246
 247
 248     memory->user = table->memory_user;
 249     table->free( memory, block );
 250     memory->user = table;
 251   }
 252
 253
 254   static void
 255   ft_mem_table_resize( FT_MemTable  table )
 256   {
 257     FT_ULong  new_size;
 258
 259
 260     new_size = ft_mem_closest_prime( table->nodes );
 261     if ( new_size != table->size )
 262     {
 263       FT_MemNode*  new_buckets;
 264       FT_ULong     i;
 265
 266
 267       new_buckets = (FT_MemNode *)
 268                       ft_mem_table_alloc( table,
 269                                           new_size * sizeof ( FT_MemNode ) );
 270       if ( new_buckets == NULL )
 271         return;
 272
 273       FT_ARRAY_ZERO( new_buckets, new_size );
 274
 275       for ( i = 0; i < table->size; i++ )
 276       {
 277         FT_MemNode  node, next, *pnode;
 278         FT_PtrDist  hash;
 279
 280
 281         node = table->buckets[i];
 282         while ( node )
 283         {
 284           next  = node->link;
 285           hash  = FT_MEM_VAL( node->address ) % new_size;
 286           pnode = new_buckets + hash;
 287
 288           node->link = pnode[0];
 289           pnode[0]   = node;
 290
 291           node = next;
 292         }
 293       }
 294
 295       if ( table->buckets )
 296         ft_mem_table_free( table, table->buckets );
 297
 298       table->buckets = new_buckets;
 299       table->size    = new_size;
 300     }
 301   }
 302
 303
 304   static FT_MemTable
 305   ft_mem_table_new( FT_Memory  memory )
 306   {
 307     FT_MemTable  table;
 308
 309
 310     table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) );
 311     if ( table == NULL )
 312       goto Exit;
 313
 314     FT_ZERO( table );
 315
 316     table->size  = FT_MEM_SIZE_MIN;
 317     table->nodes = 0;
 318
 319     table->memory = memory;
 320
 321     table->memory_user = memory->user;
 322
 323     table->alloc   = memory->alloc;
 324     table->realloc = memory->realloc;
 325     table->free    = memory->free;
 326
 327     table->buckets = (FT_MemNode *)
 328                        memory->alloc( memory,
 329                                       table->size * sizeof ( FT_MemNode ) );
 330     if ( table->buckets )
 331       FT_ARRAY_ZERO( table->buckets, table->size );
 332     else
 333     {
 334       memory->free( memory, table );
 335       table = NULL;
 336     }
 337
 338   Exit:
 339     return table;
 340   }
 341
 342
 343   static void
 344   ft_mem_table_destroy( FT_MemTable  table )
 345   {
 346     FT_ULong  i;
 347     FT_Long   leak_count = 0;
 348     FT_ULong  leaks      = 0;
 349
 350
 351     FT_DumpMemory( table->memory );
 352
 353     /* remove all blocks from the table, revealing leaked ones */
 354     for ( i = 0; i < table->size; i++ )
 355     {
 356       FT_MemNode  *pnode = table->buckets + i, next, node = *pnode;
 357
 358
 359       while ( node )
 360       {
 361         next       = node->link;
 362         node->link = 0;
 363
 364         if ( node->size > 0 )
 365         {
 366           printf(
 367             "leaked memory block at address %p, size %8ld in (%s:%ld)\n",
 368             node->address, node->size,
 369             FT_FILENAME( node->source->file_name ),
 370             node->source->line_no );
 371
 372           leak_count++;
 373           leaks += node->size;
 374
 375           ft_mem_table_free( table, node->address );
 376         }
 377
 378         node->address = NULL;
 379         node->size    = 0;
 380
 381         ft_mem_table_free( table, node );
 382         node = next;
 383       }
 384       table->buckets[i] = 0;
 385     }
 386
 387     ft_mem_table_free( table, table->buckets );
 388     table->buckets = NULL;
 389
 390     table->size  = 0;
 391     table->nodes = 0;
 392
 393     /* remove all sources */
 394     for ( i = 0; i < FT_MEM_SOURCE_BUCKETS; i++ )
 395     {
 396       FT_MemSource  source, next;
 397
 398
 399       for ( source = table->sources[i]; source != NULL; source = next )
 400       {
 401         next = source->link;
 402         ft_mem_table_free( table, source );
 403       }
 404
 405       table->sources[i] = NULL;
 406     }
 407
 408     printf( "FreeType: total memory allocations = %ld\n",
 409             table->alloc_total );
 410     printf( "FreeType: maximum memory footprint = %ld\n",
 411             table->alloc_max );
 412
 413     ft_mem_table_free( table, table );
 414
 415     if ( leak_count > 0 )
 416       ft_mem_debug_panic(
 417         "FreeType: %ld bytes of memory leaked in %ld blocks\n",
 418         leaks, leak_count );
 419
 420     printf( "FreeType: no memory leaks detected\n" );
 421   }
 422
 423
 424   static FT_MemNode*
 425   ft_mem_table_get_nodep( FT_MemTable  table,
 426                           FT_Byte*     address )
 427   {
 428     FT_PtrDist   hash;
 429     FT_MemNode  *pnode, node;
 430
 431
 432     hash  = FT_MEM_VAL( address );
 433     pnode = table->buckets + ( hash % table->size );
 434
 435     for (;;)
 436     {
 437       node = pnode[0];
 438       if ( !node )
 439         break;
 440
 441       if ( node->address == address )
 442         break;
 443
 444       pnode = &node->link;
 445     }
 446     return pnode;
 447   }
 448
 449
 450   static FT_MemSource
 451   ft_mem_table_get_source( FT_MemTable  table )
 452   {
 453     FT_UInt32     hash;
 454     FT_MemSource  node, *pnode;
 455
 456
 457     /* cast to FT_PtrDist first since void* can be larger */
 458     /* than FT_UInt32 and GCC 4.1.1 emits a warning       */
 459     hash  = (FT_UInt32)(FT_PtrDist)(void*)_ft_debug_file +
 460               (FT_UInt32)( 5 * _ft_debug_lineno );
 461     pnode = &table->sources[hash % FT_MEM_SOURCE_BUCKETS];
 462
 463     for ( ;; )
 464     {
 465       node = *pnode;
 466       if ( node == NULL )
 467         break;
 468
 469       if ( node->file_name == _ft_debug_file &&
 470            node->line_no   == _ft_debug_lineno   )
 471         goto Exit;
 472
 473       pnode = &node->link;
 474     }
 475
 476     node = (FT_MemSource)ft_mem_table_alloc( table, sizeof ( *node ) );
 477     if ( node == NULL )
 478       ft_mem_debug_panic(
 479         "not enough memory to perform memory debugging\n" );
 480
 481     node->file_name = _ft_debug_file;
 482     node->line_no   = _ft_debug_lineno;
 483
 484     node->cur_blocks = 0;
 485     node->max_blocks = 0;
 486     node->all_blocks = 0;
 487
 488     node->cur_size   = 0;
 489     node->max_size   = 0;
 490     node->all_size   = 0;
 491
 492     node->cur_max    = 0;
 493
 494     node->link = NULL;
 495     node->hash = hash;
 496     *pnode     = node;
 497
 498   Exit:
 499     return node;
 500   }
 501
 502
 503   static void
 504   ft_mem_table_set( FT_MemTable  table,
 505                     FT_Byte*     address,
 506                     FT_ULong     size,
 507                     FT_Long      delta )
 508   {
 509     FT_MemNode  *pnode, node;
 510
 511
 512     if ( table )
 513     {
 514       FT_MemSource  source;
 515
 516
 517       pnode = ft_mem_table_get_nodep( table, address );
 518       node  = *pnode;
 519       if ( node )
 520       {
 521         if ( node->size < 0 )
 522         {
 523           /* This block was already freed.  Our memory is now completely */
 524           /* corrupted!                                                  */
 525           /* This can only happen in keep-alive mode.                    */
 526           ft_mem_debug_panic(
 527             "memory heap corrupted (allocating freed block)" );
 528         }
 529         else
 530         {
 531           /* This block was already allocated.  This means that our memory */
 532           /* is also corrupted!                                            */
 533           ft_mem_debug_panic(
 534             "memory heap corrupted (re-allocating allocated block at"
 535             " %p, of size %ld)\n"
 536             "org=%s:%d new=%s:%d\n",
 537             node->address, node->size,
 538             FT_FILENAME( node->source->file_name ), node->source->line_no,
 539             FT_FILENAME( _ft_debug_file ), _ft_debug_lineno );
 540         }
 541       }
 542
 543       /* we need to create a new node in this table */
 544       node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) );
 545       if ( node == NULL )
 546         ft_mem_debug_panic( "not enough memory to run memory tests" );
 547
 548       node->address = address;
 549       node->size    = size;
 550       node->source  = source = ft_mem_table_get_source( table );
 551
 552       if ( delta == 0 )
 553       {
 554         /* this is an allocation */
 555         source->all_blocks++;
 556         source->cur_blocks++;
 557         if ( source->cur_blocks > source->max_blocks )
 558           source->max_blocks = source->cur_blocks;
 559       }
 560
 561       if ( size > (FT_ULong)source->cur_max )
 562         source->cur_max = size;
 563
 564       if ( delta != 0 )
 565       {
 566         /* we are growing or shrinking a reallocated block */
 567         source->cur_size     += delta;
 568         table->alloc_current += delta;
 569       }
 570       else
 571       {
 572         /* we are allocating a new block */
 573         source->cur_size     += size;
 574         table->alloc_current += size;
 575       }
 576
 577       source->all_size += size;
 578
 579       if ( source->cur_size > source->max_size )
 580         source->max_size = source->cur_size;
 581
 582       node->free_file_name = NULL;
 583       node->free_line_no   = 0;
 584
 585       node->link = pnode[0];
 586
 587       pnode[0] = node;
 588       table->nodes++;
 589
 590       table->alloc_total += size;
 591
 592       if ( table->alloc_current > table->alloc_max )
 593         table->alloc_max = table->alloc_current;
 594
 595       if ( table->nodes * 3 < table->size  ||
 596            table->size  * 3 < table->nodes )
 597         ft_mem_table_resize( table );
 598     }
 599   }
 600
 601
 602   static void
 603   ft_mem_table_remove( FT_MemTable  table,
 604                        FT_Byte*     address,
 605                        FT_Long      delta )
 606   {
 607     if ( table )
 608     {
 609       FT_MemNode  *pnode, node;
 610
 611
 612       pnode = ft_mem_table_get_nodep( table, address );
 613       node  = *pnode;
 614       if ( node )
 615       {
 616         FT_MemSource  source;
 617
 618
 619         if ( node->size < 0 )
 620           ft_mem_debug_panic(
 621             "freeing memory block at %p more than once at (%s:%ld)\n"
 622             "block allocated at (%s:%ld) and released at (%s:%ld)",
 623             address,
 624             FT_FILENAME( _ft_debug_file ), _ft_debug_lineno,
 625             FT_FILENAME( node->source->file_name ), node->source->line_no,
 626             FT_FILENAME( node->free_file_name ), node->free_line_no );
 627
 628         /* scramble the node's content for additional safety */
 629         FT_MEM_SET( address, 0xF3, node->size );
 630
 631         if ( delta == 0 )
 632         {
 633           source = node->source;
 634
 635           source->cur_blocks--;
 636           source->cur_size -= node->size;
 637
 638           table->alloc_current -= node->size;
 639         }
 640
 641         if ( table->keep_alive )
 642         {
 643           /* we simply invert the node's size to indicate that the node */
 644           /* was freed.                                                 */
 645           node->size           = -node->size;
 646           node->free_file_name = _ft_debug_file;
 647           node->free_line_no   = _ft_debug_lineno;
 648         }
 649         else
 650         {
 651           table->nodes--;
 652
 653           *pnode = node->link;
 654
 655           node->size   = 0;
 656           node->source = NULL;
 657
 658           ft_mem_table_free( table, node );
 659
 660           if ( table->nodes * 3 < table->size  ||
 661                table->size  * 3 < table->nodes )
 662             ft_mem_table_resize( table );
 663         }
 664       }
 665       else
 666         ft_mem_debug_panic(
 667           "trying to free unknown block at %p in (%s:%ld)\n",
 668           address,
 669           FT_FILENAME( _ft_debug_file ), _ft_debug_lineno );
 670     }
 671   }
 672
 673
 674   extern FT_Pointer
 675   ft_mem_debug_alloc( FT_Memory  memory,
 676                       FT_Long    size )
 677   {
 678     FT_MemTable  table = (FT_MemTable)memory->user;
 679     FT_Byte*     block;
 680
 681
 682     if ( size <= 0 )
 683       ft_mem_debug_panic( "negative block size allocation (%ld)", size );
 684
 685     /* return NULL if the maximum number of allocations was reached */
 686     if ( table->bound_count                           &&
 687          table->alloc_count >= table->alloc_count_max )
 688       return NULL;
 689
 690     /* return NULL if this allocation would overflow the maximum heap size */
 691     if ( table->bound_total                                             &&
 692          table->alloc_total_max - table->alloc_current > (FT_ULong)size )
 693       return NULL;
 694
 695     block = (FT_Byte *)ft_mem_table_alloc( table, size );
 696     if ( block )
 697     {
 698       ft_mem_table_set( table, block, (FT_ULong)size, 0 );
 699
 700       table->alloc_count++;
 701     }
 702
 703     _ft_debug_file   = "<unknown>";
 704     _ft_debug_lineno = 0;
 705
 706     return (FT_Pointer)block;
 707   }
 708
 709
 710   extern void
 711   ft_mem_debug_free( FT_Memory   memory,
 712                      FT_Pointer  block )
 713   {
 714     FT_MemTable  table = (FT_MemTable)memory->user;
 715
 716
 717     if ( block == NULL )
 718       ft_mem_debug_panic( "trying to free NULL in (%s:%ld)",
 719                           FT_FILENAME( _ft_debug_file ),
 720                           _ft_debug_lineno );
 721
 722     ft_mem_table_remove( table, (FT_Byte*)block, 0 );
 723
 724     if ( !table->keep_alive )
 725       ft_mem_table_free( table, block );
 726
 727     table->alloc_count--;
 728
 729     _ft_debug_file   = "<unknown>";
 730     _ft_debug_lineno = 0;
 731   }
 732
 733
 734   extern FT_Pointer
 735   ft_mem_debug_realloc( FT_Memory   memory,
 736                         FT_Long     cur_size,
 737                         FT_Long     new_size,
 738                         FT_Pointer  block )
 739   {
 740     FT_MemTable  table = (FT_MemTable)memory->user;
 741     FT_MemNode   node, *pnode;
 742     FT_Pointer   new_block;
 743     FT_Long      delta;
 744
 745     const char*  file_name = FT_FILENAME( _ft_debug_file );
 746     FT_Long      line_no   = _ft_debug_lineno;
 747
 748
 749     /* unlikely, but possible */
 750     if ( new_size == cur_size )
 751       return block;
 752
 753     /* the following is valid according to ANSI C */
 754 #if 0
 755     if ( block == NULL || cur_size == 0 )
 756       ft_mem_debug_panic( "trying to reallocate NULL in (%s:%ld)",
 757                           file_name, line_no );
 758 #endif
 759
 760     /* while the following is allowed in ANSI C also, we abort since */
 761     /* such case should be handled by FreeType.                      */
 762     if ( new_size <= 0 )
 763       ft_mem_debug_panic(
 764         "trying to reallocate %p to size 0 (current is %ld) in (%s:%ld)",
 765         block, cur_size, file_name, line_no );
 766
 767     /* check `cur_size' value */
 768     pnode = ft_mem_table_get_nodep( table, (FT_Byte*)block );
 769     node  = *pnode;
 770     if ( !node )
 771       ft_mem_debug_panic(
 772         "trying to reallocate unknown block at %p in (%s:%ld)",
 773         block, file_name, line_no );
 774
 775     if ( node->size <= 0 )
 776       ft_mem_debug_panic(
 777         "trying to reallocate freed block at %p in (%s:%ld)",
 778         block, file_name, line_no );
 779
 780     if ( node->size != cur_size )
 781       ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is "
 782                           "%ld instead of %ld in (%s:%ld)",
 783                           block, cur_size, node->size, file_name, line_no );
 784
 785     /* return NULL if the maximum number of allocations was reached */
 786     if ( table->bound_count                           &&
 787          table->alloc_count >= table->alloc_count_max )
 788       return NULL;
 789
 790     delta = (FT_Long)( new_size - cur_size );
 791
 792     /* return NULL if this allocation would overflow the maximum heap size */
 793     if ( delta > 0                                                       &&
 794          table->bound_total                                              &&
 795          table->alloc_current + (FT_ULong)delta > table->alloc_total_max )
 796       return NULL;
 797
 798     new_block = (FT_Byte *)ft_mem_table_alloc( table, new_size );
 799     if ( new_block == NULL )
 800       return NULL;
 801
 802     ft_mem_table_set( table, (FT_Byte*)new_block, new_size, delta );
 803
 804     ft_memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
 805
 806     ft_mem_table_remove( table, (FT_Byte*)block, delta );
 807
 808     _ft_debug_file   = "<unknown>";
 809     _ft_debug_lineno = 0;
 810
 811     if ( !table->keep_alive )
 812       ft_mem_table_free( table, block );
 813
 814     return new_block;
 815   }
 816
 817
 818   extern FT_Int
 819   ft_mem_debug_init( FT_Memory  memory )
 820   {
 821     FT_MemTable  table;
 822     FT_Int       result = 0;
 823
 824
 825     if ( getenv( "FT2_DEBUG_MEMORY" ) )
 826     {
 827       table = ft_mem_table_new( memory );
 828       if ( table )
 829       {
 830         const char*  p;
 831
 832
 833         memory->user    = table;
 834         memory->alloc   = ft_mem_debug_alloc;
 835         memory->realloc = ft_mem_debug_realloc;
 836         memory->free    = ft_mem_debug_free;
 837
 838         p = getenv( "FT2_ALLOC_TOTAL_MAX" );
 839         if ( p != NULL )
 840         {
 841           FT_Long   total_max = ft_atol( p );
 842
 843
 844           if ( total_max > 0 )
 845           {
 846             table->bound_total     = 1;
 847             table->alloc_total_max = (FT_ULong)total_max;
 848           }
 849         }
 850
 851         p = getenv( "FT2_ALLOC_COUNT_MAX" );
 852         if ( p != NULL )
 853         {
 854           FT_Long  total_count = ft_atol( p );
 855
 856
 857           if ( total_count > 0 )
 858           {
 859             table->bound_count     = 1;
 860             table->alloc_count_max = (FT_ULong)total_count;
 861           }
 862         }
 863
 864         p = getenv( "FT2_KEEP_ALIVE" );
 865         if ( p != NULL )
 866         {
 867           FT_Long  keep_alive = ft_atol( p );
 868
 869
 870           if ( keep_alive > 0 )
 871             table->keep_alive = 1;
 872         }
 873
 874         result = 1;
 875       }
 876     }
 877     return result;
 878   }
 879
 880
 881   extern void
 882   ft_mem_debug_done( FT_Memory  memory )
 883   {
 884     FT_MemTable  table = (FT_MemTable)memory->user;
 885
 886
 887     if ( table )
 888     {
 889       memory->free    = table->free;
 890       memory->realloc = table->realloc;
 891       memory->alloc   = table->alloc;
 892
 893       ft_mem_table_destroy( table );
 894       memory->user = NULL;
 895     }
 896   }
 897
 898
 899
 900   static int
 901   ft_mem_source_compare( const void*  p1,
 902                          const void*  p2 )
 903   {
 904     FT_MemSource  s1 = *(FT_MemSource*)p1;
 905     FT_MemSource  s2 = *(FT_MemSource*)p2;
 906
 907
 908     if ( s2->max_size > s1->max_size )
 909       return 1;
 910     else if ( s2->max_size < s1->max_size )
 911       return -1;
 912     else
 913       return 0;
 914   }
 915
 916
 917   extern void
 918   FT_DumpMemory( FT_Memory  memory )
 919   {
 920     FT_MemTable  table = (FT_MemTable)memory->user;
 921
 922
 923     if ( table )
 924     {
 925       FT_MemSource*  bucket = table->sources;
 926       FT_MemSource*  limit  = bucket + FT_MEM_SOURCE_BUCKETS;
 927       FT_MemSource*  sources;
 928       FT_UInt        nn, count;
 929       const char*    fmt;
 930
 931
 932       count = 0;
 933       for ( ; bucket < limit; bucket++ )
 934       {
 935         FT_MemSource  source = *bucket;
 936
 937
 938         for ( ; source; source = source->link )
 939           count++;
 940       }
 941
 942       sources = (FT_MemSource*)ft_mem_table_alloc(
 943                                  table, sizeof ( *sources ) * count );
 944
 945       count = 0;
 946       for ( bucket = table->sources; bucket < limit; bucket++ )
 947       {
 948         FT_MemSource  source = *bucket;
 949
 950
 951         for ( ; source; source = source->link )
 952           sources[count++] = source;
 953       }
 954
 955       ft_qsort( sources, count, sizeof ( *sources ), ft_mem_source_compare );
 956
 957       printf( "FreeType Memory Dump: "
 958               "current=%ld max=%ld total=%ld count=%ld\n",
 959               table->alloc_current, table->alloc_max,
 960               table->alloc_total, table->alloc_count );
 961       printf( " block  block    sizes    sizes    sizes   source\n" );
 962       printf( " count   high      sum  highsum      max   location\n" );
 963       printf( "-------------------------------------------------\n" );
 964
 965       fmt = "%6ld %6ld %8ld %8ld %8ld %s:%d\n";
 966
 967       for ( nn = 0; nn < count; nn++ )
 968       {
 969         FT_MemSource  source = sources[nn];
 970
 971
 972         printf( fmt,
 973                 source->cur_blocks, source->max_blocks,
 974                 source->cur_size, source->max_size, source->cur_max,
 975                 FT_FILENAME( source->file_name ),
 976                 source->line_no );
 977       }
 978       printf( "------------------------------------------------\n" );
 979
 980       ft_mem_table_free( table, sources );
 981     }
 982   }
 983
 984 #else  /* !FT_DEBUG_MEMORY */
 985
 986   /* ANSI C doesn't like empty source files */
 987   typedef int  _debug_mem_dummy;
 988
 989 #endif /* !FT_DEBUG_MEMORY */
 990
 991
 992 /* END */