github/amiga-clib2
1
0
Fork 0
mirror of https://github.com/adtools/clib2.git synced 2025-12-08 14:59:05 +00:00
Code Issues Releases Wiki Activity
Files
1550c6fef379aa70095b7b9a2b1718225ec91e39
amiga-clib2/library/stdlib_free.c
Olaf Barthel 1550c6fef3 - When using the wildcard expansion code for command line 
parameters (which is by default linked in with libunix.a),
  regular expressions can no longer prompt dos.library requesters
  to appear. However, to be on the safe side, if you are expecting
  to pass regular expressions on the command line, do not use
  the wildcard expansion code such as by overriding the library
  symbols with dummy functions such as are used in the file
  "stdlib_wildcard_expand.c".

- Added a new variable '__open_locale' which can be used to
  restrict all library functions to use the "C" language locale
  rather than the current system locale settings. In addition
  to that, two new functions __locale_exit() and __locale_init()
  can be used to close and (re-)open the system locale at a
  later time.

- Local ("static") functions are now identified by the STATIC
  qualifier. This was done in preparation for changes that will
  deal with global and local data and the issue of thread safety.


git-svn-id: file:///Users/olsen/Code/migration-svn-zu-git/logical-line-staging/clib2/trunk@14839 87f5fb63-7c3d-0410-a384-fd976d0f7a62
2005-02-25 10:14:22 +00:00

578 lines
12 KiB
C
Raw Blame History

