Chiebot-Mirror
/
freetype
mirror of https://github.com/freetype/freetype.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

[base] Clean up signedness issues in `ftdbgmem.c'.

Browse Source 
Also fix other minor issues.

* src/base/ftdbgmem.c (FT_MemTableRec): Replace all FT_ULong types
with FT_Long for consistency.
(ft_mem_primes): Change type to `FT_Int'.
(ft_mem_closest_prime, ft_mem_table_set): Updated.

(ft_mem_debug_panic, ft_mem_debug_alloc, ft_mem_debug_free,
ft_mem_debug_realloc): Use `static' keyword and fix signedness
warnings where necessary.

(ft_mem_table_resize, ft_mem_table_new, ft_mem_table_destroy,
ft_mem_table_get_nodep, ft_mem_debug_init, FT_DumpMemory): Fix types
and add or remove casts to avoid signedness warnings.
2.6.5
Werner Lemberg 10 years ago
parent 6d7d636b46
commit 48186b8168
2 changed files with 81 additions and 56 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 19
      ChangeLog
  2. 118
      src/base/ftdbgmem.c

19
ChangeLog
Unescape View File

@ -1,3 +1,22 @@
2015-02-15 Werner Lemberg <wl@gnu.org>
[base] Clean up signedness issues in `ftdbgmem.c'.
Also fix other minor issues.
* src/base/ftdbgmem.c (FT_MemTableRec): Replace all FT_ULong types
with FT_Long for consistency.
(ft_mem_primes): Change type to `FT_Int'.
(ft_mem_closest_prime, ft_mem_table_set): Updated.
(ft_mem_debug_panic, ft_mem_debug_alloc, ft_mem_debug_free,
ft_mem_debug_realloc): Use `static' keyword and fix signedness
warnings where necessary.
(ft_mem_table_resize, ft_mem_table_new, ft_mem_table_destroy,
ft_mem_table_get_nodep, ft_mem_debug_init, FT_DumpMemory): Fix types
and add or remove casts to avoid signedness warnings.
2015-02-15 Werner Lemberg <wl@gnu.org>
[base] Clean up signedness in arithmetic functions.

118
src/base/ftdbgmem.c
Unescape View File

