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