gwmem.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	malloc(n)   do_not_call_malloc_directly
#define	calloc(a, b)   do_not_use_calloc
#define	realloc(p, n)   do_not_call_realloc_directly
#define	free(p)   do_not_call_free_directly
Functions
void *	gw_native_noop (void *ptr)
void	gw_native_init (void)
void	gw_native_check_leaks (void)
void *	gw_native_malloc (size_t size)
void *	gw_native_realloc (void *ptr, size_t size)
void	gw_native_free (void *ptr)
char *	gw_native_strdup (const char *str)
void	gw_native_shutdown (void)
void	gw_check_init_mem (int slow_flag)
void	gw_check_check_leaks (void)
void *	gw_check_malloc (size_t size, const char *filename, long line, const char *function)
void *	gw_check_realloc (void *p, size_t size, const char *filename, long line, const char *function)
void	gw_check_free (void *p, const char *filename, long line, const char *function)
char *	gw_check_strdup (const char *str, const char *filename, long line, const char *function)
int	gw_check_is_allocated (void *p)
long	gw_check_area_size (void *p)
void *	gw_check_claim_area (void *p, const char *filename, long line, const char *function)
void	gw_check_shutdown (void)

---

Define Documentation

#define calloc (  a, b   )     do_not_use_calloc

Definition at line 179 of file gwmem.h. Referenced by ws_calloc().

#define free (  p   )     do_not_call_free_directly

Definition at line 181 of file gwmem.h. Referenced by build_box_arglist(), clear_extparms(), drop_from_free_ring(), dump_area(), DumpNode(), Free(), FreeNode(), gw_native_free(), main(), parse_headers(), Read_termstr(), Read_termstr_rtn(), ws_free(), and ws_realloc().

#define malloc (  n   )     do_not_call_malloc_directly

Definition at line 178 of file gwmem.h. Referenced by AddAttrStartLiteralNode(), AddAttrStartNode(), AddAttrValueNode(), AddCodepageLiteralTagNode(), AddCodepageTagNode(), AddDTDNode(), AddStringTableNode(), build_box_arglist(), gw_check_malloc(), gw_check_realloc(), gw_native_malloc(), main(), new_extparm(), NewNode(), parse_headers(), Read_bytes(), Read_termstr_rtn(), ReadBinary(), ws_malloc(), ws_realloc(), and xmalloc().

#define realloc (  p, n   )     do_not_call_realloc_directly

Definition at line 180 of file gwmem.h. Referenced by CodepageAttrvalueName(), DumpNode(), gw_native_realloc(), Read_termstr_rtn(), ReadBinary(), and ws_realloc().

---

Function Documentation

long gw_check_area_size (  void *  p  )

Definition at line 696 of file gwmem-check.c. References area::area_size, find_area(), lock, size, unlock, and warning(). { struct area *area; size_t size; lock(); area = find_area(p); if (!area) { unlock(); warning(0, "Area_size called on non-allocated area %p", p); return -1; } size = area->area_size; unlock(); return size; }

Here is the call graph for this function:

void gw_check_check_leaks (  void   )

Definition at line 652 of file gwmem-check.c. References allocated, area::area_size, check_marks(), debug(), drop_from_free_ring(), dump_area(), free_ring_len, gw_assert, highest_num_allocations, highest_total_size, initialized, lock, num_allocations, total_size, and unlock. { long calculated_size; long index; gw_assert(initialized); lock(); for (index = 0; index < free_ring_len; index++) { drop_from_free_ring(index); } free_ring_len = 0; calculated_size = 0; for (index = 0; index < num_allocations; index++) { calculated_size += allocated[index].area_size; } gw_assert(calculated_size == total_size); debug("gwlib.gwmem", 0, "----------------------------------------"); debug("gwlib.gwmem", 0, "Current allocations: %ld areas, %ld bytes", num_allocations, total_size); debug("gwlib.gwmem", 0, "Highest number of allocations: %ld areas", highest_num_allocations); debug("gwlib.gwmem", 0, "Highest memory usage: %ld bytes", highest_total_size); for (index = 0; index < num_allocations; index++) { check_marks(&allocated[index], index); dump_area(&allocated[index]); } unlock(); }

Here is the call graph for this function:

void* gw_check_claim_area (  void *  p, const char *  filename, long  line, const char *  function )

