/**************************************************************************** * * ftdbgmem.c * * Memory debugger (body). * * Copyright (C) 2001-2023 by * David Turner, Robert Wilhelm, and Werner Lemberg. * * This file is part of the FreeType project, and may only be used, * modified, and distributed under the terms of the FreeType project * license, LICENSE.TXT. By continuing to use, modify, or distribute * this file you indicate that you have read the license and * understand and accept it fully. * */ #include <ft2build.h> #include FT_CONFIG_CONFIG_H #include <freetype/internal/ftdebug.h> #include <freetype/internal/ftmemory.h> #include <freetype/ftsystem.h> #include <freetype/fterrors.h> #include <freetype/fttypes.h> #ifdef FT_DEBUG_MEMORY #define KEEPALIVE … #include FT_CONFIG_STANDARD_LIBRARY_H FT_BASE_DEF( const char* ) ft_debug_file_ = NULL; FT_BASE_DEF( long ) ft_debug_lineno_ = 0; extern void FT_DumpMemory( FT_Memory memory ); typedef struct FT_MemSourceRec_* FT_MemSource; typedef struct FT_MemNodeRec_* FT_MemNode; typedef struct FT_MemTableRec_* FT_MemTable; #define FT_MEM_VAL … /* * This structure holds statistics for a single allocation/release * site. This is useful to know where memory operations happen the * most. */ typedef struct FT_MemSourceRec_ { const char* file_name; long line_no; FT_Long cur_blocks; /* current number of allocated blocks */ FT_Long max_blocks; /* max. number of allocated blocks */ FT_Long all_blocks; /* total number of blocks allocated */ FT_Long cur_size; /* current cumulative allocated size */ FT_Long max_size; /* maximum cumulative allocated size */ FT_Long all_size; /* total cumulative allocated size */ FT_Long cur_max; /* current maximum allocated size */ FT_UInt32 hash; FT_MemSource link; } FT_MemSourceRec; /* * We don't need a resizable array for the memory sources because * their number is pretty limited within FreeType. */ #define FT_MEM_SOURCE_BUCKETS … /* * This structure holds information related to a single allocated * memory block. If KEEPALIVE is defined, blocks that are freed by * FreeType are never released to the system. Instead, their `size' * field is set to `-size'. This is mainly useful to detect double * frees, at the price of a large memory footprint during execution. */ typedef struct FT_MemNodeRec_ { FT_Byte* address; FT_Long size; /* < 0 if the block was freed */ FT_MemSource source; #ifdef KEEPALIVE const char* free_file_name; FT_Long free_line_no; #endif FT_MemNode link; } FT_MemNodeRec; /* * The global structure, containing compound statistics and all hash * tables. */ typedef struct FT_MemTableRec_ { FT_Long size; FT_Long nodes; FT_MemNode* buckets; FT_Long alloc_total; FT_Long alloc_current; FT_Long alloc_max; FT_Long alloc_count; FT_Bool bound_total; FT_Long alloc_total_max; FT_Bool bound_count; FT_Long alloc_count_max; FT_MemSource sources[FT_MEM_SOURCE_BUCKETS]; FT_Bool keep_alive; FT_Memory memory; FT_Pointer memory_user; FT_Alloc_Func alloc; FT_Free_Func free; FT_Realloc_Func realloc; } FT_MemTableRec; #define FT_MEM_SIZE_MIN … #define FT_MEM_SIZE_MAX … #define FT_FILENAME … /* * Prime numbers are ugly to handle. It would be better to implement * L-Hashing, which is 10% faster and doesn't require divisions. */ static const FT_Int ft_mem_primes[] = { 7, 11, 19, 37, 73, 109, 163, 251, 367, 557, 823, 1237, 1861, 2777, 4177, 6247, 9371, 14057, 21089, 31627, 47431, 71143, 106721, 160073, 240101, 360163, 540217, 810343, 1215497, 1823231, 2734867, 4102283, 6153409, 9230113, 13845163, }; static FT_Long ft_mem_closest_prime( FT_Long num ) { size_t i; for ( i = 0; i < sizeof ( ft_mem_primes ) / sizeof ( ft_mem_primes[0] ); i++ ) if ( ft_mem_primes[i] > num ) return ft_mem_primes[i]; return FT_MEM_SIZE_MAX; } static void ft_mem_debug_panic( const char* fmt, ... ) { va_list ap; printf( "FreeType.Debug: " ); va_start( ap, fmt ); vprintf( fmt, ap ); va_end( ap ); printf( "\n" ); exit( EXIT_FAILURE ); } static FT_Pointer ft_mem_table_alloc( FT_MemTable table, FT_Long size ) { FT_Memory memory = table->memory; FT_Pointer block; memory->user = table->memory_user; block = table->alloc( memory, size ); memory->user = table; return block; } static void ft_mem_table_free( FT_MemTable table, FT_Pointer block ) { FT_Memory memory = table->memory; memory->user = table->memory_user; table->free( memory, block ); memory->user = table; } static void ft_mem_table_resize( FT_MemTable table ) { FT_Long new_size; new_size = ft_mem_closest_prime( table->nodes ); if ( new_size != table->size ) { FT_MemNode* new_buckets; FT_Long i; new_buckets = (FT_MemNode *) ft_mem_table_alloc( table, new_size * (FT_Long)sizeof ( FT_MemNode ) ); if ( !new_buckets ) return; FT_ARRAY_ZERO( new_buckets, new_size ); for ( i = 0; i < table->size; i++ ) { FT_MemNode node, next, *pnode; FT_PtrDist hash; node = table->buckets[i]; while ( node ) { next = node->link; hash = FT_MEM_VAL( node->address ) % (FT_PtrDist)new_size; pnode = new_buckets + hash; node->link = pnode[0]; pnode[0] = node; node = next; } } if ( table->buckets ) ft_mem_table_free( table, table->buckets ); table->buckets = new_buckets; table->size = new_size; } } static void ft_mem_table_destroy( FT_MemTable table ) { FT_Long i; FT_Long leak_count = 0; FT_Long leaks = 0; /* remove all blocks from the table, revealing leaked ones */ for ( i = 0; i < table->size; i++ ) { FT_MemNode *pnode = table->buckets + i, next, node = *pnode; while ( node ) { next = node->link; node->link = NULL; if ( node->size > 0 ) { printf( "leaked memory block at address %p, size %8ld in (%s:%ld)\n", (void*)node->address, node->size, FT_FILENAME( node->source->file_name ), node->source->line_no ); leak_count++; leaks += node->size; ft_mem_table_free( table, node->address ); } node->address = NULL; node->size = 0; ft_mem_table_free( table, node ); node = next; } table->buckets[i] = NULL; } ft_mem_table_free( table, table->buckets ); table->buckets = NULL; table->size = 0; table->nodes = 0; /* remove all sources */ for ( i = 0; i < FT_MEM_SOURCE_BUCKETS; i++ ) { FT_MemSource source, next; for ( source = table->sources[i]; source != NULL; source = next ) { next = source->link; ft_mem_table_free( table, source ); } table->sources[i] = NULL; } printf( "FreeType: total memory allocations = %ld\n", table->alloc_total ); printf( "FreeType: maximum memory footprint = %ld\n", table->alloc_max ); if ( leak_count > 0 ) ft_mem_debug_panic( "FreeType: %ld bytes of memory leaked in %ld blocks\n", leaks, leak_count ); printf( "FreeType: no memory leaks detected\n" ); } static FT_MemNode* ft_mem_table_get_nodep( FT_MemTable table, FT_Byte* address ) { FT_PtrDist hash; FT_MemNode *pnode, node; hash = FT_MEM_VAL( address ); pnode = table->buckets + ( hash % (FT_PtrDist)table->size ); for (;;) { node = pnode[0]; if ( !node ) break; if ( node->address == address ) break; pnode = &node->link; } return pnode; } static FT_MemSource ft_mem_table_get_source( FT_MemTable table ) { FT_UInt32 hash; FT_MemSource node, *pnode; /* cast to FT_PtrDist first since void* can be larger */ /* than FT_UInt32 and GCC 4.1.1 emits a warning */ hash = (FT_UInt32)(FT_PtrDist)(void*)ft_debug_file_ + (FT_UInt32)( 5 * ft_debug_lineno_ ); pnode = &table->sources[hash % FT_MEM_SOURCE_BUCKETS]; for (;;) { node = *pnode; if ( !node ) break; if ( node->file_name == ft_debug_file_ && node->line_no == ft_debug_lineno_ ) goto Exit; pnode = &node->link; } node = (FT_MemSource)ft_mem_table_alloc( table, sizeof ( *node ) ); if ( !node ) ft_mem_debug_panic( "not enough memory to perform memory debugging\n" ); node->file_name = ft_debug_file_; node->line_no = ft_debug_lineno_; node->cur_blocks = 0; node->max_blocks = 0; node->all_blocks = 0; node->cur_size = 0; node->max_size = 0; node->all_size = 0; node->cur_max = 0; node->link = NULL; node->hash = hash; *pnode = node; Exit: return node; } static void ft_mem_table_set( FT_MemTable table, FT_Byte* address, FT_Long size, FT_Long delta ) { FT_MemNode *pnode, node; if ( table ) { FT_MemSource source; pnode = ft_mem_table_get_nodep( table, address ); node = *pnode; if ( node ) { if ( node->size < 0 ) { /* This block was already freed. Our memory is now completely */ /* corrupted! */ /* This can only happen in keep-alive mode. */ ft_mem_debug_panic( "memory heap corrupted (allocating freed block)" ); } else { /* This block was already allocated. This means that our memory */ /* is also corrupted! */ ft_mem_debug_panic( "memory heap corrupted (re-allocating allocated block at" " %p, of size %ld)\n" "org=%s:%d new=%s:%d\n", node->address, node->size, FT_FILENAME( node->source->file_name ), node->source->line_no, FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_ ); } } /* we need to create a new node in this table */ node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) ); if ( !node ) ft_mem_debug_panic( "not enough memory to run memory tests" ); node->address = address; node->size = size; node->source = source = ft_mem_table_get_source( table ); if ( delta == 0 ) { /* this is an allocation */ source->all_blocks++; source->cur_blocks++; if ( source->cur_blocks > source->max_blocks ) source->max_blocks = source->cur_blocks; } if ( size > source->cur_max ) source->cur_max = size; if ( delta != 0 ) { /* we are growing or shrinking a reallocated block */ source->cur_size += delta; table->alloc_current += delta; } else { /* we are allocating a new block */ source->cur_size += size; table->alloc_current += size; } source->all_size += size; if ( source->cur_size > source->max_size ) source->max_size = source->cur_size; node->free_file_name = NULL; node->free_line_no = 0; node->link = pnode[0]; pnode[0] = node; table->nodes++; table->alloc_total += size; if ( table->alloc_current > table->alloc_max ) table->alloc_max = table->alloc_current; if ( table->nodes * 3 < table->size || table->size * 3 < table->nodes ) ft_mem_table_resize( table ); } } static void ft_mem_table_remove( FT_MemTable table, FT_Byte* address, FT_Long delta ) { if ( table ) { FT_MemNode *pnode, node; pnode = ft_mem_table_get_nodep( table, address ); node = *pnode; if ( node ) { FT_MemSource source; if ( node->size < 0 ) ft_mem_debug_panic( "freeing memory block at %p more than once\n" " at (%s:%ld)!\n" " Block was allocated at (%s:%ld)\n" " and released at (%s:%ld).", address, FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_, FT_FILENAME( node->source->file_name ), node->source->line_no, FT_FILENAME( node->free_file_name ), node->free_line_no ); /* scramble the node's content for additional safety */ FT_MEM_SET( address, 0xF3, node->size ); if ( delta == 0 ) { source = node->source; source->cur_blocks--; source->cur_size -= node->size; table->alloc_current -= node->size; } if ( table->keep_alive ) { /* we simply invert the node's size to indicate that the node */ /* was freed. */ node->size = -node->size; node->free_file_name = ft_debug_file_; node->free_line_no = ft_debug_lineno_; } else { table->nodes--; *pnode = node->link; node->size = 0; node->source = NULL; ft_mem_table_free( table, node ); if ( table->nodes * 3 < table->size || table->size * 3 < table->nodes ) ft_mem_table_resize( table ); } } else ft_mem_debug_panic( "trying to free unknown block at %p in (%s:%ld)\n", address, FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_ ); } } static FT_Pointer ft_mem_debug_alloc( FT_Memory memory, FT_Long size ) { FT_MemTable table = (FT_MemTable)memory->user; FT_Byte* block; if ( size <= 0 ) ft_mem_debug_panic( "negative block size allocation (%ld)", size ); /* return NULL if the maximum number of allocations was reached */ if ( table->bound_count && table->alloc_count >= table->alloc_count_max ) return NULL; /* return NULL if this allocation would overflow the maximum heap size */ if ( table->bound_total && table->alloc_total_max - table->alloc_current > size ) return NULL; block = (FT_Byte *)ft_mem_table_alloc( table, size ); if ( block ) { ft_mem_table_set( table, block, size, 0 ); table->alloc_count++; } ft_debug_file_ = "<unknown>"; ft_debug_lineno_ = 0; return (FT_Pointer)block; } static void ft_mem_debug_free( FT_Memory memory, FT_Pointer block ) { FT_MemTable table = (FT_MemTable)memory->user; if ( !block ) ft_mem_debug_panic( "trying to free NULL in (%s:%ld)", FT_FILENAME( ft_debug_file_ ), ft_debug_lineno_ ); ft_mem_table_remove( table, (FT_Byte*)block, 0 ); if ( !table->keep_alive ) ft_mem_table_free( table, block ); table->alloc_count--; ft_debug_file_ = "<unknown>"; ft_debug_lineno_ = 0; } static FT_Pointer ft_mem_debug_realloc( FT_Memory memory, FT_Long cur_size, FT_Long new_size, FT_Pointer block ) { FT_MemTable table = (FT_MemTable)memory->user; FT_MemNode node, *pnode; FT_Pointer new_block; FT_Long delta; const char* file_name = FT_FILENAME( ft_debug_file_ ); FT_Long line_no = ft_debug_lineno_; /* unlikely, but possible */ if ( new_size == cur_size ) return block; /* the following is valid according to ANSI C */ #if 0 if ( !block || !cur_size ) ft_mem_debug_panic( "trying to reallocate NULL in (%s:%ld)", file_name, line_no ); #endif /* while the following is allowed in ANSI C also, we abort since */ /* such case should be handled by FreeType. */ if ( new_size <= 0 ) ft_mem_debug_panic( "trying to reallocate %p to size 0 (current is %ld) in (%s:%ld)", block, cur_size, file_name, line_no ); /* check `cur_size' value */ pnode = ft_mem_table_get_nodep( table, (FT_Byte*)block ); node = *pnode; if ( !node ) ft_mem_debug_panic( "trying to reallocate unknown block at %p in (%s:%ld)", block, file_name, line_no ); if ( node->size <= 0 ) ft_mem_debug_panic( "trying to reallocate freed block at %p in (%s:%ld)", block, file_name, line_no ); if ( node->size != cur_size ) ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is " "%ld instead of %ld in (%s:%ld)", block, cur_size, node->size, file_name, line_no ); /* return NULL if the maximum number of allocations was reached */ if ( table->bound_count && table->alloc_count >= table->alloc_count_max ) return NULL; delta = new_size - cur_size; /* return NULL if this allocation would overflow the maximum heap size */ if ( delta > 0 && table->bound_total && table->alloc_current + delta > table->alloc_total_max ) return NULL; new_block = (FT_Pointer)ft_mem_table_alloc( table, new_size ); if ( !new_block ) return NULL; ft_mem_table_set( table, (FT_Byte*)new_block, new_size, delta ); ft_memcpy( new_block, block, cur_size < new_size ? (size_t)cur_size : (size_t)new_size ); ft_mem_table_remove( table, (FT_Byte*)block, delta ); ft_debug_file_ = "<unknown>"; ft_debug_lineno_ = 0; if ( !table->keep_alive ) ft_mem_table_free( table, block ); return new_block; } extern void ft_mem_debug_init( FT_Memory memory ) { FT_MemTable table; if ( !ft_getenv( "FT2_DEBUG_MEMORY" ) ) return; table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) ); if ( table ) { FT_ZERO( table ); table->memory = memory; table->memory_user = memory->user; table->alloc = memory->alloc; table->realloc = memory->realloc; table->free = memory->free; ft_mem_table_resize( table ); if ( table->size ) { const char* p; memory->user = table; memory->alloc = ft_mem_debug_alloc; memory->realloc = ft_mem_debug_realloc; memory->free = ft_mem_debug_free; p = ft_getenv( "FT2_ALLOC_TOTAL_MAX" ); if ( p ) { FT_Long total_max = ft_strtol( p, NULL, 10 ); if ( total_max > 0 ) { table->bound_total = 1; table->alloc_total_max = total_max; } } p = ft_getenv( "FT2_ALLOC_COUNT_MAX" ); if ( p ) { FT_Long total_count = ft_strtol( p, NULL, 10 ); if ( total_count > 0 ) { table->bound_count = 1; table->alloc_count_max = total_count; } } p = ft_getenv( "FT2_KEEP_ALIVE" ); if ( p ) { FT_Long keep_alive = ft_strtol( p, NULL, 10 ); if ( keep_alive > 0 ) table->keep_alive = 1; } } else memory->free( memory, table ); } } extern void ft_mem_debug_done( FT_Memory memory ) { if ( memory->free == ft_mem_debug_free ) { FT_MemTable table = (FT_MemTable)memory->user; FT_DumpMemory( memory ); ft_mem_table_destroy( table ); memory->free = table->free; memory->realloc = table->realloc; memory->alloc = table->alloc; memory->user = table->memory_user; memory->free( memory, table ); } } FT_COMPARE_DEF( int ) ft_mem_source_compare( const void* p1, const void* p2 ) { FT_MemSource s1 = *(FT_MemSource*)p1; FT_MemSource s2 = *(FT_MemSource*)p2; if ( s2->max_size > s1->max_size ) return 1; else if ( s2->max_size < s1->max_size ) return -1; else return 0; } extern void FT_DumpMemory( FT_Memory memory ) { if ( memory->free == ft_mem_debug_free ) { FT_MemTable table = (FT_MemTable)memory->user; FT_MemSource* bucket = table->sources; FT_MemSource* limit = bucket + FT_MEM_SOURCE_BUCKETS; FT_MemSource* sources; FT_Int nn, count; const char* fmt; count = 0; for ( ; bucket < limit; bucket++ ) { FT_MemSource source = *bucket; for ( ; source; source = source->link ) count++; } sources = (FT_MemSource*) ft_mem_table_alloc( table, count * (FT_Long)sizeof ( *sources ) ); count = 0; for ( bucket = table->sources; bucket < limit; bucket++ ) { FT_MemSource source = *bucket; for ( ; source; source = source->link ) sources[count++] = source; } ft_qsort( sources, (size_t)count, sizeof ( *sources ), ft_mem_source_compare ); printf( "FreeType Memory Dump: " "current=%ld max=%ld total=%ld count=%ld\n", table->alloc_current, table->alloc_max, table->alloc_total, table->alloc_count ); printf( " block block sizes sizes sizes source\n" ); printf( " count high sum highsum max location\n" ); printf( "-------------------------------------------------\n" ); fmt = "%6ld %6ld %8ld %8ld %8ld %s:%d\n"; for ( nn = 0; nn < count; nn++ ) { FT_MemSource source = sources[nn]; printf( fmt, source->cur_blocks, source->max_blocks, source->cur_size, source->max_size, source->cur_max, FT_FILENAME( source->file_name ), source->line_no ); } printf( "------------------------------------------------\n" ); ft_mem_table_free( table, sources ); } } #else /* !FT_DEBUG_MEMORY */ /* ANSI C doesn't like empty source files */ debug_mem_dummy_; #endif /* !FT_DEBUG_MEMORY */ /* END */
Codebase Browser
godot