src/base/ftdbgmem.c

   1 /****************************************************************************
   2  *
   3  * ftdbgmem.c
   4  *
   5  *   Memory debugger (body).
   6  *
   7  * Copyright (C) 2001-2023 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 <freetype/internal/ftdebug.h>
  22 #include <freetype/internal/ftmemory.h>
  23 #include <freetype/ftsystem.h>
  24 #include <freetype/fterrors.h>
  25 #include <freetype/fttypes.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_   = NULL;
  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
  89    * frees, at the price of a 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_Long          size;
 115     FT_Long          nodes;
 116     FT_MemNode*      buckets;
 117
 118     FT_Long          alloc_total;
 119     FT_Long          alloc_current;
 120     FT_Long          alloc_max;
 121     FT_Long          alloc_count;
 122
 123     FT_Bool          bound_total;
 124     FT_Long          alloc_total_max;
 125
 126     FT_Bool          bound_count;
 127     FT_Long          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_Int  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_Long
 193   ft_mem_closest_prime( FT_Long  num )
 194   {
 195     size_t  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   static 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_Long  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_Long      i;
 265
 266
 267       new_buckets = (FT_MemNode *)
 268                       ft_mem_table_alloc(
 269                         table,
 270                         new_size * (FT_Long)sizeof ( FT_MemNode ) );
 271       if ( !new_buckets )
 272         return;
 273
 274       FT_ARRAY_ZERO( new_buckets, new_size );
 275
 276       for ( i = 0; i < table->size; i++ )
 277       {
 278         FT_MemNode  node, next, *pnode;
 279         FT_PtrDist  hash;
 280
 281
 282         node = table->buckets[i];
 283         while ( node )
 284         {
 285           next  = node->link;
 286           hash  = FT_MEM_VAL( node->address ) % (FT_PtrDist)new_size;
 287           pnode = new_buckets + hash;
 288
 289           node->link = pnode[0];
 290           pnode[0]   = node;
 291
 292           node = next;
 293         }
 294       }
 295
 296       if ( table->buckets )
 297         ft_mem_table_free( table, table->buckets );
 298
 299       table->buckets = new_buckets;
 300       table->size    = new_size;
 301     }
 302   }
 303
 304
 305   static void
 306   ft_mem_table_destroy( FT_MemTable  table )
 307   {
 308     FT_Long  i;
 309     FT_Long  leak_count = 0;
 310     FT_Long  leaks      = 0;
 311
 312
 313     /* remove all blocks from the table, revealing leaked ones */
 314     for ( i = 0; i < table->size; i++ )
 315     {
 316       FT_MemNode  *pnode = table->buckets + i, next, node = *pnode;
 317
 318
 319       while ( node )
 320       {
 321         next       = node->link;
 322         node->link = NULL;
 323
 324         if ( node->size > 0 )
 325         {
 326           printf(
 327             "leaked memory block at address %p, size %8ld in (%s:%ld)\n",
 328             (void*)node->address,
 329             node->size,
 330             FT_FILENAME( node->source->file_name ),
 331             node->source->line_no );
 332
 333           leak_count++;
 334           leaks += node->size;
 335
 336           ft_mem_table_free( table, node->address );
 337         }
 338
 339         node->address = NULL;
 340         node->size    = 0;
 341
 342         ft_mem_table_free( table, node );
 343         node = next;
 344       }
 345       table->buckets[i] = NULL;
 346     }
 347
 348     ft_mem_table_free( table, table->buckets );
 349     table->buckets = NULL;
 350
 351     table->size  = 0;
 352     table->nodes = 0;
 353
 354     /* remove all sources */
 355     for ( i = 0; i < FT_MEM_SOURCE_BUCKETS; i++ )
 356     {
 357       FT_MemSource  source, next;
 358
 359
 360       for ( source = table->sources[i]; source != NULL; source = next )
 361       {
 362         next = source->link;
 363         ft_mem_table_free( table, source );
 364       }
 365
 366       table->sources[i] = NULL;
 367     }
 368
 369     printf( "FreeType: total memory allocations = %ld\n",
 370             table->alloc_total );
 371     printf( "FreeType: maximum memory footprint = %ld\n",
 372             table->alloc_max );
 373
 374     if ( leak_count > 0 )
 375       ft_mem_debug_panic(
 376         "FreeType: %ld bytes of memory leaked in %ld blocks\n",
 377         leaks, leak_count );
 378
 379     printf( "FreeType: no memory leaks detected\n" );
 380   }
 381
 382
 383   static FT_MemNode*
 384   ft_mem_table_get_nodep( FT_MemTable  table,
 385                           FT_Byte*     address )
 386   {
 387     FT_PtrDist   hash;
 388     FT_MemNode  *pnode, node;
 389
 390
 391     hash  = FT_MEM_VAL( address );
 392     pnode = table->buckets + ( hash % (FT_PtrDist)table->size );
 393
 394     for (;;)
 395     {
 396       node = pnode[0];
 397       if ( !node )
 398         break;
 399
 400       if ( node->address == address )
 401         break;
 402
 403       pnode = &node->link;
 404     }
 405     return pnode;
 406   }
 407
 408
 409   static FT_MemSource
 410   ft_mem_table_get_source( FT_MemTable  table )
 411   {
 412     FT_UInt32     hash;
 413     FT_MemSource  node, *pnode;
 414
 415
 416     /* cast to FT_PtrDist first since void* can be larger */
 417     /* than FT_UInt32 and GCC 4.1.1 emits a warning       */
 418     hash  = (FT_UInt32)(FT_PtrDist)(void*)ft_debug_file_ +
 419               (FT_UInt32)( 5 * ft_debug_lineno_ );
 420     pnode = &table->sources[hash % FT_MEM_SOURCE_BUCKETS];
 421
 422     for (;;)
 423     {
 424       node = *pnode;
 425       if ( !node )
 426         break;
 427
 428       if ( node->file_name == ft_debug_file_   &&
 429            node->line_no   == ft_debug_lineno_ )
 430         goto Exit;
 431
 432       pnode = &node->link;
 433     }
 434
 435     node = (FT_MemSource)ft_mem_table_alloc( table, sizeof ( *node ) );
 436     if ( !node )
 437       ft_mem_debug_panic(
 438         "not enough memory to perform memory debugging\n" );
 439
 440     node->file_name = ft_debug_file_;
 441     node->line_no   = ft_debug_lineno_;
 442
 443     node->cur_blocks = 0;
 444     node->max_blocks = 0;
 445     node->all_blocks = 0;
 446
 447     node->cur_size = 0;
 448     node->max_size = 0;
 449     node->all_size = 0;
 450
 451     node->cur_max = 0;
 452
 453     node->link = NULL;
 454     node->hash = hash;
 455     *pnode     = node;
 456
 457   Exit:
 458     return node;
 459   }
 460
 461
 462   static void
 463   ft_mem_table_set( FT_MemTable  table,
 464                     FT_Byte*     address,
 465                     FT_Long      size,
 466                     FT_Long      delta )
 467   {
 468     FT_MemNode  *pnode, node;
 469
 470
 471     if ( table )
 472     {
 473       FT_MemSource  source;
 474
 475
 476       pnode = ft_mem_table_get_nodep( table, address );
 477       node  = *pnode;
 478       if ( node )
 479       {
 480         if ( node->size < 0 )
 481         {
 482           /* This block was already freed.  Our memory is now completely */
 483           /* corrupted!                                                  */
 484           /* This can only happen in keep-alive mode.                    */
 485           ft_mem_debug_panic(
 486             "memory heap corrupted (allocating freed block)" );
 487         }
 488         else
 489         {
 490           /* This block was already allocated.  This means that our memory */
 491           /* is also corrupted!                                            */
 492           ft_mem_debug_panic(
 493             "memory heap corrupted (re-allocating allocated block at"
 494             " %p, of size %ld)\n"
 495             "org=%s:%d new=%s:%d\n",
 496             node->address, node->size,
 497             FT_FILENAME( node->source->file_name ), node->source->line_no,
 498             FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_ );
 499         }
 500       }
 501
 502       /* we need to create a new node in this table */
 503       node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) );
 504       if ( !node )
 505         ft_mem_debug_panic( "not enough memory to run memory tests" );
 506
 507       node->address = address;
 508       node->size    = size;
 509       node->source  = source = ft_mem_table_get_source( table );
 510
 511       if ( delta == 0 )
 512       {
 513         /* this is an allocation */
 514         source->all_blocks++;
 515         source->cur_blocks++;
 516         if ( source->cur_blocks > source->max_blocks )
 517           source->max_blocks = source->cur_blocks;
 518       }
 519
 520       if ( size > source->cur_max )
 521         source->cur_max = size;
 522
 523       if ( delta != 0 )
 524       {
 525         /* we are growing or shrinking a reallocated block */
 526         source->cur_size     += delta;
 527         table->alloc_current += delta;
 528       }
 529       else
 530       {
 531         /* we are allocating a new block */
 532         source->cur_size     += size;
 533         table->alloc_current += size;
 534       }
 535
 536       source->all_size += size;
 537
 538       if ( source->cur_size > source->max_size )
 539         source->max_size = source->cur_size;
 540
 541       node->free_file_name = NULL;
 542       node->free_line_no   = 0;
 543
 544       node->link = pnode[0];
 545
 546       pnode[0] = node;
 547       table->nodes++;
 548
 549       table->alloc_total += size;
 550
 551       if ( table->alloc_current > table->alloc_max )
 552         table->alloc_max = table->alloc_current;
 553
 554       if ( table->nodes * 3 < table->size  ||
 555            table->size  * 3 < table->nodes )
 556         ft_mem_table_resize( table );
 557     }
 558   }
 559
 560
 561   static void
 562   ft_mem_table_remove( FT_MemTable  table,
 563                        FT_Byte*     address,
 564                        FT_Long      delta )
 565   {
 566     if ( table )
 567     {
 568       FT_MemNode  *pnode, node;
 569
 570
 571       pnode = ft_mem_table_get_nodep( table, address );
 572       node  = *pnode;
 573       if ( node )
 574       {
 575         FT_MemSource  source;
 576
 577
 578         if ( node->size < 0 )
 579           ft_mem_debug_panic(
 580             "freeing memory block at %p more than once\n"
 581             "  at (%s:%ld)!\n"
 582             "  Block was allocated at (%s:%ld)\n"
 583             "  and released at (%s:%ld).",
 584             address,
 585             FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_,
 586             FT_FILENAME( node->source->file_name ), node->source->line_no,
 587             FT_FILENAME( node->free_file_name ), node->free_line_no );
 588
 589         /* scramble the node's content for additional safety */
 590         FT_MEM_SET( address, 0xF3, node->size );
 591
 592         if ( delta == 0 )
 593         {
 594           source = node->source;
 595
 596           source->cur_blocks--;
 597           source->cur_size -= node->size;
 598
 599           table->alloc_current -= node->size;
 600         }
 601
 602         if ( table->keep_alive )
 603         {
 604           /* we simply invert the node's size to indicate that the node */
 605           /* was freed.                                                 */
 606           node->size           = -node->size;
 607           node->free_file_name = ft_debug_file_;
 608           node->free_line_no   = ft_debug_lineno_;
 609         }
 610         else
 611         {
 612           table->nodes--;
 613
 614           *pnode = node->link;
 615
 616           node->size   = 0;
 617           node->source = NULL;
 618
 619           ft_mem_table_free( table, node );
 620
 621           if ( table->nodes * 3 < table->size  ||
 622                table->size  * 3 < table->nodes )
 623             ft_mem_table_resize( table );
 624         }
 625       }
 626       else
 627         ft_mem_debug_panic(
 628           "trying to free unknown block at %p in (%s:%ld)\n",
 629           address,
 630           FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_ );
 631     }
 632   }
 633
 634
 635   static FT_Pointer
 636   ft_mem_debug_alloc( FT_Memory  memory,
 637                       FT_Long    size )
 638   {
 639     FT_MemTable  table = (FT_MemTable)memory->user;
 640     FT_Byte*     block;
 641
 642
 643     if ( size <= 0 )
 644       ft_mem_debug_panic( "negative block size allocation (%ld)", size );
 645
 646     /* return NULL if the maximum number of allocations was reached */
 647     if ( table->bound_count                           &&
 648          table->alloc_count >= table->alloc_count_max )
 649       return NULL;
 650
 651     /* return NULL if this allocation would overflow the maximum heap size */
 652     if ( table->bound_total                                   &&
 653          table->alloc_total_max - table->alloc_current > size )
 654       return NULL;
 655
 656     block = (FT_Byte *)ft_mem_table_alloc( table, size );
 657     if ( block )
 658     {
 659       ft_mem_table_set( table, block, size, 0 );
 660
 661       table->alloc_count++;
 662     }
 663
 664     ft_debug_file_   = "<unknown>";
 665     ft_debug_lineno_ = 0;
 666
 667     return (FT_Pointer)block;
 668   }
 669
 670
 671   static void
 672   ft_mem_debug_free( FT_Memory   memory,
 673                      FT_Pointer  block )
 674   {
 675     FT_MemTable  table = (FT_MemTable)memory->user;
 676
 677
 678     if ( !block )
 679       ft_mem_debug_panic( "trying to free NULL in (%s:%ld)",
 680                           FT_FILENAME( ft_debug_file_ ),
 681                           ft_debug_lineno_ );
 682
 683     ft_mem_table_remove( table, (FT_Byte*)block, 0 );
 684
 685     if ( !table->keep_alive )
 686       ft_mem_table_free( table, block );
 687
 688     table->alloc_count--;
 689
 690     ft_debug_file_   = "<unknown>";
 691     ft_debug_lineno_ = 0;
 692   }
 693
 694
 695   static FT_Pointer
 696   ft_mem_debug_realloc( FT_Memory   memory,
 697                         FT_Long     cur_size,
 698                         FT_Long     new_size,
 699                         FT_Pointer  block )
 700   {
 701     FT_MemTable  table = (FT_MemTable)memory->user;
 702     FT_MemNode   node, *pnode;
 703     FT_Pointer   new_block;
 704     FT_Long      delta;
 705
 706     const char*  file_name = FT_FILENAME( ft_debug_file_ );
 707     FT_Long      line_no   = ft_debug_lineno_;
 708
 709
 710     /* unlikely, but possible */
 711     if ( new_size == cur_size )
 712       return block;
 713
 714     /* the following is valid according to ANSI C */
 715 #if 0
 716     if ( !block || !cur_size )
 717       ft_mem_debug_panic( "trying to reallocate NULL in (%s:%ld)",
 718                           file_name, line_no );
 719 #endif
 720
 721     /* while the following is allowed in ANSI C also, we abort since */
 722     /* such case should be handled by FreeType.                      */
 723     if ( new_size <= 0 )
 724       ft_mem_debug_panic(
 725         "trying to reallocate %p to size 0 (current is %ld) in (%s:%ld)",
 726         block, cur_size, file_name, line_no );
 727
 728     /* check `cur_size' value */
 729     pnode = ft_mem_table_get_nodep( table, (FT_Byte*)block );
 730     node  = *pnode;
 731     if ( !node )
 732       ft_mem_debug_panic(
 733         "trying to reallocate unknown block at %p in (%s:%ld)",
 734         block, file_name, line_no );
 735
 736     if ( node->size <= 0 )
 737       ft_mem_debug_panic(
 738         "trying to reallocate freed block at %p in (%s:%ld)",
 739         block, file_name, line_no );
 740
 741     if ( node->size != cur_size )
 742       ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is "
 743                           "%ld instead of %ld in (%s:%ld)",
 744                           block, cur_size, node->size, file_name, line_no );
 745
 746     /* return NULL if the maximum number of allocations was reached */
 747     if ( table->bound_count                           &&
 748          table->alloc_count >= table->alloc_count_max )
 749       return NULL;
 750
 751     delta = new_size - cur_size;
 752
 753     /* return NULL if this allocation would overflow the maximum heap size */
 754     if ( delta > 0                                             &&
 755          table->bound_total                                    &&
 756          table->alloc_current + delta > table->alloc_total_max )
 757       return NULL;
 758
 759     new_block = (FT_Pointer)ft_mem_table_alloc( table, new_size );
 760     if ( !new_block )
 761       return NULL;
 762
 763     ft_mem_table_set( table, (FT_Byte*)new_block, new_size, delta );
 764
 765     ft_memcpy( new_block, block, cur_size < new_size ? (size_t)cur_size
 766                                                      : (size_t)new_size );
 767
 768     ft_mem_table_remove( table, (FT_Byte*)block, delta );
 769
 770     ft_debug_file_   = "<unknown>";
 771     ft_debug_lineno_ = 0;
 772
 773     if ( !table->keep_alive )
 774       ft_mem_table_free( table, block );
 775
 776     return new_block;
 777   }
 778
 779
 780   extern void
 781   ft_mem_debug_init( FT_Memory  memory )
 782   {
 783     FT_MemTable  table;
 784
 785
 786     if ( !ft_getenv( "FT2_DEBUG_MEMORY" ) )
 787       return;
 788
 789     table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) );
 790
 791     if ( table )
 792     {
 793       FT_ZERO( table );
 794
 795       table->memory      = memory;
 796       table->memory_user = memory->user;
 797       table->alloc       = memory->alloc;
 798       table->realloc     = memory->realloc;
 799       table->free        = memory->free;
 800
 801       ft_mem_table_resize( table );
 802
 803       if ( table->size )
 804       {
 805         const char*  p;
 806
 807
 808         memory->user    = table;
 809         memory->alloc   = ft_mem_debug_alloc;
 810         memory->realloc = ft_mem_debug_realloc;
 811         memory->free    = ft_mem_debug_free;
 812
 813         p = ft_getenv( "FT2_ALLOC_TOTAL_MAX" );
 814         if ( p )
 815         {
 816           FT_Long  total_max = ft_strtol( p, NULL, 10 );
 817
 818
 819           if ( total_max > 0 )
 820           {
 821             table->bound_total     = 1;
 822             table->alloc_total_max = total_max;
 823           }
 824         }
 825
 826         p = ft_getenv( "FT2_ALLOC_COUNT_MAX" );
 827         if ( p )
 828         {
 829           FT_Long  total_count = ft_strtol( p, NULL, 10 );
 830
 831
 832           if ( total_count > 0 )
 833           {
 834             table->bound_count     = 1;
 835             table->alloc_count_max = total_count;
 836           }
 837         }
 838
 839         p = ft_getenv( "FT2_KEEP_ALIVE" );
 840         if ( p )
 841         {
 842           FT_Long  keep_alive = ft_strtol( p, NULL, 10 );
 843
 844
 845           if ( keep_alive > 0 )
 846             table->keep_alive = 1;
 847         }
 848       }
 849       else
 850         memory->free( memory, table );
 851     }
 852   }
 853
 854
 855   extern void
 856   ft_mem_debug_done( FT_Memory  memory )
 857   {
 858     if ( memory->free == ft_mem_debug_free )
 859     {
 860       FT_MemTable  table = (FT_MemTable)memory->user;
 861
 862
 863       FT_DumpMemory( memory );
 864
 865       ft_mem_table_destroy( table );
 866
 867       memory->free    = table->free;
 868       memory->realloc = table->realloc;
 869       memory->alloc   = table->alloc;
 870       memory->user    = table->memory_user;
 871
 872       memory->free( memory, table );
 873     }
 874   }
 875
 876
 877   FT_COMPARE_DEF( int )
 878   ft_mem_source_compare( const void*  p1,
 879                          const void*  p2 )
 880   {
 881     FT_MemSource  s1 = *(FT_MemSource*)p1;
 882     FT_MemSource  s2 = *(FT_MemSource*)p2;
 883
 884
 885     if ( s2->max_size > s1->max_size )
 886       return 1;
 887     else if ( s2->max_size < s1->max_size )
 888       return -1;
 889     else
 890       return 0;
 891   }
 892
 893
 894   extern void
 895   FT_DumpMemory( FT_Memory  memory )
 896   {
 897     if ( memory->free == ft_mem_debug_free )
 898     {
 899       FT_MemTable    table = (FT_MemTable)memory->user;
 900       FT_MemSource*  bucket = table->sources;
 901       FT_MemSource*  limit  = bucket + FT_MEM_SOURCE_BUCKETS;
 902       FT_MemSource*  sources;
 903       FT_Int         nn, count;
 904       const char*    fmt;
 905
 906
 907       count = 0;
 908       for ( ; bucket < limit; bucket++ )
 909       {
 910         FT_MemSource  source = *bucket;
 911
 912
 913         for ( ; source; source = source->link )
 914           count++;
 915       }
 916
 917       sources = (FT_MemSource*)
 918                   ft_mem_table_alloc(
 919                     table, count * (FT_Long)sizeof ( *sources ) );
 920
 921       count = 0;
 922       for ( bucket = table->sources; bucket < limit; bucket++ )
 923       {
 924         FT_MemSource  source = *bucket;
 925
 926
 927         for ( ; source; source = source->link )
 928           sources[count++] = source;
 929       }
 930
 931       ft_qsort( sources,
 932                 (size_t)count,
 933                 sizeof ( *sources ),
 934                 ft_mem_source_compare );
 935
 936       printf( "FreeType Memory Dump: "
 937               "current=%ld max=%ld total=%ld count=%ld\n",
 938               table->alloc_current, table->alloc_max,
 939               table->alloc_total, table->alloc_count );
 940       printf( " block  block    sizes    sizes    sizes   source\n" );
 941       printf( " count   high      sum  highsum      max   location\n" );
 942       printf( "-------------------------------------------------\n" );
 943
 944       fmt = "%6ld %6ld %8ld %8ld %8ld %s:%d\n";
 945
 946       for ( nn = 0; nn < count; nn++ )
 947       {
 948         FT_MemSource  source = sources[nn];
 949
 950
 951         printf( fmt,
 952                 source->cur_blocks, source->max_blocks,
 953                 source->cur_size, source->max_size, source->cur_max,
 954                 FT_FILENAME( source->file_name ),
 955                 source->line_no );
 956       }
 957       printf( "------------------------------------------------\n" );
 958
 959       ft_mem_table_free( table, sources );
 960     }
 961   }
 962
 963 #else  /* !FT_DEBUG_MEMORY */
 964
 965   /* ANSI C doesn't like empty source files */
 966   typedef int  debug_mem_dummy_;
 967
 968 #endif /* !FT_DEBUG_MEMORY */
 969
 970
 971 /* END */