--- a/jdk/src/jdk.hprof.agent/share/native/libhprof/debug_malloc.c Thu Aug 20 11:38:20 2015 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,769 +0,0 @@
-/*
- * Copyright (c) 2004, 2013, Oracle and/or its affiliates. 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.
- *
- * - Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * - Neither the name of Oracle nor the names of its
- * 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.
- */
-
-/*
- * This source code is provided to illustrate the usage of a given feature
- * or technique and has been deliberately simplified. Additional steps
- * required for a production-quality application, such as security checks,
- * input validation and proper error handling, might not be present in
- * this sample code.
- */
-
-
-/* **************************************************************************
- *
- * Set of malloc/realloc/calloc/strdup/free replacement macros that
- * insert some extra words around each allocation for debugging purposes
- * and also attempt to detect invalid uses of the malloc heap through
- * various tricks like inserting clobber words at the head and tail of
- * the user's area, delayed free() calls, and setting the memory to
- * a fixed pattern on allocation and when freed. The allocations also
- * can include warrants so that when an area is clobbered, this
- * package can report where the allocation took place.
- * The macros included are:
- * malloc(size)
- * realloc(ptr,size)
- * calloc(nelem,elsize)
- * strdup(s1)
- * free(ptr)
- * malloc_police() <--- Not a system function
- * The above macros match the standard behavior of the system functions.
- *
- * They should be used through the include file "debug_malloc.h".
- *
- * IMPORTANT: All source files that call any of these macros
- * should include debug_malloc.h. This package will
- * not work if the memory isn't allocated and freed
- * by the macros in debug_malloc.h. The important issue
- * is that any malloc() from debug_malloc.h must be
- * freed by the free() in debug_malloc.h.
- *
- * The macros in debug_malloc.h will override the normal use of
- * malloc, realloc, calloc, strdup, and free with the functions below.
- *
- * These functions include:
- * void *debug_malloc(size_t, void*, int);
- * void *debug_realloc(void*, size_t, void*, int);
- * void *debug_calloc(size_t, size_t, void*, int);
- * void debug_free(void *, void*, int);
- *
- * In addition the function debug_malloc_police() can be called to
- * tell you what memory has not been freed.
- * void debug_malloc_police(void*, int);
- * The function debug_malloc_police() is available through the macro
- * malloc_police(). Normally you would want to call this at exit()
- * time to find out what memory is still allocated.
- *
- * The variable malloc_watch determines if the warrants are generated.
- * warrants are structures that include the filename and line number
- * of the caller who allocated the memory. This structure is stored
- * at the tail of the malloc space, which is allocated large enough
- * to hold some clobber words at the head and tail, the user's request
- * and the warrant record (if malloc_watch is non-zero).
- *
- * The macro LEFT_OVER_CHAR is what the trailing bytes of an allocation
- * are set to (when the allocation is not a multiple of 8) on allocation.
- * At free(0 time, these bytes are double checked to make sure they were
- * not clobbered. To remove this feature #undef LEFT_OVER_CHAR.
- *
- * The memory freed will have the FREED_CHAR put into it. To remove this
- * feature #undef FREED_CHAR.
- *
- * The memory allocated (not calloc'd) will have the ALLOC_CHAR put into it
- * at the time of allocation. To remove this feature #undef ALLOC_CHAR.
- *
- * The macro MAX_FREE_DELAY_COUNT controls how many free blocks will
- * be kept around before being freed. This creates a delayed affect
- * so that free space that gets clobbered just might get detected.
- * The free() call will immediately set the user space to the FREED_CHAR,
- * leaving the clobber words and warrant in place (making sure they
- * haven't been clobbered). Then the free() pointer is added to a
- * queue of MAX_FREE_DELAY_COUNT long, and if the queue was full, the
- * oldest free()'d memory is actually freed, getting it's entire
- * memory length set to the FREED_CHAR.
- *
- * WARNING: This can significantly slow down an application, depending
- * on how many allocations are made. Also the additional memory
- * needed for the clobber words and the warrants can be significant
- * again, depending on how many allocations are made.
- * In addition, the delayed free calls can create situations
- * where you might run out of memory prematurely.
- *
- * **************************************************************************
- */
-
-#ifdef DEBUG
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include "hprof.h"
-
-/* ***************************************************************************
- * Space normally looks like (clobber Word is 64 bits and aligned to 8 bytes):
- *
- * -----------------
- * malloc/free get->| clobber Word | ---> contains -size requested by user
- * -----------------
- * User gets --->| user space |
- * | |
- * | | left_over | ---> left_over bytes will be <= 7
- * -----------------
- * | clobber Word | ---> contains -size requested by user
- * -----------------
- * | Warrant | ---> Optional (malloc_watch!=0)
- * | | Contains filename and line number
- * | | where allocation happened
- * | |
- * -----------------
- ***************************************************************************/
-
-/*
- * Flag that tells debug_malloc/debug_free/debug_realloc to police
- * heap space usage. (This is a dynamic flag that can be turned on/off)
- */
-static int malloc_watch = 1;
-
-/* Character to stuff into freed space */
-#define FREED_CHAR 'F'
-
-/* Character to stuff into allocated space */
-#define ALLOC_CHAR 'A'
-
-/* Character to stuff into left over trailing bytes */
-#define LEFT_OVER_CHAR 'Z'
-
-/* Number of 'free' calls that will be delayed until the end */
-#define MAX_FREE_DELAY_COUNT 1
-#undef MAX_FREE_DELAY_COUNT
-
-/* Maximum name of __FILE_ stored in each malloc'd area */
-#define WARRANT_NAME_MAX (32-1) /* 1 less than multiple of 8 is best */
-
-/* Macro to convert a user pointer to the malloc pointer */
-#define user2malloc_(uptr) (((char*)(void*)uptr)-sizeof(Word))
-
-/* Macro to convert a macro pointer to the user pointer */
-#define malloc2user_(mptr) (((char*)(void*)(mptr))+sizeof(Word))
-
-/* Size of the warrant record (this is dynamic) */
-#define warrant_space ( malloc_watch?sizeof(Warrant_Record):0 )
-
-/* Macro to round up a number of bytes to a multiple of sizeof(Word) bytes */
-#define round_up_(n) \
- ((n)==0?0:(sizeof(Word)+(((n)-1)/sizeof(Word))*sizeof(Word)))
-
-/* Macro to calculate the needed malloc bytes from the user's request. */
-#define rbytes_(nbytes) \
- (size_t)( sizeof(Word) + round_up_(nbytes) + sizeof(Word) + warrant_space )
-
-/* Macro to get the -size stored in space through the malloc pointer */
-#define nsize1_(mptr) (((Word*)(void*)(mptr))->nsize1)
-#define nsize2_(mptr) (((Word*)(void*)(mptr))->nsize2)
-
-/* Macro to get the -size stored in the tail of the space through */
-/* the malloc pointer */
-#define tail_nsize1_(mptr) \
- nsize1_(((char*)(void*)(mptr))+round_up_(-nsize1_(mptr))+sizeof(Word))
-#define tail_nsize2_(mptr) \
- nsize2_(((char*)(void*)(mptr))+round_up_(-nsize1_(mptr))+sizeof(Word))
-
-/* Macro to get the -size stored in space through the user pointer */
-#define user_nsize1_(uptr) nsize1_(user2malloc_(uptr))
-#define user_nsize2_(uptr) nsize2_(user2malloc_(uptr))
-
-/* Macro to get the -size stored in the tail of the space through */
-/* the user pointer */
-#define user_tail_nsize1_(uptr) tail_nsize1_(user2malloc_(uptr))
-#define user_tail_nsize2_(uptr) tail_nsize2_(user2malloc_(uptr))
-
-/* Macro to get the int* of the last 32bit word of user space */
-#define last_user_word_(mptr) \
- ((int*)(((char*)(void*)(mptr))+round_up_(-nsize1_(mptr))))
-
-/* Macros to get at the warrant contents from the malloc pointer */
-#define warrant_(mptr) \
- (*((Warrant_Record*)(void*)(((char*)(void*)(mptr))+round_up_(-nsize1_(mptr))+sizeof(Word)*2)))
-
-/* This struct is allocated after the tail clobber word if malloc_watch */
-/* is true. */
-typedef struct {
- void *link; /* Next mptr in list */
- char name[WARRANT_NAME_MAX + 1]; /* Name of allocator */
- int line; /* Line number where allocated */
- int id; /* Nth allocation */
-} Warrant_Record;
-#define warrant_link_(mptr) warrant_(mptr).link
-#define warrant_name_(mptr) warrant_(mptr).name
-#define warrant_line_(mptr) warrant_(mptr).line
-#define warrant_id_(mptr) warrant_(mptr).id
-#define MFILE(mptr) (malloc_watch?warrant_name_(mptr):"?")
-#define MLINE(mptr) (malloc_watch?warrant_line_(mptr):0)
-#define MID(mptr) (malloc_watch?warrant_id_(mptr):0)
-
-/* This should be one machine word and is also the clobber word struct */
-typedef struct {
- int nsize1;
- int nsize2;
-} Word; /* Largest basic type , sizeof(double)? */
-
-/* The first malloc pointer for the warrants */
-static void *first_warrant_mptr = NULL;
-
-/* Counter of allocations */
-static int id_counter = 0;
-static int largest_size = 0;
-static void * largest_addr = NULL;
-static void * smallest_addr = NULL;
-
-/* Used to isolate what the error is */
-static char *debug_check;
-static void *clobbered_ptr;
-
-/* Minimum macro */
-#define minimum(a,b) ((a)<(b)?(a):(b))
-
-/* Message routine */
-static void
-error_message(const char * format, ...)
-{
- FILE *error_fp = stderr; /* All debug_malloc.c messages */
- va_list ap;
- va_start(ap, format);
- (void)fprintf(error_fp, "debug_malloc: ");
- (void)vfprintf(error_fp, format, ap);
- (void)fprintf(error_fp, "\n");
- (void)fflush(error_fp);
- va_end(ap);
-}
-
-/* This function prints out a memory error for the memory function
- * 'name' which was called in file 'file' at line number 'line'. The malloc
- * pointer with the error is in 'mptr'.
- */
-static void
-memory_error(void *mptr, const char *name, int mid, const char *mfile, int mline, const char *file, int line)
-{
- char nice_words[512];
- char temp[256];
- int len;
- void *mptr_walk;
-
- if (name == NULL)
- name = "UNKNOWN_NAME";
- if (file == NULL)
- file = "UNKNOWN_FILE";
- md_system_error(temp, (int)sizeof(temp));
- (void)strcpy(nice_words, temp);
- if ( debug_check!=NULL ) {
- (void)md_snprintf(nice_words, sizeof(nice_words),
- "%s The %s at %p appears to have been hit.",
- temp, debug_check, clobbered_ptr);
- }
- len = -nsize1_(mptr);
- error_message("Error: "
- "%s The malloc space #%d is at %p [user size=%d(0x%x)],"
- " and was allocated from file \"%s\" at line %d."
- " [The debug function %s() detected this error "
- "in file \"%s\" at line %d.]",
- nice_words, mid, mptr, len, len, mfile, mline,
- name, file, line);
-
- /* Print out contents of this allocation */
- {
- int i;
- void *uptr = malloc2user_(mptr);
- char *pmess;
- pmess = temp;
- for(i=0;i<(int)sizeof(temp);i++) {
- int ch = ((unsigned char*)uptr)[i];
- if ( isprint(ch) ) {
- *pmess++ = ch;
- } else {
- *pmess++ = '\\';
- *pmess++ = 'x';
- (void)sprintf(pmess,"%02x",ch);
- pmess+=2;
- }
- }
- *pmess = 0;
- error_message("Error: %p contains user data: %s", uptr, temp);
- }
-
- /* Try and print out table */
- if (!malloc_watch) {
- return;
- }
- mptr_walk = first_warrant_mptr;
- if (mptr_walk != NULL) {
- error_message("Active allocations: "
- "count=%d, largest_size=%d, address range (%p,%p)",
- id_counter, largest_size, smallest_addr, largest_addr);
- do {
- int size1;
- int size2;
- char *mfile_walk;
-
- if ( mptr_walk > largest_addr || mptr_walk < smallest_addr ) {
- error_message("Terminating list due to pointer corruption");
- break;
- }
- size1 = -nsize1_(mptr_walk);
- size2 = -nsize2_(mptr_walk);
- mfile_walk = MFILE(mptr_walk);
- error_message("#%d: addr=%p size1=%d size2=%d file=\"%.*s\" line=%d",
- MID(mptr_walk), mptr_walk, size1, size2,
- WARRANT_NAME_MAX, mfile_walk, MLINE(mptr_walk));
- if ( size1 != size2 || size1 > largest_size || size1 < 0 ) {
- error_message("Terminating list due to size corruption");
- break;
- }
- mptr_walk = warrant_link_(mptr_walk);
- } while (mptr_walk != NULL);
- }
- abort();
-}
-
-/* This function sets the clobber word and sets up the warrant for the input
- * malloc pointer "mptr".
- */
-static void
-setup_space_and_issue_warrant(void *mptr, size_t size, const char *file, int line)
-{
- register int nbytes;
-
- /*LINTED*/
- nbytes = (int)size;
- if ( nbytes > largest_size || largest_addr == NULL ) largest_size = nbytes;
- /*LINTED*/
- if ( mptr > largest_addr ) largest_addr = mptr;
- /*LINTED*/
- if ( mptr < smallest_addr || smallest_addr == NULL ) smallest_addr = mptr;
-
- /* Must be done first: */
- nsize1_(mptr) = -nbytes;
- nsize2_(mptr) = -nbytes;
- tail_nsize1_(mptr) = -nbytes;
- tail_nsize2_(mptr) = -nbytes;
-
-#ifdef LEFT_OVER_CHAR
- /* Fill in those few extra bytes just before the tail Word structure */
- {
- register int trailing_extra_bytes;
- /* LINTED */
- trailing_extra_bytes = (int) (round_up_(nbytes) - nbytes);
- if ( trailing_extra_bytes > 0 ) {
- register char *p;
- register int i;
- p = ((char *) mptr) + sizeof(Word) + nbytes;
- for (i = 0; i < trailing_extra_bytes; i++)
- p[i] = LEFT_OVER_CHAR;
- }
- }
-#endif
-
- /* Fill out warrant */
- if (malloc_watch) {
- static Warrant_Record zero_warrant;
- register void *p1,
- *p2;
- size_t len;
- int start_pos = 0;
- warrant_(mptr) = zero_warrant;
- p1 = warrant_name_(mptr);
- len = strlen(file);
- if ( len > WARRANT_NAME_MAX ) {
- /*LINTED*/
- start_pos = (int)len - WARRANT_NAME_MAX;
- }
- p2 = ((char*)file) + start_pos;
- /*LINTED*/
- (void) memcpy(p1, p2, minimum(((int)len), WARRANT_NAME_MAX));
- warrant_line_(mptr) = line;
- warrant_id_(mptr) = ++id_counter;
- warrant_link_(mptr) = first_warrant_mptr;
- first_warrant_mptr = mptr;
- }
-}
-
-/* This function checks the clobber words at the beginning and end of the
- * allocated space.
- */
-static void
-memory_check(void *uptr, int mid, const char *mfile, int mline, const char *file, int line)
-{
- int neg_nbytes;
- int nbytes;
-
- debug_check = "pointer value itself";
- clobbered_ptr = uptr;
- if (uptr == NULL)
- memory_error((void *) NULL, "memory_check", mid, mfile, mline, file, line);
-
- /* Check both Word structures */
-
- debug_check = "first beginning clobber word";
- clobbered_ptr = (char*)&user_nsize1_(uptr);
- neg_nbytes = user_nsize1_(uptr);
- if (neg_nbytes >= 0)
- memory_error(user2malloc_(uptr), "memory_check", mid, mfile, mline, file, line);
-
- debug_check = "second beginning clobber word";
- clobbered_ptr = (char*)&user_nsize2_(uptr);
- if (neg_nbytes != user_nsize2_(uptr))
- memory_error(user2malloc_(uptr), "memory_check", mid, mfile, mline, file, line);
-
- debug_check = "first ending clobber word";
- clobbered_ptr = (char*)&user_tail_nsize1_(uptr);
- if (neg_nbytes != user_tail_nsize1_(uptr))
- memory_error(user2malloc_(uptr), "memory_check", mid, mfile, mline, file, line);
-
- debug_check = "second ending clobber word";
- clobbered_ptr = (char*)&user_tail_nsize2_(uptr);
- if (neg_nbytes != user_tail_nsize2_(uptr))
- memory_error(user2malloc_(uptr), "memory_check", mid, mfile, mline, file, line);
-
- /* Get a positive count of bytes */
- nbytes = -neg_nbytes;
-
-#ifdef LEFT_OVER_CHAR
- {
- /* Check those few extra bytes just before the tail Word structure */
- register int trailing_extra_bytes;
- register int i;
- register char *p;
- /* LINTED */
- trailing_extra_bytes = (int) (round_up_(nbytes) - nbytes);
- p = ((char *) (uptr)) + nbytes;
- debug_check = "trailing left over area";
- for (i = 0; i < trailing_extra_bytes; i++) {
- clobbered_ptr = p+1;
- if (p[i] != LEFT_OVER_CHAR) {
- memory_error(user2malloc_(uptr), "memory_check", mid, mfile, mline, file, line);
- }
- }
- }
-#endif
-
- /* Make sure debug_check is cleared */
- debug_check = NULL;
-}
-
-/* This function looks for the given malloc pointer in the police line up
- * and removes it from the warrant list.
- * mptr The pointer to the malloc space being removed
- */
-static int
-remove_warrant(void *mptr)
-{
- void *mptr1,
- *last_mptr1;
-
- /* Free it up from the list */
- if (malloc_watch && mptr != NULL) {
- int found;
-
- found = 0;
- last_mptr1 = NULL;
- mptr1 = first_warrant_mptr;
- while (mptr1 != NULL) {
- if (mptr1 == mptr) {
- if (last_mptr1 == NULL)
- first_warrant_mptr = warrant_link_(mptr1);
- else
- warrant_link_(last_mptr1) = warrant_link_(mptr1);
- found = 1;
- break;
- }
- last_mptr1 = mptr1;
- mptr1 = warrant_link_(mptr1);
- }
- return found;
- }
- return 1;
-}
-
-static void
-actual_free(void *uptr, const char *file, int line)
-{
- void *mptr;
- const char *mfile;
- int mline;
- int mid;
- if ( uptr == NULL )
- return;
- mptr = user2malloc_(uptr);
- memory_check(uptr, (mid=MID(mptr)), (mfile=MFILE(mptr)), (mline=MLINE(mptr)), file, line);
- if (malloc_watch && remove_warrant(mptr)==0 )
- memory_check(uptr, mid, mfile, mline, file, line);
-#ifdef FREED_CHAR
- if ( mptr!=NULL ) {
- size_t nbytes = -nsize1_(mptr);
- /* LINTED */
- (void)memset(mptr, FREED_CHAR, rbytes_(nbytes));
- }
-#endif
- free(mptr);
-}
-
-#ifdef MAX_FREE_DELAY_COUNT
-
-static void *free_delay[MAX_FREE_DELAY_COUNT];
-static int free_delay_pos = 0;
-
-static void
-delayed_free(void *uptr, const char* file, int line)
-{
- void *mptr;
- void *olduptr = free_delay[free_delay_pos];
- size_t nbytes;
- if ( uptr==NULL )
- return;
- mptr = user2malloc_(uptr);
- memory_check(uptr, MID(mptr), MFILE(mptr), MLINE(mptr), file, line);
- if ( olduptr!=NULL ) {
- actual_free(olduptr, file, line);
- }
- free_delay[free_delay_pos] = uptr;
- free_delay_pos++;
- free_delay_pos = free_delay_pos % MAX_FREE_DELAY_COUNT;
- nbytes = -user_nsize1_(uptr);
-#ifdef FREED_CHAR
- (void)memset(uptr, FREED_CHAR, (size_t)nbytes);
-#endif
-}
-
-static void
-delayed_free_all(const char *file, int line)
-{
- int i;
- for ( i=0; i< MAX_FREE_DELAY_COUNT; i++) {
- void *olduptr = free_delay[i];
- free_delay[i] = NULL;
- if ( olduptr!=NULL ) {
- actual_free(olduptr, file, line);
- }
- }
-}
-
-#endif
-
-void
-debug_free(void *uptr, const char *file, int line)
-{
- int mid = 0;
-
- if (uptr == NULL)
- memory_error((void *) NULL, "debug_free", mid, file, line, file, line);
-#ifdef MAX_FREE_DELAY_COUNT
- delayed_free(uptr, file, line);
-#else
- actual_free(uptr, file, line);
-#endif
-}
-
-/* This function calls malloc(). */
-void *
-debug_malloc(size_t nbytes, const char *file, int line)
-{
- void *mptr;
- void *uptr;
- int mid = id_counter;
-
- /*LINTED*/
- if ((int)nbytes <= 0)
- memory_error((void *) NULL, "debug_malloc", mid, file, line, file, line);
- /* LINTED */
- mptr = malloc(rbytes_(nbytes));
- if (mptr == NULL)
- memory_error((void *) NULL, "debug_malloc", mid, file, line, file, line);
- setup_space_and_issue_warrant(mptr, nbytes, file, line);
- uptr = malloc2user_(mptr);
-#ifdef ALLOC_CHAR
- (void)memset(uptr, ALLOC_CHAR, (size_t)nbytes);
-#endif
- return uptr;
-}
-
-void *
-debug_realloc(void *uptr, size_t nbytes, const char *file, int line)
-{
- void *mptr;
- void *oldmptr;
- void *newuptr;
- size_t oldnbytes;
- int mid = id_counter;
-
- oldmptr = user2malloc_(uptr);
- oldnbytes = 0;
- if ((int)nbytes <= 0)
- memory_error(oldmptr, "debug_realloc", mid, file, line, file, line);
- if (uptr != NULL) {
- memory_check(uptr, MID(oldmptr), MFILE(oldmptr), MLINE(oldmptr), file, line);
- oldnbytes = -user_nsize1_(uptr);
- if ( malloc_watch && remove_warrant(oldmptr)==0 )
- memory_check(uptr, MID(oldmptr), MFILE(oldmptr), MLINE(oldmptr), file, line);
- }
- if (uptr == NULL) {
- /* LINTED */
- mptr = malloc(rbytes_(nbytes));
- } else {
- /* LINTED */
- mptr = realloc(oldmptr, rbytes_(nbytes));
- }
- if (mptr == NULL)
- memory_error(oldmptr, "debug_realloc", mid, file, line, file, line);
- setup_space_and_issue_warrant(mptr, nbytes, file, line);
- newuptr = malloc2user_(mptr);
-#ifdef ALLOC_CHAR
- if (uptr == NULL)
- (void)memset(newuptr, ALLOC_CHAR, (size_t)nbytes);
- else if ( nbytes > oldnbytes )
- (void)memset(((char*)newuptr)+oldnbytes, ALLOC_CHAR, (size_t)nbytes-oldnbytes);
-#endif
- return newuptr;
-}
-
-/* This function calls calloc(). */
-void *
-debug_calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
- void *mptr;
- size_t nbytes;
- int mid = id_counter;
-
- nbytes = nelem*elsize;
- /*LINTED*/
- if ((int)nbytes <= 0)
- memory_error((void *) NULL, "debug_calloc", mid, file, line, file, line);
- /* LINTED */
- mptr = calloc(rbytes_(nbytes),1);
- if (mptr == NULL)
- memory_error((void *) NULL, "debug_calloc", mid, file, line, file, line);
- setup_space_and_issue_warrant(mptr, nbytes, file, line);
- return malloc2user_(mptr);
-}
-
-/* This function replaces strdup(). */
-char *
-debug_strdup(const char *s1, const char *file, int line)
-{
- void *mptr;
- void *uptr;
- size_t nbytes;
- int mid = id_counter;
-
- if (s1 == NULL)
- memory_error((void *) NULL, "debug_strdup", mid, file, line, file, line);
- nbytes = strlen(s1)+1;
- /*LINTED*/
- if ((int)nbytes < 0)
- memory_error((void *) NULL, "debug_strdup", mid, file, line, file, line);
- /* LINTED */
- mptr = malloc(rbytes_(nbytes));
- if (mptr == NULL)
- memory_error((void *) NULL, "debug_strdup", mid, file, line, file, line);
- setup_space_and_issue_warrant(mptr, nbytes, file, line);
- uptr = malloc2user_(mptr);
- (void)strcpy((char*)uptr, s1);
- return (char*)uptr;
-}
-
-void
-debug_malloc_verify(const char *file, int line)
-{
- void *mptr;
-
-#ifdef MAX_FREE_DELAY_COUNT
- delayed_free_all(file,line);
-#endif
-
- if (!malloc_watch) {
- return;
- }
- mptr = first_warrant_mptr;
- if (mptr != NULL) {
- /* Check all this memory first */
- do {
- memory_check(malloc2user_(mptr), MID(mptr), MFILE(mptr), MLINE(mptr), file, line);
- mptr = warrant_link_(mptr);
- } while (mptr != NULL);
- }
-}
-
-/* Report outstanding space warrants to console. */
-void
-debug_malloc_police(const char *file, int line)
-{
- void *mptr;
-
-#ifdef MAX_FREE_DELAY_COUNT
- delayed_free_all(file,line);
-#endif
-
- if (!malloc_watch) {
- return;
- }
-
- mptr = first_warrant_mptr;
- if (mptr != NULL) {
- debug_malloc_verify(file, line);
- /* Now issue warrants */
- mptr = first_warrant_mptr;
- do {
- error_message("Outstanding space warrant: %p (%d bytes) allocated by %s at line %d, allocation #%d",
- mptr, -nsize1_(mptr), warrant_name_(mptr),
- warrant_line_(mptr), warrant_id_(mptr));
-
- mptr = warrant_link_(mptr);
- } while (mptr != NULL);
- }
-}
-
-#else
-
-void
-debug_malloc_verify(const char *file, int line)
-{
- file = file;
- line = line;
-}
-
-void
-debug_malloc_police(const char *file, int line)
-{
- file = file;
- line = line;
-}
-
-#endif