@ -47,7 +47,7 @@
typedef struct FT_MemTableRec_* FT_MemTable;
#define FT_MEM_VAL( addr ) ((FT_PtrDist)(FT_Pointer)( addr ))
#define FT_MEM_VAL( addr ) ( (FT_PtrDist)(FT_Pointer)( addr ) )
/*
* This structure holds statistics for a single allocation/release
@ -76,7 +76,7 @@
/*
* We don't need a resizable array for the memory sources, because
* We don't need a resizable array for the memory sources because
* their number is pretty limited within FreeType.
*/
#define FT_MEM_SOURCE_BUCKETS 128
@ -85,8 +85,8 @@
* 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 large memory footprint during execution.
* 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_
{
@ -111,20 +111,20 @@
*/
typedef struct FT_MemTableRec_
{
FT_ULong size;
FT_ULong nodes;
FT_Long size;
FT_Long nodes;
FT_MemNode* buckets;
FT_ULong alloc_total;
FT_ULong alloc_current;
FT_ULong alloc_max;
FT_ULong alloc_count;
FT_Long alloc_total;
FT_Long alloc_current;
FT_Long alloc_max;
FT_Long alloc_count;
FT_Bool bound_total;
FT_ULong alloc_total_max;
FT_Long alloc_total_max;
FT_Bool bound_count;
FT_ULong alloc_count_max;
FT_Long alloc_count_max;
FT_MemSource sources[FT_MEM_SOURCE_BUCKETS];
@ -142,14 +142,14 @@
#define FT_MEM_SIZE_MIN 7
#define FT_MEM_SIZE_MAX 13845163
#define FT_FILENAME( x ) ((x) ? (x) : "unknown file")
#define FT_FILENAME( x ) ( (x) ? (x) : "unknown file" )
/*
* 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_UInt ft_mem_primes[] =
static const FT_Int ft_mem_primes[] =
{
7,
11,
@ -189,10 +189,10 @@
};
static FT_ULong
ft_mem_closest_prime( FT_ULong num )
static FT_Long
ft_mem_closest_prime( FT_Long num )
{
FT_UInt i;
size_t i;
for ( i = 0;
@ -204,7 +204,7 @@
}
extern void
static void
ft_mem_debug_panic( const char* fmt,
... )
{
@ -254,19 +254,20 @@
static void
ft_mem_table_resize( FT_MemTable table )
{
FT_ULong new_size;
FT_Long new_size;
new_size = ft_mem_closest_prime( table->nodes );
if ( new_size != table->size )
{
FT_MemNode* new_buckets;
FT_ULong i;
FT_Long i;
new_buckets = (FT_MemNode *)
ft_mem_table_alloc( table,
new_size * sizeof ( FT_MemNode ) );
ft_mem_table_alloc(
table,
new_size * (FT_Long)sizeof ( FT_MemNode ) );
if ( new_buckets == NULL )
return;
@ -282,7 +283,7 @@
while ( node )
{
next = node->link;
hash = FT_MEM_VAL( node->address ) % new_size;
hash = FT_MEM_VAL( node->address ) % (FT_PtrDist)new_size;
pnode = new_buckets + hash;
node->link = pnode[0];
@ -325,8 +326,9 @@
table->free = memory->free;
table->buckets = (FT_MemNode *)
memory->alloc( memory,
table->size * sizeof ( FT_MemNode ) );
memory->alloc(
memory,
table->size * (FT_Long)sizeof ( FT_MemNode ) );
if ( table->buckets )
FT_ARRAY_ZERO( table->buckets, table->size );
else
@ -343,9 +345,9 @@
static void
ft_mem_table_destroy( FT_MemTable table )
{
FT_ULong i;
FT_Long leak_count = 0;
FT_ULong leaks = 0;
FT_Long i;
FT_Long leak_count = 0;
FT_Long leaks = 0;
FT_DumpMemory( table->memory );
@ -430,7 +432,7 @@
hash = FT_MEM_VAL( address );
pnode = table->buckets + ( hash % table->size );
pnode = table->buckets + ( hash % (FT_PtrDist)table->size );
for (;;)
{
@ -466,8 +468,8 @@
if ( node == NULL )
break;
if ( node->file_name == _ft_debug_file &&
node->line_no == _ft_debug_lineno )
if ( node->file_name == _ft_debug_file &&
node->line_no == _ft_debug_lineno )
goto Exit;
pnode = &node->link;
@ -485,11 +487,11 @@
node->max_blocks = 0;
node->all_blocks = 0;
node->cur_size = 0;
node->max_size = 0;
node->all_size = 0;
node->cur_size = 0;
node->max_size = 0;
node->all_size = 0;
node->cur_max = 0;
node->cur_max = 0;
node->link = NULL;
node->hash = hash;
@ -503,7 +505,7 @@
static void
ft_mem_table_set( FT_MemTable table,
FT_Byte* address,
FT_ULong size,
FT_Long size,
FT_Long delta )
{
FT_MemNode *pnode, node;
@ -558,7 +560,7 @@
source->max_blocks = source->cur_blocks;
}
if ( size > (FT_ULong)source->cur_max )
if ( size > source->cur_max )
source->cur_max = size;
if ( delta != 0 )
@ -671,7 +673,7 @@
}
extern FT_Pointer
static FT_Pointer
ft_mem_debug_alloc( FT_Memory memory,
FT_Long size )
{
@ -688,14 +690,14 @@
return NULL;
/* return NULL if this allocation would overflow the maximum heap size */
if ( table->bound_total &&
table->alloc_total_max - table->alloc_current > (FT_ULong)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, (FT_ULong)size, 0 );
ft_mem_table_set( table, block, size, 0 );
table->alloc_count++;
}
@ -707,7 +709,7 @@
}
extern void
static void
ft_mem_debug_free( FT_Memory memory,
FT_Pointer block )
{
@ -731,7 +733,7 @@
}
extern FT_Pointer
static FT_Pointer
ft_mem_debug_realloc( FT_Memory memory,
FT_Long cur_size,
FT_Long new_size,
@ -787,21 +789,22 @@
table->alloc_count >= table->alloc_count_max )
return NULL;
delta = (FT_Long)( new_size - cur_size );
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 + (FT_ULong)delta > table->alloc_total_max )
if ( delta > 0 &&
table->bound_total &&
table->alloc_current + delta > table->alloc_total_max )
return NULL;
new_block = (FT_Byte *)ft_mem_table_alloc( table, new_size );
new_block = (FT_Pointer)ft_mem_table_alloc( table, new_size );
if ( new_block == NULL )
return NULL;
ft_mem_table_set( table, (FT_Byte*)new_block, new_size, delta );
ft_memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
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 );
@ -844,7 +847,7 @@
if ( total_max > 0 )
{
table->bound_total = 1;
table->alloc_total_max = (FT_ULong)total_max;
table->alloc_total_max = total_max;
}
}
@ -857,7 +860,7 @@
if ( total_count > 0 )
{
table->bound_count = 1;
table->alloc_count_max = (FT_ULong)total_count;
table->alloc_count_max = total_count;
}
}
@ -896,7 +899,6 @@
}
static int
ft_mem_source_compare( const void* p1,
const void* p2 )
@ -925,7 +927,7 @@
FT_MemSource* bucket = table->sources;
FT_MemSource* limit = bucket + FT_MEM_SOURCE_BUCKETS;
FT_MemSource* sources;
FT_UInt nn, count;
FT_Int nn, count;
const char* fmt;
@ -939,8 +941,9 @@
count++;
}
sources = (FT_MemSource*)ft_mem_table_alloc(
table, sizeof ( *sources ) * count );
sources = (FT_MemSource*)
ft_mem_table_alloc(
table, count * (FT_Long)sizeof ( *sources ) );
count = 0;
for ( bucket = table->sources; bucket < limit; bucket++ )
@ -952,7 +955,10 @@
sources[count++] = source;
}
ft_qsort( sources, count, sizeof ( *sources ), ft_mem_source_compare );
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",

Write Preview
Loading…
Cancel
Save