/*
* $Id: stdlib_free.c,v 1.6 2005-02-25 10:14:21 obarthel Exp $
*
* :ts=4
*
* Portable ISO 'C' (1994) runtime library for the Amiga computer
* Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Neither the name of Olaf Barthel nor the names of contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _STDLIB_MEM_DEBUG_H
#include "stdlib_mem_debug.h"
#endif /* _STDLIB_MEM_DEBUG_H */
/****************************************************************************/
#ifndef _STDLIB_HEADERS_H
#include "stdlib_headers.h"
#endif /* _STDLIB_HEADERS_H */
/****************************************************************************/
#undef free
#undef __free
/****************************************************************************/
#ifdef __MEM_DEBUG
/****************************************************************************/
STATIC CHAR
get_hex_char(int n)
{
char result;
if(0 <= n && n <= 9)
result = n + '0';
else
result = n + 'A' - 10;
return(result);
}
STATIC VOID
int_to_hex(unsigned long v,char * buffer,int min_digits)
{
int i,j,c;
i = 0;
do
{
c = (v % 16);
v = v / 16;
buffer[i++] = get_hex_char(c);
}
while(v > 0);
while(i < min_digits)
buffer[i++] = '0';
for(j = 0 ; j < i / 2 ; j++)
{
c = buffer[i - 1 - j];
buffer[i - 1 - j] = buffer[j];
buffer[j] = c;
}
buffer[i] = '\0';
}
STATIC VOID
dump_memory(unsigned char * m,int size,int ignore)
{
const int mod = 20;
int position,i,c;
char buffer[120];
char hex[10];
buffer[0] = '\0';
for(i = 0 ; i < size ; i++)
{
position = i % mod;
if(position == 0)
{
if(buffer[0] != '\0')
{
int len = sizeof(buffer)-1;
while(len > 0 && buffer[len-1] == ' ')
len--;
buffer[len] = '\0';
kprintf("[%s] %s\n",__program_name,buffer);
}
memset(buffer,' ',sizeof(buffer)-1);
int_to_hex((unsigned long)&m[i],hex,8);
memmove(buffer,hex,8);
hex[9] = ':';
}
if(m[i] != ignore)
{
buffer[10 + 2 * position + 0] = get_hex_char(m[i] >> 4);
buffer[10 + 2 * position + 1] = get_hex_char(m[i] & 15);
c = m[i];
if(c < ' ' || (c >= 127 && c <= 160))
c = '.';
buffer[10 + 2 * mod + 1 + position] = c;
}
else
{
buffer[10 + 2 * position + 0] = '_';
buffer[10 + 2 * position + 1] = '_';
}
}
if(buffer[0] != '\0')
{
int len = sizeof(buffer)-1;
while(len > 0 && buffer[len-1] == ' ')
len--;
buffer[len] = '\0';
kprintf("[%s] %s\n",__program_name,buffer);
}
}
/****************************************************************************/
STATIC VOID
check_memory_node(struct MemoryNode * mn,const char * file,int line)
{
size_t size = mn->mn_Size;
unsigned char * head = (unsigned char *)(mn + 1);
unsigned char * body = head + MALLOC_HEAD_SIZE;
unsigned char * tail = body + size;
int max_head_damage = 0;
int max_tail_damage = 0;
int max_body_damage = 0;
int i;
for(i = 1 ; i <= MALLOC_HEAD_SIZE ; i++)
{
if(head[MALLOC_HEAD_SIZE - i] != MALLOC_HEAD_FILL)
max_head_damage = i;
}
if(max_head_damage > 0)
{
kprintf("[%s] ",__program_name);
if(file != NULL)
kprintf("%s:%ld:",file,line);
kprintf("At least %ld bytes were damaged in front of allocation 0x%08lx..0x%08lx, size = %ld",
max_head_damage,
body,body + size - 1,size);
if(mn->mn_File != NULL)
kprintf(", allocated at %s:%ld",mn->mn_File,mn->mn_Line);
kprintf("\n");
dump_memory(head,MALLOC_HEAD_SIZE,MALLOC_HEAD_FILL);
}
for(i = 0 ; i < MALLOC_TAIL_SIZE ; i++)
{
if(tail[i] != MALLOC_TAIL_FILL)
max_tail_damage = i+1;
}
if(max_tail_damage > 0)
{
kprintf("[%s] ",__program_name);
if(file != NULL)
kprintf("%s:%ld:",file,line);
kprintf("At least %ld bytes were damaged behind allocation 0x%08lx..0x%08lx, size = %ld (with damage = %ld)",
max_tail_damage,
body,body + size - 1,
size,size+max_tail_damage);
if(mn->mn_File != NULL)
kprintf(", allocated at %s:%ld",mn->mn_File,mn->mn_Line);
kprintf("\n");
dump_memory(tail,MALLOC_TAIL_SIZE,MALLOC_TAIL_FILL);
}
if(mn->mn_AlreadyFree)
{
for(i = 0 ; i < size ; i++)
{
if(body[i] != MALLOC_FREE_FILL)
max_body_damage = i+1;
}
if(max_body_damage > 0)
{
kprintf("[%s] ",__program_name);
if(file != NULL)
kprintf("%s:%ld:",file,line);
kprintf("At least %ld bytes were damaged in freed allocation 0x%08lx..0x%08lx, size = %ld",
max_body_damage,
body,body + size - 1,size);
if(mn->mn_File != NULL)
kprintf(", allocated at %s:%ld",mn->mn_File,mn->mn_Line);
kprintf("\n");
dump_memory(body,size,MALLOC_FREE_FILL);
}
}
}
/****************************************************************************/
void
__check_memory_allocations(const char * file,int line)
{
struct MemoryNode * mn;
for(mn = (struct MemoryNode *)__memory_list.mlh_Head ;
mn->mn_MinNode.mln_Succ != NULL ;
mn = (struct MemoryNode *)mn->mn_MinNode.mln_Succ)
{
check_memory_node(mn,file,line);
}
}
/****************************************************************************/
struct MemoryNode *
__find_memory_node(void * address)
{
struct MemoryNode * result;
assert( address != NULL );
#if defined(__USE_MEM_TREES)
{
result = __red_black_tree_find(&__memory_tree,address);
}
#else
{
struct MemoryNode * mn;
result = NULL;
for(mn = (struct MemoryNode *)__memory_list.mlh_Head ;
mn->mn_MinNode.mln_Succ != NULL ;
mn = (struct MemoryNode *)mn->mn_MinNode.mln_Succ)
{
if(address == mn->mn_Allocation)
{
result = mn;
break;
}
}
}
#endif /* __USE_MEM_TREES */
return(result);
}
/****************************************************************************/
#else
/****************************************************************************/
struct MemoryNode *
__find_memory_node(void * address)
{
struct MemoryNode * result;
assert( address != NULL );
result = &((struct MemoryNode *)address)[-1];
return(result);
}
/****************************************************************************/
#endif /* __MEM_DEBUG */
/****************************************************************************/
STATIC VOID
remove_and_free_memory_node(struct MemoryNode * mn)
{
size_t allocation_size;
assert( mn != NULL );
Remove((struct Node *)mn);
#if defined(__USE_MEM_TREES) && defined(__MEM_DEBUG)
{
__red_black_tree_remove(&__memory_tree,mn);
}
#endif /* __USE_MEM_TREES && __MEM_DEBUG */
#ifdef __MEM_DEBUG
{
allocation_size = sizeof(*mn) + MALLOC_HEAD_SIZE + mn->mn_Size + MALLOC_TAIL_SIZE;
assert( allocation_size == mn->mn_AllocationSize );
memset(mn,MALLOC_FREE_FILL,allocation_size);
}
#else
{
allocation_size = sizeof(*mn) + mn->mn_Size;
}
#endif /* __MEM_DEBUG */
if(__memory_pool != NULL)
FreePooled(__memory_pool,mn,allocation_size);
else
FreeMem(mn,allocation_size);
}
/****************************************************************************/
void
__free_memory_node(struct MemoryNode * mn,const char * UNUSED file,int UNUSED line)
{
assert(mn != NULL);
#ifdef __MEM_DEBUG
{
size_t size = mn->mn_Size;
check_memory_node(mn,file,line);
if(NOT mn->mn_AlreadyFree)
{
#ifdef __MEM_DEBUG_LOG
{
kprintf("[%s] - %10ld 0x%08lx [",__program_name,mn->mn_Size,mn->mn_Allocation);
if(mn->mn_File != NULL)
kprintf("allocated at %s:%ld, ",mn->mn_File,mn->mn_Line);
kprintf("freed at %s:%ld]\n",file,line);
}
#endif /* __MEM_DEBUG_LOG */
if(__never_free)
{
mn->mn_AlreadyFree = TRUE;
mn->mn_FreeFile = (char *)file;
mn->mn_FreeLine = line;
memset(mn->mn_Allocation,MALLOC_FREE_FILL,size);
}
else
{
__current_memory_allocated -= size;
__current_num_memory_chunks_allocated--;
remove_and_free_memory_node(mn);
}
}
else
{
#ifdef __MEM_DEBUG_LOG
{
kprintf("[%s] - %10ld 0x%08lx [",__program_name,mn->mn_Size,mn->mn_Allocation);
kprintf("FAILED]\n");
}
#endif /* __MEM_DEBUG_LOG */
kprintf("[%s] %s:%ld:Allocation at address 0x%08lx, size %ld",
__program_name,file,line,mn->mn_Allocation,mn->mn_Size);
if(mn->mn_File != NULL)
kprintf(", allocated at %s:%ld",mn->mn_File,mn->mn_Line);
kprintf(", has already been freed at %s:%ld.\n",mn->mn_FreeFile,mn->mn_FreeLine);
}
}
#else
{
remove_and_free_memory_node(mn);
}
#endif /* __MEM_DEBUG */
}
/****************************************************************************/
STATIC VOID
free_memory(void * ptr,BOOL force,const char * file,int line)
{
struct MemoryNode * mn;
assert(ptr != NULL);
/* Try to get rid of now unused memory. */
/*__alloca_cleanup(file,line);*/
#ifdef __MEM_DEBUG
{
/*if((rand() % 16) == 0)
__check_memory_allocations(file,line);*/
}
#endif /* __MEM_DEBUG */
mn = __find_memory_node(ptr);
#ifdef __MEM_DEBUG
{
if(mn != NULL)
{
if(force || (NOT mn->mn_NeverFree))
__free_memory_node(mn,file,line);
}
else
{
#ifdef __MEM_DEBUG_LOG
{
kprintf("[%s] - %10ld 0x%08lx [",__program_name,0,ptr);
kprintf("FAILED]\n");
}
#endif /* __MEM_DEBUG_LOG */
kprintf("[%s] %s:%ld:Address for free(0x%08lx) not known.\n",__program_name,file,line,ptr);
D(("memory allocation at 0x%08lx could not be freed",ptr));
}
}
#else
{
assert( mn != NULL );
if(mn != NULL && (force || (NOT mn->mn_NeverFree)))
__free_memory_node(mn,file,line);
}
#endif /* __MEM_DEBUG */
}
/****************************************************************************/
void
__force_free(void * ptr,const char * file,int line)
{
if(ptr != NULL)
free_memory(ptr,TRUE,file,line);
}
/****************************************************************************/
__static void
__free(void * ptr,const char * file,int line)
{
if(ptr != NULL)
free_memory(ptr,FALSE,file,line);
}
/****************************************************************************/
void
free(void * ptr)
{
__free(ptr,NULL,0);
}
/****************************************************************************/
void
__memory_exit(void)
{
ENTER();
#ifdef __MEM_DEBUG
{
kprintf("[%s] %ld bytes still allocated upon exit, maximum of %ld bytes allocated at a time.\n",
__program_name,__current_memory_allocated,__maximum_memory_allocated);
kprintf("[%s] %ld chunks of memory still allocated upon exit, maximum of %ld chunks allocated at a time.\n",
__program_name,__current_num_memory_chunks_allocated,__maximum_num_memory_chunks_allocated);
__check_memory_allocations(__FILE__,__LINE__);
__never_free = FALSE;
if(__memory_list.mlh_Head != NULL)
{
while(NOT IsListEmpty((struct List *)&__memory_list))
{
((struct MemoryNode *)__memory_list.mlh_Head)->mn_AlreadyFree = FALSE;
__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,__FILE__,__LINE__);
}
}
#if defined(__USE_MEM_TREES)
{
__initialize_red_black_tree(&__memory_tree);
}
#endif /* __USE_MEM_TREES */
}
#endif /* __MEM_DEBUG */
if(__memory_pool != NULL)
{
NewList((struct List *)&__memory_list);
DeletePool(__memory_pool);
__memory_pool = NULL;
}
else
{
if(__memory_list.mlh_Head != NULL)
{
#ifdef __MEM_DEBUG
{
while(NOT IsListEmpty((struct List *)&__memory_list))
__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,__FILE__,__LINE__);
}
#else
{
while(NOT IsListEmpty((struct List *)&__memory_list))
__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,NULL,0);
}
#endif /* __MEM_DEBUG */
}
}
LEAVE();
}
Reference in New Issue View Git Blame Copy Permalink