unsigned MEMDBG_get_line(const void *ptr, const char **err_msg) {
MEMDBG_HDR *p = CLIENT_2_HDR(ptr);
*err_msg = "valid memdbg block";
if (memcmp(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOSTt, 4))
*err_msg = "INVALID memdbg memory (possible underflow), mdbg_line returned may not be correct!";
return (unsigned)p->mdbg_line;
}
void
mem_free_ (
void *client_ptr, /* Block of memory to free */
const char *filename, /* Name of source file making call */
word lineno /* Line number in calling source */
)
{
MEMHDR
*ptr;
if (client_ptr == NULL) /* Do nothing if address is null */
return;
/* Check for valid block */
ptr = CLIENT_2_HDR (client_ptr);
if (ptr-> tag != MEMTAG)
mem_tag_err (ptr, filename, lineno);
# if (defined (MEM_TRACE))
if (filename)
trace ("%s (%d): free=%p", filename, lineno, ptr);
# endif
# if (defined (DEBUG))
memset (client_ptr, 0, ptr-> size);
# endif
/* Invalidate header */
ptr-> tag = MEMUNTAG;
mem_total -= ptr-> size;
mem_free_count += 1;
list_unlink (ptr); /* Remove block from list */
free (ptr);
}
void *
mem_realloc_ (
void *client_ptr, /* Block of memory to reallocate */
size_t size, /* Desired size of memory block */
const char *filename, /* Name of source file making call */
word lineno /* Line number in calling source */
)
{
MEMHDR
*ptr,
*next;
ASSERT (client_ptr);
ASSERT (size > 0);
/* Check that block is valid */
ptr = CLIENT_2_HDR (client_ptr);
if (ptr-> tag != MEMTAG)
mem_tag_err (ptr, filename, lineno);
/* Invalidate header */
ptr-> tag = MEMUNTAG;
mem_total -= ptr-> size;
mem_free_count += 1;
next = ptr-> next; /* Save where we were linked */
list_unlink (ptr); /* and unlink */
/* Reallocate memory block */
ptr = (MEMHDR *) realloc (ptr, RESERVE_SIZE + size);
if (ptr == NULL) /* If nothing free, do a hunt */
{ /* and try again... */
mem_scavenge ();
ptr = (MEMHDR *) realloc (ptr, RESERVE_SIZE + size);
if (ptr == NULL)
return (NULL); /* Really in trouble now! */
}
# if (defined (MEM_TRACE))
if (filename)
trace ("%s (%d): realloc %d bytes ->%p", filename, lineno, size, ptr);
# endif
/* Update header */
ptr-> tag = MEMTAG;
ptr-> size = size;
ptr-> file = filename;
ptr-> line = lineno;
list_reset (ptr); /* Set up block as list */
list_relink_before (ptr, next); /* And link where old block was */
mem_total += size; /* Keep count of space used */
mem_alloc_count += 1; /* and number of allocations */
return (HDR_2_CLIENT (ptr));
}
void *
xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
{
MEMHDR *p;
unsigned long number;
if (!xmlMemInitialized) xmlInitMemory();
if (ptr == NULL)
return(NULL);
TEST_POINT
p = CLIENT_2_HDR(ptr);
number = p->mh_number;
if (p->mh_tag != MEMTAG) {
Mem_Tag_Err(p);
goto error;
}
p->mh_tag = ~MEMTAG;
debugMemSize -= p->mh_size;
#ifdef MEM_LIST
debugmem_list_delete(p);
#endif
p = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
if (!p) {
goto error;
}
if (xmlMemTraceBlockAt == ptr) {
xmlGenericError(xmlGenericErrorContext,
"%p : Realloced(%d -> %d) Ok\n",
xmlMemTraceBlockAt, p->mh_size, size);
xmlMallocBreakpoint();
}
p->mh_tag = MEMTAG;
p->mh_number = number;
p->mh_type = REALLOC_TYPE;
p->mh_size = size;
p->mh_file = file;
p->mh_line = line;
debugMemSize += size;
if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
debugmem_list_add(p);
#endif
TEST_POINT
return(HDR_2_CLIENT(p));
error:
return(NULL);
}
/*
* MEMDBG_free
* Free a memory block, checking a lot of data, which would have been
* set at allocation time.
*/
void MEMDBG_free(const void *ptr, char *file, int line)
{
MEMDBG_HDR *p;
int err=0, i;
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
p = CLIENT_2_HDR(ptr);
if (!memcmp(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOSTt, 4))
mem_sizet -= p->mdbg_size;
else if (!memcmp(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOST, 4))
mem_size -= p->mdbg_size;
else if (memcmp(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOSTt, 4))
err = 1;
else {
for (i = 0; i < 4; ++i)
if (((char*)(p->mdbg_hdr2->mdbg_fpst))[i] != cpMEMFPOST[i]) {
err = 1;
break;
}
}
if (err) {
for (i = 0; i < 4; ++i)
if (((char*)(p->mdbg_hdr1->mdbg_fpst))[i] != cpMEMFPOST[i]) {
err = 2;
break;
}
}
MEMDBG_LIST_delete(p);
for (i = 0; i < 4; ++i) {
((char*)(p->mdbg_hdr2->mdbg_fpst))[i] = cpMEMFPOSTd[i];
((char*)(p->mdbg_hdr1->mdbg_fpst))[i] = cpMEMFPOSTd[i];
}
}
if (err) {
if (err == 2)
mem_fence_post_errd(p, file, line);
else
mem_fence_post_err(p, file, line);
return;
}
#ifndef MEMDBG_EXTRA_CHECKS
free(p);
#else
MEMDBG_FREEDLIST_add(p);
#endif
if ( ((signed long long)mem_size) < 0)
fprintf(stderr, "MEMDBG_free (end) %s:%d mem:"LLd"\n", file, line, (unsigned long long)mem_size);
}
static void
xmlMemContentShow(FILE *fp, MEMHDR *p)
{
int i,j,k,len;
const char *buf;
if (p == NULL) {
fprintf(fp, " NULL");
return;
}
len = p->mh_size;
buf = (const char *) HDR_2_CLIENT(p);
for (i = 0;i < len;i++) {
if (buf[i] == 0) break;
if (!isprint((unsigned char) buf[i])) break;
}
if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
if (len >= 4) {
MEMHDR *q;
void *cur;
for (j = 0;(j < len -3) && (j < 40);j += 4) {
cur = *((void **) &buf[j]);
q = CLIENT_2_HDR(cur);
p = memlist;
k = 0;
while (p != NULL) {
if (p == q) break;
p = p->mh_next;
if (k++ > 100) break;
}
if ((p != NULL) && (p == q)) {
fprintf(fp, " pointer to #%lu at index %d",
p->mh_number, j);
return;
}
}
}
} else if ((i == 0) && (buf[i] == 0)) {
fprintf(fp," null");
} else {
if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
else {
fprintf(fp," [");
for (j = 0;j < i;j++)
fprintf(fp,"%c", buf[j]);
fprintf(fp,"]");
}
}
}
/**
* xmlMemFree:
* @ptr: the memory block pointer
*
* a free() equivalent, with error checking.
*/
void
xmlMemFree(void *ptr)
{
MEMHDR *p;
char *target;
if (ptr == (void *) -1) {
xmlGenericError(xmlGenericErrorContext,
"trying to free pointer from freed area\n");
goto error;
}
if (xmlMemTraceBlockAt == ptr) {
xmlGenericError(xmlGenericErrorContext,
"%p : Freed()\n", xmlMemTraceBlockAt);
xmlMallocBreakpoint();
}
TEST_POINT
target = (char *) ptr;
p = CLIENT_2_HDR(ptr);
if (p->mh_tag != MEMTAG) {
Mem_Tag_Err(p);
goto error;
}
p->mh_tag = ~MEMTAG;
debugMemSize -= p->mh_size;
memset(target, -1, p->mh_size);
#ifdef MEM_LIST
debugmem_list_delete(p);
#endif
free(p);
TEST_POINT
return;
error:
xmlGenericError(xmlGenericErrorContext,
"xmlMemFree(%lX) error\n", (unsigned long) ptr);
xmlMallocBreakpoint();
return;
}
/* MUST be thread safe */
void MEMDBG_tag_mem_from_alloc_tiny(void *ptr) {
MEMDBG_HDR *p;
p = CLIENT_2_HDR(ptr);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
if (p->mdbg_fpst == MEMFPOST) {
p->mdbg_fpst = MEMFPOSTt;
mem_size -= p->mdbg_size;
mem_sizet += p->mdbg_size;
if (mem_sizet > max_mem_sizet)
max_mem_sizet = mem_sizet;
}
}
}
/* MUST be thread safe */
void MEMDBG_tag_mem_from_alloc_tiny(void *ptr) {
MEMDBG_HDR *p;
p = CLIENT_2_HDR(ptr);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
if (!memcmp(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOST, 4)) {
memcpy(p->mdbg_hdr1->mdbg_fpst, cpMEMFPOSTt, 4);
mem_size -= p->mdbg_size;
mem_sizet += p->mdbg_size;
if (mem_sizet > max_mem_sizet)
max_mem_sizet = mem_sizet;
}
}
}
void
mem_check_ (
const void *client_ptr, /* Block of memory to free */
const char *filename, /* Name of source file making call */
word lineno /* Line number in calling source */
)
{
MEMHDR
*ptr;
if (client_ptr == NULL) /* Do nothing if address is null */
return;
/* Check for valid block */
ptr = CLIENT_2_HDR (client_ptr);
if (ptr-> tag != MEMTAG)
mem_tag_err (ptr, filename, lineno);
}
/**
* xmlMemFree:
* @ptr: the memory block pointer
*
* a free() equivalent, with error checking.
*/
void
xmlMemFree(void *ptr)
{
MEMHDR *p;
char *target;
#ifdef DEBUG_MEMORY
size_t size;
#endif
if (ptr == (void *) -1) {
xmlGenericError(xmlGenericErrorContext,
"trying to free pointer from freed area\n");
goto error;
}
if (xmlMemTraceBlockAt == ptr) {
xmlGenericError(xmlGenericErrorContext,
"%p : Freed()\n", xmlMemTraceBlockAt);
xmlMallocBreakpoint();
}
TEST_POINT
target = (char *) ptr;
p = CLIENT_2_HDR(ptr);
if (p->mh_tag != MEMTAG) {
Mem_Tag_Err(p);
goto error;
}
if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
p->mh_tag = ~MEMTAG;
memset(target, -1, p->mh_size);
xmlMutexLock(xmlMemMutex);
debugMemSize -= p->mh_size;
debugMemBlocks--;
#ifdef DEBUG_MEMORY
size = p->mh_size;
#endif
#ifdef MEM_LIST
debugmem_list_delete(p);
#endif
xmlMutexUnlock(xmlMemMutex);
free(p);
TEST_POINT
#ifdef DEBUG_MEMORY
xmlGenericError(xmlGenericErrorContext,
"Freed(%d) Ok\n", size);
#endif
return;
error:
xmlGenericError(xmlGenericErrorContext,
"xmlMemFree(%lX) error\n", (unsigned long) ptr);
xmlMallocBreakpoint();
return;
}
void *
xmlReallocLoc(void *ptr,unsigned int size, const char * file, int line)
{
MEMHDR *p;
unsigned long number;
#ifdef DEBUG_MEMORY
unsigned int oldsize;
#endif
if (ptr == NULL)
return(xmlMallocLoc(size, file, line));
if (!xmlMemInitialized) xmlInitMemory();
TEST_POINT
p = CLIENT_2_HDR(ptr);
number = p->mh_number;
if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
if (p->mh_tag != MEMTAG) {
Mem_Tag_Err(p);
goto error;
}
p->mh_tag = ~MEMTAG;
xmlMutexLock(xmlMemMutex);
debugMemSize -= p->mh_size;
debugMemBlocks--;
#ifdef DEBUG_MEMORY
oldsize = p->mh_size;
#endif
#ifdef MEM_LIST
debugmem_list_delete(p);
#endif
xmlMutexUnlock(xmlMemMutex);
p = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
if (!p) {
goto error;
}
if (xmlMemTraceBlockAt == ptr) {
xmlGenericError(xmlGenericErrorContext,
"%p : Realloced(%ld -> %ld) Ok\n",
xmlMemTraceBlockAt, p->mh_size, size);
xmlMallocBreakpoint();
}
p->mh_tag = MEMTAG;
p->mh_number = number;
p->mh_type = REALLOC_TYPE;
p->mh_size = size;
p->mh_file = file;
p->mh_line = line;
xmlMutexLock(xmlMemMutex);
debugMemSize += size;
debugMemBlocks++;
if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
#ifdef MEM_LIST
debugmem_list_add(p);
#endif
xmlMutexUnlock(xmlMemMutex);
TEST_POINT
#ifdef DEBUG_MEMORY
xmlGenericError(xmlGenericErrorContext,
"Realloced(%d to %d) Ok\n", oldsize, size);
#endif
return(HDR_2_CLIENT(p));
error:
return(NULL);
}
/*
* MEMDBG_realloc
* Reallocate a memory block makes a protected call to realloc(), allocating
* extra data, and adding data to all required structures.
* *** realloc is a NASTY function. The code here has taken a few turns,
* trying to handle all of the nuances of this function, and how we hook it,
* and how we deal with trying to not free data (if in MEMDBG_EXTRA_CHECKS mode)
*/
void *
MEMDBG_realloc(const void *ptr, size_t size, char *file, int line)
{
MEMDBG_HDR *p;
int istiny=0;
int err=0, i;
if ( ((signed long long)mem_size) < 0)
fprintf(stderr, "MEMDBG_realloc(%lld) %s:%d mem:%lld\n", (unsigned long long)size, file, line, (unsigned long long)mem_size);
/* if ptr is null, this function works just like alloc, so simply use alloc */
if (!ptr)
return MEMDBG_alloc(size, file, line);
#ifdef _OPENMP
#pragma omp critical
#endif
{
p = CLIENT_2_HDR(ptr);
if (p->mdbg_fpst == MEMFPOSTt)
istiny = 1;
else if (p->mdbg_fpst != MEMFPOST)
err = 1;
else {
for (i = 0; i < 4; ++i)
if (((char*)(p->mdbg_hdr2->mdbg_fpst))[i] != cpMEMFPOST[i]) {
err = 1;
break;
}
}
if (err) {
if (p->mdbg_fpst == MEMFPOSTd)
err = 2;
else {
for (i = 0; i < 4; ++i)
if (((char*)(p->mdbg_hdr2->mdbg_fpst))[i] != cpMEMFPOSTd[i]) {
break;
}
if (i < 4)
err = 2;
}
}
}
if (err) {
if (err == 2)
mem_fence_post_errd(p, file, line);
else
mem_fence_post_err(p, file, line);
return NULL;
}
/* if size == 0, this function works exactly like free, so just use free */
if (!size) {
/* NOTE, use ptr, and NOT p */
MEMDBG_free(ptr, file, line);
return NULL;
}
p->mdbg_fpst = MEMFPOSTd;
memcpy(p->mdbg_hdr2->mdbg_fpst, cpMEMFPOSTd, 4);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
if (istiny)
mem_sizet -= p->mdbg_size;
else
mem_size -= p->mdbg_size;
MEMDBG_LIST_delete(p);
}
#ifdef MEMDBG_EXTRA_CHECKS
if (size > p->mdbg_size) {
void *p2 = MEMDBG_alloc(size, file, line);
if (p2) {
if (istiny)
MEMDBG_tag_mem_from_alloc_tiny(p);
memcpy(p2, ((char*)p)+RESERVE_SZ, p->mdbg_size);
/* we had to keep the original data 'clean' until now.
* but Now, we can put it on free list (which smashes
* the original memory block
*/
MEMDBG_FREEDLIST_add(p);
return p2;
}
/* We have to undo the MEMDBG_LIST_delete(p); because realloc should
* leave the ORIGINAL buffer alone, if we can not allocate more
* memory. Thus we need to 'leave' the leak alone. This is a leak
* unless the client code frees the original pointer. 'undoing' the
* MEMDBG_LIST_delete(p) keeps our code knowing this is a lost pointer.
*/
p->mdbg_fpst = MEMFPOST;
memcpy(p->mdbg_hdr2, cpMEMFPOST, 4);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
mem_size += p->mdbg_size;
if (mem_size > max_mem_size)
max_mem_size = mem_size;
MEMDBG_LIST_add(p);
}
if (istiny)
MEMDBG_tag_mem_from_alloc_tiny(p);
return NULL;
}
/* NOTE, it is assumed that the memory will NOT be freed, so we simply drop
through, and allow normal realloc to work, and DO NOT try to put anything
onto the FREEDLIST, since it will just be the same block */
#endif
p = (MEMDBG_HDR *) realloc(p, RESERVE_SZ + size + 4);
#ifdef MEMDBG_EXTRA_CHECKS
#ifdef _OPENMP
{
int i = 0;
do {
#pragma omp critical (memdbg_crit)
{
if (!p && freed_mem_size > (RESERVE_SZ + size + 4) && !p && freed_cnt)
i = 1;
}
if (i) {
release_oldest_freed_block();
p = (MEMDBG_HDR*)realloc(CLIENT_2_HDR(ptr), RESERVE_SZ + size + 4);
}
} while (i && !p);
}
#else
/* this is the 'right' block, but hard to do with the restrictions of no branching out that omp critical places on us */
if (!p && freed_mem_size > (RESERVE_SZ + size + 4)) {
while (!p && freed_cnt) {
release_oldest_freed_block();
p = (MEMDBG_HDR*)realloc(CLIENT_2_HDR(ptr), RESERVE_SZ + size + 4);
}
}
#endif
#endif
if (!p)
{
/* We have to undo the MEMDBG_LIST_delete(p); because realloc should
* leave the ORIGINAL buffer alone, if we can not allocate more
* memory. Thus we need to 'leave' the leak alone.
*/
p = CLIENT_2_HDR(ptr); /* we have to get 'original' pointer again */
p->mdbg_fpst = MEMFPOST;
memcpy(p->mdbg_hdr2, cpMEMFPOST, 4);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
mem_size += p->mdbg_size;
if (mem_size > max_mem_size)
max_mem_size = mem_size;
MEMDBG_LIST_add(p);
}
if (istiny)
MEMDBG_tag_mem_from_alloc_tiny(p);
return NULL;
}
p->mdbg_fpst = MEMFPOST;
p->mdbg_size = size;
p->mdbg_file = file;
p->mdbg_line = line;
p->mdbg_hdr2 = (MEMDBG_HDR2*)(((char*)p)+RESERVE_SZ + size);
memcpy(p->mdbg_hdr2, cpMEMFPOST, 4);
#ifdef _OPENMP
#pragma omp critical (memdbg_crit)
#endif
{
p->mdbg_cnt = ++alloc_cnt;
mem_size += size;
if (mem_size > max_mem_size)
max_mem_size = mem_size;
MEMDBG_LIST_add(p);
}
if (istiny)
MEMDBG_tag_mem_from_alloc_tiny(p);
return HDR_2_CLIENT(p);
}
