1/***************************************************************************/
2/*                                                                         */
3/*  ftdbgmem.c                                                             */
4/*                                                                         */
5/*    Memory debugger (body).                                              */
6/*                                                                         */
7/*  Copyright 2001-2018 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 ( ft_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 = ft_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 = ft_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 = ft_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