534 lines
14 KiB
C
534 lines
14 KiB
C
/*
|
|
* $QNXtpLicenseC:
|
|
* Copyright 2007, QNX Software Systems. All Rights Reserved.
|
|
*
|
|
* You must obtain a written license from and pay applicable license fees to QNX
|
|
* Software Systems before you may reproduce, modify or distribute this software,
|
|
* or any work that includes all or part of this software. Free development
|
|
* licenses are available for evaluation and non-commercial purposes. For more
|
|
* information visit http://licensing.qnx.com or email licensing@qnx.com.
|
|
*
|
|
* This file may contain contributions from others. Please review this entire
|
|
* file for other proprietary rights or license notices, as well as the QNX
|
|
* Development Suite License Guide at http://licensing.qnx.com/license-guide/
|
|
* for other information.
|
|
* $
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* (c) Copyright 1990, 1991 Conor P. Cahill (uunet!virtech!cpcahil).
|
|
* You may copy, distribute, and use this software as long as this
|
|
* copyright statement is not removed.
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
#include "malloc-lib.h"
|
|
#include "mallocint.h"
|
|
|
|
/*
|
|
* memccpy - copy memory region up to specified byte or length
|
|
*/
|
|
void *
|
|
memccpy(void *ptr1, const void *ptr2, int ch, size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemccpy( (char *) NULL, line, ptr1, ptr2, ch, len) );
|
|
}
|
|
|
|
void *
|
|
DBmemccpy(const char *file, int line, void *ptr1, const void *ptr2, int ch, size_t len)
|
|
{
|
|
register char * myptr1;
|
|
register const char * myptr2;
|
|
register size_t i;
|
|
void * rtn;
|
|
|
|
|
|
if ((len == 0) && (!malloc_verify_access_level)) {
|
|
return(NULL);
|
|
}
|
|
myptr1 = (char *) ptr1;
|
|
myptr2 = (char *) ptr2;
|
|
|
|
/*
|
|
* I know that the assignment could be done in the following, but
|
|
* I wanted to perform a check before any assignment, so first I
|
|
* determine the length, check the pointers and then do the assignment.
|
|
*/
|
|
for( i=0; (i < len) && (myptr2[i] != ch); i++)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* if we found the character...
|
|
*/
|
|
if( i < len )
|
|
{
|
|
rtn = myptr1+i+1;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
rtn = (char *) 0;
|
|
}
|
|
|
|
/*
|
|
* make sure we have enough room in both ptr1 and ptr2
|
|
*/
|
|
if( !in_malloc() && malloc_verify_access )
|
|
{
|
|
ENTER();
|
|
malloc_check_data("memccpy", file, line, ptr1, i);
|
|
malloc_check_data("memccpy", file, line, ptr2, i);
|
|
LEAVE();
|
|
}
|
|
|
|
while( i-- > 0 )
|
|
{
|
|
*(myptr1++) = *(myptr2++);
|
|
}
|
|
|
|
return( rtn );
|
|
}
|
|
|
|
/*
|
|
* memchr - find a byte in a memory region
|
|
*/
|
|
void *
|
|
memchr(const void *ptr1,register int ch, size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemchr( (char *)NULL, line, ptr1, ch, len) );
|
|
}
|
|
|
|
void *
|
|
DBmemchr(const char *file, int line, const void *ptr1, register int ch, size_t len)
|
|
{
|
|
register const char * myptr1;
|
|
size_t i;
|
|
|
|
if ((len == 0) && (!malloc_verify_access_level)) {
|
|
return(NULL);
|
|
}
|
|
if( !in_malloc() && malloc_verify_access )
|
|
{
|
|
ENTER();
|
|
malloc_check_data("memchr", file, line, ptr1, len);
|
|
LEAVE();
|
|
}
|
|
|
|
myptr1 = (char *) ptr1;
|
|
|
|
for( i=0; (i < len) && (myptr1[i] != (char) ch); i++)
|
|
{
|
|
}
|
|
|
|
if( i < len )
|
|
{
|
|
return( (void *) (myptr1+i) );
|
|
}
|
|
else
|
|
{
|
|
return( (void *) 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* memcpy - copy one memory area to another
|
|
* memmove - copy one memory area to another
|
|
*/
|
|
void *
|
|
memmove(void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemmove( (char *) NULL, line,ptr1, ptr2, len) );
|
|
}
|
|
|
|
void *
|
|
DBmemmove(const char *file, int line, void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
return( DBFmemcpy( "memmove", file, line, ptr1, ptr2, len) );
|
|
}
|
|
|
|
|
|
void *
|
|
memcpy(void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemcpy( (char *) NULL, line, ptr1, ptr2, len) );
|
|
}
|
|
|
|
void *
|
|
DBmemcpy(const char *file, int line, void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
return( DBFmemcpy( "memcpy", file, line ,ptr1, ptr2, len) );
|
|
}
|
|
|
|
void *
|
|
DBFmemcpy(const char *func, const char *file, int line, void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
register char * myptr1;
|
|
register const char * myptr2;
|
|
void * rtn = ptr1;
|
|
|
|
if ((len == 0) && (!malloc_verify_access_level)) {
|
|
return(rtn);
|
|
}
|
|
if( !in_malloc() && malloc_verify_access )
|
|
{
|
|
ENTER();
|
|
malloc_check_data(func, file, line, ptr1, len);
|
|
malloc_check_data(func, file, line, ptr2, len);
|
|
LEAVE();
|
|
}
|
|
|
|
myptr1 = ptr1;
|
|
myptr2 = ptr2;
|
|
|
|
/*
|
|
* while the normal memcpy does not guarrantee that it will
|
|
* handle overlapping memory correctly, we will try...
|
|
*/
|
|
if( myptr1 > myptr2 && myptr1 < (myptr2+len))
|
|
{
|
|
myptr1 += (len-1);
|
|
myptr2 += (len-1);
|
|
while( len-- > 0 )
|
|
{
|
|
*(myptr1--) = *(myptr2--);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while( len-- > 0 )
|
|
{
|
|
*(myptr1++) = *(myptr2++);
|
|
}
|
|
}
|
|
|
|
return(rtn);
|
|
}
|
|
|
|
/*
|
|
* memcmp - compare two memory regions
|
|
*/
|
|
int
|
|
memcmp(const void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemcmp((char *)NULL,line,ptr1,ptr2,len) );
|
|
}
|
|
|
|
int
|
|
DBmemcmp(const char *file, int line, const void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
return( DBFmemcmp("memcmp",file,line,ptr1,ptr2,len) );
|
|
}
|
|
|
|
int
|
|
DBFmemcmp(const char *func, const char *file, int line,
|
|
const void *ptr1, const void *ptr2, register size_t len)
|
|
{
|
|
register const unsigned char * myptr1;
|
|
register const unsigned char * myptr2;
|
|
|
|
if ((len == 0) && (!malloc_verify_access_level)) {
|
|
return(0);
|
|
}
|
|
if( !in_malloc() && malloc_verify_access )
|
|
{
|
|
ENTER();
|
|
malloc_check_data(func,file,line, ptr1, len);
|
|
malloc_check_data(func,file,line, ptr2, len);
|
|
LEAVE();
|
|
}
|
|
|
|
myptr1 = ptr1;
|
|
myptr2 = ptr2;
|
|
|
|
while( len > 0 && (*myptr1 == *myptr2) )
|
|
{
|
|
len--;
|
|
myptr1++;
|
|
myptr2++;
|
|
}
|
|
|
|
/*
|
|
* If stopped by len, return zero
|
|
*/
|
|
if( len == 0 )
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
return( ((*myptr1 - *myptr2) < 0) ? -1 : 1);
|
|
}
|
|
|
|
/*
|
|
* memset - set all bytes of a memory block to a specified value
|
|
*/
|
|
void *
|
|
memset(void *ptr1, register int ch, register size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBmemset((char *)NULL,line,ptr1,ch,len) );
|
|
}
|
|
|
|
void *
|
|
DBmemset(const char *file, int line, void *ptr1, register int ch, register size_t len)
|
|
{
|
|
return( DBFmemset("memset",file,line,ptr1,ch,len) );
|
|
}
|
|
|
|
void *
|
|
DBFmemset(const char *func, const char *file, int line,
|
|
void *ptr1, register int ch, register size_t len)
|
|
{
|
|
register char * myptr1;
|
|
char * rtn = ptr1;
|
|
|
|
if ((len == 0) && (!malloc_verify_access_level)) {
|
|
return(rtn);
|
|
}
|
|
if( !in_malloc() && malloc_verify_access )
|
|
{
|
|
ENTER();
|
|
malloc_check_data(func, file, line, ptr1, len);
|
|
LEAVE();
|
|
}
|
|
|
|
myptr1 = ptr1;
|
|
|
|
while( len-- )
|
|
{
|
|
*(myptr1++) = ch;
|
|
}
|
|
|
|
return(rtn);
|
|
}
|
|
|
|
/*
|
|
* bcopy - copy memory block to another area
|
|
*/
|
|
void
|
|
bcopy(const void *ptr2, void *ptr1, size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
DBbcopy((char *)NULL,line,ptr2,ptr1,len);
|
|
}
|
|
|
|
void *
|
|
DBbcopy(const char *file, int line, const void *ptr2, void *ptr1, size_t len)
|
|
{
|
|
return( DBFmemcpy("bcopy",file,line,ptr1,ptr2,len));
|
|
}
|
|
|
|
/*
|
|
* bzero - clear block of memory to zeros
|
|
*/
|
|
void
|
|
bzero(void *ptr1, size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
DBbzero((char *)NULL,line,ptr1,len);
|
|
}
|
|
|
|
void *
|
|
DBbzero(const char *file, int line, void *ptr1, size_t len)
|
|
{
|
|
return( DBFmemset("bzero",file,line,ptr1,'\0',len) );
|
|
}
|
|
|
|
/*
|
|
* bcmp - compary memory blocks
|
|
*/
|
|
int
|
|
bcmp(const void *ptr2, const void *ptr1, size_t len)
|
|
{
|
|
//int line = (int)__builtin_return_address(0);
|
|
int line;
|
|
__my_builtin_return_address(line, 0);
|
|
return( DBbcmp((char *)NULL,line,ptr2, ptr1, len) );
|
|
}
|
|
|
|
int
|
|
DBbcmp(const char *file, int line, const void *ptr2, const void *ptr1, size_t len)
|
|
{
|
|
return( DBFmemcmp("bcmp",file,line,ptr1,ptr2,len) );
|
|
}
|
|
|
|
/*
|
|
* $Log$
|
|
* Revision 1.8 2005/06/03 01:22:48 adanko
|
|
* Replace existing QNX copyright licence headers with macros as specified by
|
|
* the QNX Coding Standard. This is a change to source files in the head branch
|
|
* only.
|
|
*
|
|
* Note: only comments were changed.
|
|
*
|
|
* PR25328
|
|
*
|
|
* Revision 1.7 2005/03/29 18:22:44 shiv
|
|
* PR24134
|
|
* PR24010
|
|
* PR24008
|
|
* PR24184
|
|
* The malloc lib used to report errors when mem* and str* functions
|
|
* were called (for those that take a length parameter) with
|
|
* a length of zero, if the other arguments are not valid..
|
|
* In general these would not cause errors, since
|
|
* no actual data is moved. But since the errors being reported could
|
|
* be useful, the option to increase the level of verbosity for this
|
|
* has been provided. the environment variable
|
|
* MALLOC_CKACCESS_LEVEL can be used or the mallopt call
|
|
* with the option mallopt(MALLOC_CKACCESS_LEVEL, arg)
|
|
* can be used. By default the level is zero, a non-zero
|
|
* level will turn on strict checking and reporting of errors
|
|
* if the arguments are not valid.
|
|
* Also fixed PR24184 which had an incorrect function name
|
|
* being passed in (strchr instead of strrchr... thanx kirk)
|
|
* Modified Files:
|
|
* mallocint.h dbg/m_init.c dbg/malloc_chk.c dbg/malloc_g.c
|
|
* dbg/mallopt.c dbg/memory.c dbg/string.c
|
|
* public/malloc_g/malloc-lib.h
|
|
*
|
|
* Revision 1.6 2005/01/16 20:38:45 shiv
|
|
* Latest DBG malloc code. Lots of cleanup/optimistions
|
|
* Modified Files:
|
|
* common.mk mallocint.h common/tostring.c dbg/analyze.c
|
|
* dbg/calloc.c dbg/dump.c dbg/free.c dbg/m_init.c
|
|
* dbg/malloc_chk.c dbg/malloc_chn.c dbg/malloc_g.c
|
|
* dbg/malloc_gc.c dbg/mallopt.c dbg/memory.c dbg/mtrace.c
|
|
* dbg/process.c dbg/realloc.c dbg/string.c
|
|
* public/malloc_g/malloc-lib.h public/malloc_g/malloc.h
|
|
* std/calloc.c std/free.c std/m_init.c std/malloc_wrapper.c
|
|
* std/mtrace.c std/realloc.c
|
|
* Added Files:
|
|
* dbg/dl_alloc.c dbg/malloc_control.c dbg/malloc_debug.c
|
|
* dbg/new.cc public/malloc_g/malloc-control.h
|
|
* public/malloc_g/malloc-debug.h
|
|
*
|
|
* Revision 1.5 2004/02/12 15:43:17 shiv
|
|
* Updated copyright/licenses
|
|
* Modified Files:
|
|
* common.mk debug.h malloc-lib.h mallocint.h tostring.h
|
|
* common/tostring.c dbg/analyze.c dbg/calloc.c dbg/context.h
|
|
* dbg/crc.c dbg/dump.c dbg/free.c dbg/m_init.c dbg/m_perror.c
|
|
* dbg/malloc_chk.c dbg/malloc_chn.c dbg/malloc_g.c
|
|
* dbg/malloc_gc.c dbg/mallopt.c dbg/memory.c dbg/mtrace.c
|
|
* dbg/process.c dbg/realloc.c dbg/string.c
|
|
* public/malloc/malloc.h public/malloc_g/malloc-lib.h
|
|
* public/malloc_g/malloc.h public/malloc_g/prototypes.h
|
|
* std/calloc.c std/context.h std/free.c std/m_init.c
|
|
* std/malloc_wrapper.c std/mtrace.c std/realloc.c test/memtest.c
|
|
* test/mtrace.c
|
|
*
|
|
* Revision 1.4 2003/10/22 20:51:04 shiv
|
|
* PR17401: memcmp in debug malloc lib needs to do comparisons
|
|
* using unsigned rather than signed.
|
|
*
|
|
* Revision 1.3 2000/02/14 16:34:27 furr
|
|
* Fixed bzero, bcopy
|
|
*
|
|
* Modified Files:
|
|
* mallocint.h dbg/memory.c public/malloc_g/malloc.h
|
|
* public/malloc_g/prototypes.h
|
|
*
|
|
* Revision 1.2 2000/02/08 19:16:23 furr
|
|
* Fix up guard code problems re. underlying implementation
|
|
* Fixed up problems for Java such as locking on mem functions
|
|
*
|
|
* Modified Files:
|
|
* dbg/free.c dbg/malloc_chk.c dbg/memory.c dbg/realloc.c
|
|
* dbg/string.c
|
|
*
|
|
* Revision 1.1 2000/01/31 19:03:31 bstecher
|
|
* Create libmalloc.so and libmalloc_g.so libraries for everything. See
|
|
* Steve Furr for details.
|
|
*
|
|
* Revision 1.1 2000/01/28 22:32:44 furr
|
|
* libmalloc_g allows consistency checks and bounds checking of heap
|
|
* blocks allocated using malloc.
|
|
* Initial revision
|
|
*
|
|
* Added Files:
|
|
* Makefile analyze.c calloc_g.c crc.c dump.c free.c m_init.c
|
|
* m_perror.c malloc-config.c malloc_chk.c malloc_chn.c
|
|
* malloc_g.c malloc_gc.c mallopt.c memory.c process.c realloc.c
|
|
* string.c tostring.c inc/debug.h inc/mallocint.h inc/tostring.h
|
|
* inc/malloc_g/malloc inc/malloc_g/malloc.h
|
|
* inc/malloc_g/prototypes.h test/memtest.C test/memtest.c
|
|
* x86/Makefile x86/so/Makefile
|
|
*
|
|
* Revision 1.2 1996/08/18 21:01:12 furr
|
|
* print the caller return address on errors
|
|
*
|
|
* Revision 1.1 1996/07/24 18:06:40 furr
|
|
* Initial revision
|
|
*
|
|
* Revision 1.13 1992/01/24 04:49:05 cpcahil
|
|
* changed memccpy to only check number of chars it will copy.
|
|
*
|
|
* Revision 1.12 1991/12/31 21:31:26 cpcahil
|
|
* changes for patch 6. See CHANGES file for more info
|
|
*
|
|
* Revision 1.11 1991/12/02 19:10:13 cpcahil
|
|
* changes for patch release 5
|
|
*
|
|
* Revision 1.10 91/11/25 14:42:03 cpcahil
|
|
* Final changes in preparation for patch 4 release
|
|
*
|
|
* Revision 1.9 91/11/24 00:49:31 cpcahil
|
|
* first cut at patch 4
|
|
*
|
|
* Revision 1.8 91/05/21 18:33:47 cpcahil
|
|
* fixed bug in memccpy() which checked an extra byte if the first character
|
|
* after the specified length matched the search character.
|
|
*
|
|
* Revision 1.7 90/08/29 21:27:58 cpcahil
|
|
* fixed value of check in memccpy when character was not found.
|
|
*
|
|
* Revision 1.6 90/07/16 20:06:26 cpcahil
|
|
* fixed several minor bugs found with Henry Spencer's string/mem tester
|
|
* program.
|
|
*
|
|
*
|
|
* Revision 1.5 90/05/11 15:39:36 cpcahil
|
|
* fixed bug in memccpy().
|
|
*
|
|
* Revision 1.4 90/05/11 00:13:10 cpcahil
|
|
* added copyright statment
|
|
*
|
|
* Revision 1.3 90/02/24 21:50:29 cpcahil
|
|
* lots of lint fixes
|
|
*
|
|
* Revision 1.2 90/02/24 17:29:41 cpcahil
|
|
* changed $Header to $Id so full path wouldnt be included as part of rcs
|
|
* id string
|
|
*
|
|
* Revision 1.1 90/02/22 23:17:43 cpcahil
|
|
* Initial revision
|
|
*
|
|
*/
|