2 * xmlmemory.c: libxml memory allocator wrapper.
12 #ifdef HAVE_SYS_TYPES_H
13 #include <sys/types.h>
32 /* #define DEBUG_MEMORY */
37 * keep track of all allocated blocks for error reporting
38 * Always build the memory list !
40 #ifdef DEBUG_MEMORY_LOCATION
42 #define MEM_LIST /* keep a list of all the allocated memory blocks */
46 #include <libxml/globals.h> /* must come before xmlmemory.h */
47 #include <libxml/xmlmemory.h>
48 #include <libxml/xmlerror.h>
49 #include <libxml/threads.h>
51 static int xmlMemInitialized = 0;
52 static unsigned long debugMemSize = 0;
53 static unsigned long debugMemBlocks = 0;
54 static unsigned long debugMaxMemSize = 0;
55 static xmlMutexPtr xmlMemMutex = NULL;
57 void xmlMallocBreakpoint(void);
59 /************************************************************************
61 * Macros, variables and associated types *
63 ************************************************************************/
65 #if !defined(LIBXML_THREAD_ENABLED) && !defined(LIBXML_THREAD_ALLOC_ENABLED)
78 * Each of the blocks allocated begin with a header containing informations
84 #define REALLOC_TYPE 2
86 #define MALLOC_ATOMIC_TYPE 4
87 #define REALLOC_ATOMIC_TYPE 5
89 typedef struct memnod {
92 unsigned long mh_number;
95 struct memnod *mh_next;
96 struct memnod *mh_prev;
104 #define ALIGN_SIZE 16
106 #define ALIGN_SIZE sizeof(double)
108 #define HDR_SIZE sizeof(MEMHDR)
109 #define RESERVE_SIZE (((HDR_SIZE + (ALIGN_SIZE-1)) \
110 / ALIGN_SIZE ) * ALIGN_SIZE)
113 #define CLIENT_2_HDR(a) ((MEMHDR *) (((char *) (a)) - RESERVE_SIZE))
114 #define HDR_2_CLIENT(a) ((void *) (((char *) (a)) + RESERVE_SIZE))
117 static unsigned int block=0;
118 static unsigned int xmlMemStopAtBlock = 0;
119 static void *xmlMemTraceBlockAt = NULL;
121 static MEMHDR *memlist = NULL;
124 static void debugmem_tag_error(void *addr);
126 static void debugmem_list_add(MEMHDR *);
127 static void debugmem_list_delete(MEMHDR *);
129 #define Mem_Tag_Err(a) debugmem_tag_error(a);
136 * xmlMallocBreakpoint:
138 * Breakpoint to use in conjunction with xmlMemStopAtBlock. When the block
139 * number reaches the specified value this function is called. One need to add a breakpoint
140 * to it to get the context in which the given block is allocated.
144 xmlMallocBreakpoint(void) {
145 xmlGenericError(xmlGenericErrorContext,
146 "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
151 * @size: an int specifying the size in byte to allocate.
152 * @file: the file name or NULL
153 * @line: the line number
155 * a malloc() equivalent, with logging of the allocation info.
157 * Returns a pointer to the allocated area or NULL in case of lack of memory.
161 xmlMallocLoc(size_t size, const char * file, int line)
166 if (!xmlMemInitialized) xmlInitMemory();
168 xmlGenericError(xmlGenericErrorContext,
169 "Malloc(%d)\n",size);
174 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
177 xmlGenericError(xmlGenericErrorContext,
178 "xmlMallocLoc : Out of free space\n");
184 p->mh_type = MALLOC_TYPE;
187 xmlMutexLock(xmlMemMutex);
188 p->mh_number = ++block;
189 debugMemSize += size;
191 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
193 debugmem_list_add(p);
195 xmlMutexUnlock(xmlMemMutex);
198 xmlGenericError(xmlGenericErrorContext,
199 "Malloc(%d) Ok\n",size);
202 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
204 ret = HDR_2_CLIENT(p);
206 if (xmlMemTraceBlockAt == ret) {
207 xmlGenericError(xmlGenericErrorContext,
208 "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
209 (long unsigned)size);
210 xmlMallocBreakpoint();
219 * xmlMallocAtomicLoc:
220 * @size: an int specifying the size in byte to allocate.
221 * @file: the file name or NULL
222 * @line: the line number
224 * a malloc() equivalent, with logging of the allocation info.
226 * Returns a pointer to the allocated area or NULL in case of lack of memory.
230 xmlMallocAtomicLoc(size_t size, const char * file, int line)
235 if (!xmlMemInitialized) xmlInitMemory();
237 xmlGenericError(xmlGenericErrorContext,
238 "Malloc(%d)\n",size);
243 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
246 xmlGenericError(xmlGenericErrorContext,
247 "xmlMallocLoc : Out of free space\n");
253 p->mh_type = MALLOC_ATOMIC_TYPE;
256 xmlMutexLock(xmlMemMutex);
257 p->mh_number = ++block;
258 debugMemSize += size;
260 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
262 debugmem_list_add(p);
264 xmlMutexUnlock(xmlMemMutex);
267 xmlGenericError(xmlGenericErrorContext,
268 "Malloc(%d) Ok\n",size);
271 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
273 ret = HDR_2_CLIENT(p);
275 if (xmlMemTraceBlockAt == ret) {
276 xmlGenericError(xmlGenericErrorContext,
277 "%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
278 (long unsigned)size);
279 xmlMallocBreakpoint();
288 * @size: an int specifying the size in byte to allocate.
290 * a malloc() equivalent, with logging of the allocation info.
292 * Returns a pointer to the allocated area or NULL in case of lack of memory.
296 xmlMemMalloc(size_t size)
298 return(xmlMallocLoc(size, "none", 0));
303 * @ptr: the initial memory block pointer
304 * @size: an int specifying the size in byte to allocate.
305 * @file: the file name or NULL
306 * @line: the line number
308 * a realloc() equivalent, with logging of the allocation info.
310 * Returns a pointer to the allocated area or NULL in case of lack of memory.
314 xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
317 unsigned long number;
323 return(xmlMallocLoc(size, file, line));
325 if (!xmlMemInitialized) xmlInitMemory();
328 p = CLIENT_2_HDR(ptr);
329 number = p->mh_number;
330 if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
331 if (p->mh_tag != MEMTAG) {
336 xmlMutexLock(xmlMemMutex);
337 debugMemSize -= p->mh_size;
340 oldsize = p->mh_size;
343 debugmem_list_delete(p);
345 xmlMutexUnlock(xmlMemMutex);
347 p = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
351 if (xmlMemTraceBlockAt == ptr) {
352 xmlGenericError(xmlGenericErrorContext,
353 "%p : Realloced(%lu -> %lu) Ok\n",
354 xmlMemTraceBlockAt, (long unsigned)p->mh_size,
355 (long unsigned)size);
356 xmlMallocBreakpoint();
359 p->mh_number = number;
360 p->mh_type = REALLOC_TYPE;
364 xmlMutexLock(xmlMemMutex);
365 debugMemSize += size;
367 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
369 debugmem_list_add(p);
371 xmlMutexUnlock(xmlMemMutex);
376 xmlGenericError(xmlGenericErrorContext,
377 "Realloced(%d to %d) Ok\n", oldsize, size);
379 return(HDR_2_CLIENT(p));
387 * @ptr: the initial memory block pointer
388 * @size: an int specifying the size in byte to allocate.
390 * a realloc() equivalent, with logging of the allocation info.
392 * Returns a pointer to the allocated area or NULL in case of lack of memory.
396 xmlMemRealloc(void *ptr,size_t size) {
397 return(xmlReallocLoc(ptr, size, "none", 0));
402 * @ptr: the memory block pointer
404 * a free() equivalent, with error checking.
407 xmlMemFree(void *ptr)
418 if (ptr == (void *) -1) {
419 xmlGenericError(xmlGenericErrorContext,
420 "trying to free pointer from freed area\n");
424 if (xmlMemTraceBlockAt == ptr) {
425 xmlGenericError(xmlGenericErrorContext,
426 "%p : Freed()\n", xmlMemTraceBlockAt);
427 xmlMallocBreakpoint();
432 target = (char *) ptr;
434 p = CLIENT_2_HDR(ptr);
435 if (p->mh_tag != MEMTAG) {
439 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
441 memset(target, -1, p->mh_size);
442 xmlMutexLock(xmlMemMutex);
443 debugMemSize -= p->mh_size;
449 debugmem_list_delete(p);
451 xmlMutexUnlock(xmlMemMutex);
458 xmlGenericError(xmlGenericErrorContext,
459 "Freed(%d) Ok\n", size);
465 xmlGenericError(xmlGenericErrorContext,
466 "xmlMemFree(%lX) error\n", (unsigned long) ptr);
467 xmlMallocBreakpoint();
473 * @str: the initial string pointer
474 * @file: the file name or NULL
475 * @line: the line number
477 * a strdup() equivalent, with logging of the allocation info.
479 * Returns a pointer to the new string or NULL if allocation error occurred.
483 xmlMemStrdupLoc(const char *str, const char *file, int line)
486 size_t size = strlen(str) + 1;
489 if (!xmlMemInitialized) xmlInitMemory();
492 p = (MEMHDR *) malloc(RESERVE_SIZE+size);
498 p->mh_type = STRDUP_TYPE;
501 xmlMutexLock(xmlMemMutex);
502 p->mh_number = ++block;
503 debugMemSize += size;
505 if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
507 debugmem_list_add(p);
509 xmlMutexUnlock(xmlMemMutex);
511 s = (char *) HDR_2_CLIENT(p);
513 if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
522 if (xmlMemTraceBlockAt == s) {
523 xmlGenericError(xmlGenericErrorContext,
524 "%p : Strdup() Ok\n", xmlMemTraceBlockAt);
525 xmlMallocBreakpoint();
536 * @str: the initial string pointer
538 * a strdup() equivalent, with logging of the allocation info.
540 * Returns a pointer to the new string or NULL if allocation error occurred.
544 xmlMemoryStrdup(const char *str) {
545 return(xmlMemStrdupLoc(str, "none", 0));
551 * Provides the amount of memory currently allocated
553 * Returns an int representing the amount of memory allocated.
558 return(debugMemSize);
564 * Provides the number of memory areas currently allocated
566 * Returns an int representing the number of blocks
571 return(debugMemBlocks);
577 * @fp: a FILE descriptor used as the output file
578 * @p: a memory block header
580 * tries to show some content from the memory block
584 xmlMemContentShow(FILE *fp, MEMHDR *p)
586 int i,j,k,len = p->mh_size;
587 const char *buf = (const char *) HDR_2_CLIENT(p);
590 fprintf(fp, " NULL");
594 for (i = 0;i < len;i++) {
595 if (buf[i] == 0) break;
596 if (!isprint((unsigned char) buf[i])) break;
598 if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
603 for (j = 0;(j < len -3) && (j < 40);j += 4) {
604 cur = *((void **) &buf[j]);
605 q = CLIENT_2_HDR(cur);
611 if (k++ > 100) break;
613 if ((p != NULL) && (p == q)) {
614 fprintf(fp, " pointer to #%lu at index %d",
620 } else if ((i == 0) && (buf[i] == 0)) {
623 if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
626 for (j = 0;j < i;j++)
627 fprintf(fp,"%c", buf[j]);
636 * @fp: a FILE descriptor used as the output file, if NULL, the result is
637 * written to the file .memorylist
638 * @nbBytes: the amount of memory to dump
640 * the last nbBytes of memory allocated and not freed, useful for dumping
641 * the memory left allocated between two places at runtime.
645 xmlMemDisplayLast(FILE *fp, long nbBytes)
658 fp = fopen(".memorylist", "w");
664 fprintf(fp," Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
665 nbBytes, debugMemSize, debugMaxMemSize);
666 fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
668 xmlMutexLock(xmlMemMutex);
670 while ((p) && (nbBytes > 0)) {
671 fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
672 (unsigned long)p->mh_size);
673 switch (p->mh_type) {
674 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
675 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
676 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
677 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
678 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
680 fprintf(fp,"Unknown memory block, may be corrupted");
681 xmlMutexUnlock(xmlMemMutex);
686 if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
687 if (p->mh_tag != MEMTAG)
688 fprintf(fp," INVALID");
691 xmlMemContentShow(fp, p);
696 nbBytes -= (unsigned long)p->mh_size;
699 xmlMutexUnlock(xmlMemMutex);
701 fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
709 * @fp: a FILE descriptor used as the output file, if NULL, the result is
710 * written to the file .memorylist
712 * show in-extenso the memory blocks allocated
716 xmlMemDisplay(FILE *fp)
722 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
731 fp = fopen(".memorylist", "w");
737 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
738 currentTime = time(NULL);
739 tstruct = localtime(¤tTime);
740 strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
741 fprintf(fp," %s\n\n", buf);
745 fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
746 debugMemSize, debugMaxMemSize);
747 fprintf(fp,"BLOCK NUMBER SIZE TYPE\n");
749 xmlMutexLock(xmlMemMutex);
752 fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number,
753 (unsigned long)p->mh_size);
754 switch (p->mh_type) {
755 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
756 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
757 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
758 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
759 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
761 fprintf(fp,"Unknown memory block, may be corrupted");
762 xmlMutexUnlock(xmlMemMutex);
767 if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
768 if (p->mh_tag != MEMTAG)
769 fprintf(fp," INVALID");
772 xmlMemContentShow(fp, p);
779 xmlMutexUnlock(xmlMemMutex);
781 fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
789 static void debugmem_list_add(MEMHDR *p)
791 p->mh_next = memlist;
793 if (memlist) memlist->mh_prev = p;
795 #ifdef MEM_LIST_DEBUG
801 static void debugmem_list_delete(MEMHDR *p)
804 p->mh_next->mh_prev = p->mh_prev;
806 p->mh_prev->mh_next = p->mh_next;
807 else memlist = p->mh_next;
808 #ifdef MEM_LIST_DEBUG
817 * debugmem_tag_error:
819 * internal error function.
822 static void debugmem_tag_error(void *p)
824 xmlGenericError(xmlGenericErrorContext,
825 "Memory tag error occurs :%p \n\t bye\n", p);
828 xmlMemDisplay(stderr);
833 static FILE *xmlMemoryDumpFile = NULL;
838 * @fp: a FILE descriptor used as the output file
839 * @nr: number of entries to dump
841 * show a show display of the memory allocated, and dump
842 * the @nr last allocated areas which were not freed
846 xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
853 fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n",
854 debugMemSize, debugMaxMemSize);
856 xmlMutexLock(xmlMemMutex);
858 fprintf(fp,"NUMBER SIZE TYPE WHERE\n");
860 while ((p) && nr > 0) {
861 fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
862 switch (p->mh_type) {
863 case STRDUP_TYPE:fprintf(fp,"strdup() in ");break;
864 case MALLOC_TYPE:fprintf(fp,"malloc() in ");break;
865 case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break;
866 case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
867 case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
868 default:fprintf(fp," ??? in ");break;
870 if (p->mh_file != NULL)
871 fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
872 if (p->mh_tag != MEMTAG)
873 fprintf(fp," INVALID");
874 xmlMemContentShow(fp, p);
880 xmlMutexUnlock(xmlMemMutex);
881 #endif /* MEM_LIST */
887 * Dump in-extenso the memory blocks allocated to the file .memorylist
896 if (debugMaxMemSize == 0)
898 dump = fopen(".memdump", "w");
900 xmlMemoryDumpFile = stderr;
901 else xmlMemoryDumpFile = dump;
903 xmlMemDisplay(xmlMemoryDumpFile);
905 if (dump != NULL) fclose(dump);
906 #endif /* MEM_LIST */
910 /****************************************************************
912 * Initialization Routines *
914 ****************************************************************/
919 * Initialize the memory layer.
921 * Returns 0 on success
930 xmlGenericError(xmlGenericErrorContext,
931 "xmlInitMemory()\n");
934 This is really not good code (see Bug 130419). Suggestions for
935 improvement will be welcome!
937 if (xmlMemInitialized) return(-1);
938 xmlMemInitialized = 1;
939 xmlMemMutex = xmlNewMutex();
942 breakpoint = getenv("XML_MEM_BREAKPOINT");
943 if (breakpoint != NULL) {
944 sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
948 breakpoint = getenv("XML_MEM_TRACE");
949 if (breakpoint != NULL) {
950 sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
955 xmlGenericError(xmlGenericErrorContext,
956 "xmlInitMemory() Ok\n");
964 * Free up all the memory allocated by the library for its own
965 * use. This should not be called by user level code.
968 xmlCleanupMemory(void) {
970 xmlGenericError(xmlGenericErrorContext,
971 "xmlCleanupMemory()\n");
973 if (xmlMemInitialized == 0)
976 xmlFreeMutex(xmlMemMutex);
978 xmlMemInitialized = 0;
980 xmlGenericError(xmlGenericErrorContext,
981 "xmlCleanupMemory() Ok\n");
987 * @freeFunc: the free() function to use
988 * @mallocFunc: the malloc() function to use
989 * @reallocFunc: the realloc() function to use
990 * @strdupFunc: the strdup() function to use
992 * Override the default memory access functions with a new set
993 * This has to be called before any other libxml routines !
995 * Should this be blocked if there was already some allocations
998 * Returns 0 on success
1001 xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1002 xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
1004 xmlGenericError(xmlGenericErrorContext,
1007 if (freeFunc == NULL)
1009 if (mallocFunc == NULL)
1011 if (reallocFunc == NULL)
1013 if (strdupFunc == NULL)
1016 xmlMalloc = mallocFunc;
1017 xmlMallocAtomic = mallocFunc;
1018 xmlRealloc = reallocFunc;
1019 xmlMemStrdup = strdupFunc;
1021 xmlGenericError(xmlGenericErrorContext,
1022 "xmlMemSetup() Ok\n");
1029 * @freeFunc: place to save the free() function in use
1030 * @mallocFunc: place to save the malloc() function in use
1031 * @reallocFunc: place to save the realloc() function in use
1032 * @strdupFunc: place to save the strdup() function in use
1034 * Provides the memory access functions set currently in use
1036 * Returns 0 on success
1039 xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1040 xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
1041 if (freeFunc != NULL) *freeFunc = xmlFree;
1042 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1043 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1044 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1050 * @freeFunc: the free() function to use
1051 * @mallocFunc: the malloc() function to use
1052 * @mallocAtomicFunc: the malloc() function to use for atomic allocations
1053 * @reallocFunc: the realloc() function to use
1054 * @strdupFunc: the strdup() function to use
1056 * Override the default memory access functions with a new set
1057 * This has to be called before any other libxml routines !
1058 * The mallocAtomicFunc is specialized for atomic block
1059 * allocations (i.e. of areas useful for garbage collected memory allocators
1061 * Should this be blocked if there was already some allocations
1064 * Returns 0 on success
1067 xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1068 xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1069 xmlStrdupFunc strdupFunc) {
1071 xmlGenericError(xmlGenericErrorContext,
1072 "xmlGcMemSetup()\n");
1074 if (freeFunc == NULL)
1076 if (mallocFunc == NULL)
1078 if (mallocAtomicFunc == NULL)
1080 if (reallocFunc == NULL)
1082 if (strdupFunc == NULL)
1085 xmlMalloc = mallocFunc;
1086 xmlMallocAtomic = mallocAtomicFunc;
1087 xmlRealloc = reallocFunc;
1088 xmlMemStrdup = strdupFunc;
1090 xmlGenericError(xmlGenericErrorContext,
1091 "xmlGcMemSetup() Ok\n");
1098 * @freeFunc: place to save the free() function in use
1099 * @mallocFunc: place to save the malloc() function in use
1100 * @mallocAtomicFunc: place to save the atomic malloc() function in use
1101 * @reallocFunc: place to save the realloc() function in use
1102 * @strdupFunc: place to save the strdup() function in use
1104 * Provides the memory access functions set currently in use
1105 * The mallocAtomicFunc is specialized for atomic block
1106 * allocations (i.e. of areas useful for garbage collected memory allocators
1108 * Returns 0 on success
1111 xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1112 xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
1113 xmlStrdupFunc *strdupFunc) {
1114 if (freeFunc != NULL) *freeFunc = xmlFree;
1115 if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1116 if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1117 if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1118 if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1122 #define bottom_xmlmemory
1123 #include "elfgcchack.h"