src/third_party/freetype2/src/src/base/ftdbgmem.c

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