Definition at line 627 of file gwmem-check.c. References area::claimer, location::filename, find_area(), location::function, location::lineno, lock, panic, and unlock. { struct area *area; /* Allow this for the convenience of wrapper macros. */ if (p == NULL) return NULL; lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Claim_area called on non-allocated area"); } area->claimer.filename = filename; area->claimer.lineno = lineno; area->claimer.function = function; unlock(); /* For convenience of calling macros */ return p; }

Here is the call graph for this function:

void gw_check_free (  void *  p, const char *  filename, long  line, const char *  function )

Definition at line 594 of file gwmem-check.c. References find_area(), free_area(), gw_assert, initialized, lock, panic, and unlock. { struct area *area; gw_assert(initialized); if (p == NULL) return; lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Free called on non-allocated area"); } free_area(area); unlock(); }

Here is the call graph for this function:

void gw_check_init_mem (  int  slow_flag  )

Definition at line 500 of file gwmem-check.c. References gwmem_lock, initialized, mutex_init_static, and slow. { mutex_init_static(&gwmem_lock); slow = slow_flag; initialized = 1; }

int gw_check_is_allocated (  void *  p  )

Definition at line 686 of file gwmem-check.c. References find_area(), lock, and unlock. { struct area *area; lock(); area = find_area(p); unlock(); return area != NULL; }

Here is the call graph for this function:

void* gw_check_malloc (  size_t  size, const char *  filename, long  line, const char *  function )

Definition at line 513 of file gwmem-check.c. References filename, fill(), gw_assert, initialized, lock, malloc, MARKER_SIZE, NEW_AREA_PATTERN, panic, record_allocation(), size, and unlock. Referenced by gw_check_realloc(), and gw_check_strdup(). { unsigned char *p; gw_assert(initialized); /* ANSI C89 says malloc(0) is implementation-defined. Avoid it. */ gw_assert(size > 0); p = malloc(size + 2 * MARKER_SIZE); if (p == NULL) panic(errno, "Memory allocation of %ld bytes failed.", (long)size); p += MARKER_SIZE; lock(); fill(p, size, NEW_AREA_PATTERN); record_allocation(p, size, filename, lineno, function); unlock(); return p; }

Here is the call graph for this function:

void* gw_check_realloc (  void *  p, size_t  size, const char *  filename, long  line, const char *  function )

Definition at line 536 of file gwmem-check.c. References area::allocator, area::area_size, change_total_size(), endmark(), location::filename, filename, fill(), find_area(), free_area(), location::function, gw_assert, gw_check_malloc(), initialized, location::lineno, lock, malloc, MARKER_SIZE, area::max_size, NEW_AREA_PATTERN, panic, area::reallocator, record_allocation(), round_pow2(), size, and unlock. { struct area *area; if (p == NULL) return gw_check_malloc(size, filename, lineno, function); gw_assert(initialized); gw_assert(size > 0); lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Realloc called on non-allocated area"); } if (size == area->area_size) { /* No changes */ } else if (size <= area->max_size) { change_total_size(size - area->area_size); area->area_size = size; endmark(p, size); } else if (size > area->max_size) { /* The current block is not large enough for the reallocation. * We will allocate a new block, copy the data over, and free * the old block. We round the size up to a power of two, * to prevent frequent reallocations. */ struct area *new_area; size_t new_size; unsigned char *new_p; new_size = round_pow2(size + 2 * MARKER_SIZE); new_p = malloc(new_size); new_size -= 2 * MARKER_SIZE; new_p += MARKER_SIZE; memcpy(new_p, p, area->area_size); fill(new_p + area->area_size, size - area->area_size, NEW_AREA_PATTERN); new_area = record_allocation(new_p, size, area->allocator.filename, area->allocator.lineno, area->allocator.function); new_area->max_size = new_size; free_area(area); p = new_p; area = new_area; } area->reallocator.filename = filename; area->reallocator.lineno = lineno; area->reallocator.function = function; unlock(); return p; }

Here is the call graph for this function:

void gw_check_shutdown (  void   )

Definition at line 507 of file gwmem-check.c. References gwmem_lock, initialized, and mutex_destroy(). { mutex_destroy(&gwmem_lock); initialized = 0; }

Here is the call graph for this function:

char* gw_check_strdup (  const char *  str, const char *  filename, long  line, const char *  function )

Definition at line 614 of file gwmem-check.c. References filename, gw_assert, gw_check_malloc(), and initialized. { char *copy; gw_assert(initialized); gw_assert(str != NULL); copy = gw_check_malloc(strlen(str) + 1, filename, lineno, function); strcpy(copy, str); return copy; }

Here is the call graph for this function:

void gw_native_check_leaks (  void   )

void gw_native_free (  void *  ptr  )

Definition at line 108 of file gwmem-native.c. References free. { free(ptr); }

void gw_native_init (  void   )

void* gw_native_malloc (  size_t  size  )

Definition at line 79 of file gwmem-native.c. References gw_assert, malloc, panic, and size. Referenced by gw_native_strdup(). { void *ptr; /* ANSI C89 says malloc(0) is implementation-defined. Avoid it. */ gw_assert(size > 0); ptr = malloc(size); if (ptr == NULL) panic(errno, "Memory allocation failed"); return ptr; }

void* gw_native_noop (  void *  ptr  )

Definition at line 77 of file gwmem-native.c. { return ptr; }

void* gw_native_realloc (  void *  ptr, size_t  size )

Definition at line 94 of file gwmem-native.c. References gw_assert, panic, realloc, and size. { void *new_ptr; gw_assert(size > 0); new_ptr = realloc(ptr, size); if (new_ptr == NULL) panic(errno, "Memory re-allocation failed"); return new_ptr; }

void gw_native_shutdown (  void   )

char* gw_native_strdup (  const char *  str  )

Definition at line 114 of file gwmem-native.c. References gw_assert, and gw_native_malloc(). { char *copy; gw_assert(str != NULL); copy = gw_native_malloc(strlen(str) + 1); strcpy(copy, str); return copy; }

Here is the call graph for this function:

See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.