root/1.8.3/trunk/src/csrimalloc.c

/*  Author: Mark Moraes <moraes@csri.toronto.edu> */

#include "config.h"
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#ifdef I_FCNTL
#include <fcntl.h>
#endif
#ifdef I_SYS_FILE
#include <sys/file.h>
#endif
#ifdef I_SYS_MMAN
#include <sys/mman.h>
#endif
#ifdef I_SYS_STAT
#include <sys/stat.h>
#endif
#ifdef I_SYS_TYPES
#include <sys/types.h>
#endif
#include "conf.h"
#include "externs.h"
#include "mymalloc.h"
#include "csrimalloc.h"         /* Must be after mymalloc.h! */

#ifdef CSRI_TRACE
#undef malloc(x)
#undef calloc(x, n)
#undef realloc(p, x)
#undef memalign(x, n)
#undef valloc(x)
#undef emalloc(x)
#undef ecalloc(x, n)
#undef erealloc(p, x)
#undef strdup(p)
#undef strsave(p)
#undef cfree(p)
#undef free(p)
extern char *strdup(const char *);
#endif


/*  Author: Mark Moraes <moraes@csri.toronto.edu> */
/*  Modified by Javelin to replace references to _mal_statsfile
 *  with stderr, to make glibc happy.
 */
#ifndef __DEFS_H__
#define __DEFS_H__
/* 
 *  This file includes all relevant include files, and defines various
 *  types and constants. It also defines lots of macros which operate on
 *  the malloc blocks and pointers, to try and keep the ugliness
 *  abstracted away from the source code.
 */

#include <errno.h>

#ifndef REGISTER
#ifdef __GNUC__
   /* gcc probably does better register allocation than I do */
#define REGISTER
#else
#define REGISTER register
#endif
#endif

#if defined(__STDC__)
#define proto(x)        x
#else
#define proto(x)        ()
#define const
#define volatile
#endif

#ifndef EXTERNS_H__
#define EXTERNS_H__

/* Lots of ugliness as we cope with non-standardness */

/* 
 *  Malloc definitions from General Utilities <stdlib.h>. Note that we
 *  disagree with Berkeley Unix on the return type of free/cfree.
 */
extern univptr_t malloc proto((size_t));
extern univptr_t calloc proto((size_t, size_t));
extern univptr_t realloc proto((univptr_t, size_t));
extern Free_t free proto((univptr_t));

/* General Utilities <stdlib.h> */

extern void abort proto((void));
extern void exit proto((int));
extern char *getenv proto((const char *));

/*
 *  Input/Output <stdio.h> Note we disagree with Berkeley Unix on
 *  sprintf().
 */

#if 0                           /* can't win with this one */
extern int sprintf proto((char *, const char *, ...));
#endif

extern int fputs proto((const char *, FILE *));
extern int fflush proto((FILE *));
#if 0
extern int setvbuf proto((FILE *, char *, int, memsize_t));
#endif


/* Character Handling: <string.h> */

#if 0
/* We'd better not have to do this - Javelin */

#ifndef HAS_MEMSET
extern univptr_t memset proto((univptr_t, int, memsize_t));
#endif

#ifndef HAS_MEMCPY
extern univptr_t memcpy proto((univptr_t, const univptr_t, memsize_t));
#endif

extern char *strcpy proto((char *, const char *));
extern memsize_t strlen proto((const char *));
#endif

/* UNIX -- unistd.h */
extern int write
proto((int /*fd */ , const char * /*buf */ , int /*nbytes */ ));
extern int open proto((const char * /*path */ , int /*flags */ , ...));

#define caddr_t char *
extern caddr_t sbrk proto((int));

#ifdef _AIX                     /* IBM AIX doesn't declare sbrk, but is STDHEADERS. */
extern caddr_t sbrk proto((int));
#endif

/* Backwards compatibility with BSD/Sun -- these are going to vanish one day */
extern univptr_t valloc proto((size_t));
extern univptr_t memalign proto((size_t, size_t));
extern Free_t cfree proto((univptr_t));

/* Malloc definitions - my additions.  Yuk, should use malloc.h properly!!  */
extern univptr_t emalloc proto((size_t));
extern univptr_t ecalloc proto((size_t, size_t));
extern univptr_t erealloc proto((univptr_t, size_t));
extern char *strsave proto((const char *));
#ifdef CSRI_DEBUG
extern void mal_debug proto((int));
extern int mal_verify proto((int));
#endif
extern void mal_dumpleaktrace proto((FILE *));
extern void mal_heapdump proto((FILE *));
extern void mal_leaktrace proto((int));
extern void mal_mmap proto((char *));
extern void mal_sbrkset proto((int));
extern void mal_slopset proto((int));
#ifdef CSRI_PROFILESIZES
extern void mal_statsdump proto((FILE *));
#endif
extern void mal_trace proto((int));

/* Internal definitions */
extern int __nothing proto((void));
extern univptr_t _mal_sbrk proto((size_t));
extern univptr_t _mal_mmap proto((size_t));

#ifdef HAVE_MMAP
extern int madvise proto((caddr_t, size_t, int));
extern caddr_t mmap proto((caddr_t, size_t, int, int, int, off_t));
#endif

#endif  /* EXTERNS_H__ */                        /* Do not add anything after this line */

/* $Id: csrimalloc.c 1.23.1.8 Wed, 26 May 2004 09:52:42 -0500 dunemush $ */
#ifndef __ASSERT_H__
#define __ASSERT_H__
#ifdef CSRI_DEBUG
#define ASSERT(p, s) \
        ((void)(!(p)?__m_botch((s),"",(univptr_t)0,0,__FILE__,__LINE__):0))
#define ASSERT_SP(p, s, s2, sp) \
        ((void)(!(p)?__m_botch((s),(s2),(univptr_t)(sp),0,__FILE__,__LINE__):0))
#define ASSERT_EP(p, s, s2, ep) \
        ((void)(!(p)?__m_botch((s),(s2),(univptr_t)(ep),1,__FILE__,__LINE__):0))

extern int __m_botch
proto((const char *, const char *, univptr_t, int, const char *, int));
#else
#define ASSERT(p, s)
#define ASSERT_SP(p, s, s2, sp)
#define ASSERT_EP(p, s, s2, ep)
#endif
#endif  /* __ASSERT_H__ */                        /* Do not add anything after this line */
#ifndef EXIT_FAILURE
#define EXIT_FAILURE    1
#endif

#ifdef __STDC__
#include <limits.h>
#ifndef BITSPERBYTE
#define BITSPERBYTE     CHAR_BIT
#endif
#else
#include <values.h>
#endif

/* $Id: csrimalloc.c 1.23.1.8 Wed, 26 May 2004 09:52:42 -0500 dunemush $ */
#ifndef __ALIGN_H__
#define __ALIGN_H__
/* 
 * 'union word' must be aligned to the most pessimistic alignment needed
 * on the architecture (See align.h) since all pointers returned by
 * malloc and friends are really pointers to a Word. This is the job of
 * the 'foo' field in the union, which actually decides the size. (On
 * Sun3s, 1 int/long (4 bytes) is good enough, on Sun4s, 8 bytes are
 * necessary, i.e. 2 ints/longs)
 */
/*
 * 'union word' should also be the size necessary to ensure that an
 * sbrk() immediately following an sbrk(sizeof(union word) * n) returns
 * an address one higher than the first sbrk. i.e. contiguous space from
 * successive sbrks. (Most sbrks will do this regardless of the size -
 * Sun's doesnt) This is not vital - the malloc will work, but will not
 * be able to coalesce between sbrk'ed segments.
 */

#if defined(sparc) || defined(__sparc__) || defined(__sgi) || defined(__hpux)
/*
 * Sparcs require doubles to be aligned on double word, SGI R4000 based
 * machines are 64 bit, this is the conservative way out
 */
/* this will waste space on R4000s or the 64bit UltraSparc */
#define ALIGN long foo[2]
#define NALIGN 8
#endif

#if defined(__alpha)
/* 64 bit */
#define ALIGN long foo
#define NALIGN 8
#endif

/* This default seems to work on most 32bit machines */
#ifndef ALIGN
#define ALIGN long foo
#define NALIGN 4
#endif

/* Align with power of 2 */
#define SIMPLEALIGN(X, N) (univptr_t)(((size_t)((char *)(X) + (N-1))) & ~(N-1))

#if     NALIGN == 2 || NALIGN == 4 || NALIGN == 8 || NALIGN == 16
  /* if NALIGN is a power of 2, the next line will do ok */
#define ALIGNPTR(X) SIMPLEALIGN(X, NALIGN)
#else
  /* otherwise we need the generic version; hope the compiler isn't too smart */
static size_t _N = NALIGN;
#define ALIGNPTR(X) (univptr_t)((((size_t)((univptr_t)(X)+(NALIGN-1)))/_N)*_N)
#endif

/*
 * If your sbrk does not return blocks that are aligned to the
 * requirements of malloc(), as specified by ALIGN above, then you need
 * to define SBRKEXTRA so that it gets the extra memory needed to find
 * an alignment point. Not needed on Suns on which sbrk does return
 * properly aligned blocks. But on U*x Vaxen, A/UX and UMIPS at least,
 * you need to do this. It is safer to take the non Sun route (!! since
 * the non-sun part also works on Suns, maybe we should just remove the
 * Sun ifdef)
 */
#if ! (defined(sun) || defined(__sun__))
#define SBRKEXTRA               (sizeof(Word) - 1)
#define SBRKALIGN(x)    ALIGNPTR(x)
#else
#define SBRKEXTRA               0
#define SBRKALIGN(x)    (x)
#endif

#ifndef BITSPERBYTE
  /*
   * These values should work with any binary representation of integers
   * where the high-order bit contains the sign. Should be in values.h,
   * but just in case...
   */
  /* a number used normally for size of a shift */
#if gcos
#define BITSPERBYTE     9
#else                           /* ! gcos */
#define BITSPERBYTE     8
#endif                          /* gcos */
#endif                          /* BITSPERBYTE */

#ifndef BITS
#define BITS(type)      (BITSPERBYTE * (int) sizeof(type))
#endif                          /* BITS */

/* size_t with only the high-order bit turned on */
#define HIBITSZ (((size_t) 1) << (BITS(size_t) - 1))

#endif  /* __ALIGN_H__ */                        /* Do not add anything after this line */

/*
 * We assume that FREE is a 0 bit, and the tag for a free block, Or'ing the
 * tag with ALLOCED should turn on the high bit, And'ing with SIZEMASK
 * should turn it off.
 */

#define FREE            ((size_t) 0)
#define ALLOCED         (HIBITSZ)
#define SIZEMASK        (~HIBITSZ)

#define MAXBINS         8

#define DEF_SBRKUNITS   1024

union word {                    /* basic unit of storage */
  size_t size;                  /* size of this block + 1 bit status */
  union word *next;             /* next free block */
  union word *prev;             /* prev free block */
  univptr_t ptr;                /* stops lint complaining, keeps alignment */
  char c;
  int i;
  char *cp;
  char **cpp;
  int *ip;
  int **ipp;
   ALIGN;                       /* alignment stuff - wild fun */
};

typedef union word Word;

/*
 *  WARNING - Many of these macros are UNSAFE because they have multiple
 *  evaluations of the arguments. Use with care, avoid side-effects.
 */
/*
 * These macros define operations on a pointer to a block. The zero'th
 * word of a block is the size field, where the top bit is 1 if the
 * block is allocated. This word is also referred to as the starting tag.
 * The last word of the block is identical to the zero'th word of the
 * block and is the end tag.  IF the block is free, the second last word
 * is a pointer to the next block in the free list (a doubly linked list
 * of all free blocks in the heap), and the third from last word is a
 * pointer to the previous block in the free list.  HEADERWORDS is the
 * number of words before the pointer in the block that malloc returns,
 * TRAILERWORDS is the number of words after the returned block. Note
 * that the zero'th and the last word MUST be the boundary tags - this
 * is hard-wired into the algorithm. Increasing HEADERWORDS or
 * TRAILERWORDS suitably should be accompanied by additional macros to
 * operate on those words. The routines most likely to be affected are
 * malloc/realloc/free/memalign/mal_verify/mal_heapdump.
 */
/*
 * There are two ways we can refer to a block -- by pointing at the
 * start tag, or by pointing at the end tag. For reasons of efficiency
 * and performance, free blocks are always referred to by the end tag,
 * while allocated blocks are usually referred to by the start tag.
 * Accordingly, the following macros indicate the type of their argument
 * by using either 'p', 'sp', or 'ep' to indicate a pointer. 'p' means
 * the pointer could point at either the start or end tag. 'sp' means it
 * must point at a start tag for that macro to work correctly, 'ep'
 * means it must point at the end tag. Usually, macros operating on free
 * blocks (NEXT, PREV, VALID_PREV_PTR, VALID_NEXT_PTR) take 'ep', while
 * macros operating on allocated blocks (REALSIZE, MAGIC_PTR,
 * SET_REALSIZE) take 'sp'. The size field may be validated using either
 * VALID_START_SIZE_FIELD for an 'sp' or VALID_END_SIZE_FIELD for an
 * 'ep'.
 */
/*
 *  SIZE, SIZEFIELD and TAG are valid for allocated and free blocks,
 *  REALSIZE is valid for allocated blocks when debugging, and NEXT and
 *  PREV are valid for free blocks. We could speed things up by making
 *  the free list singly linked when not debugging - the double link are
 *  just so we can check for pointer validity. (PREV(NEXT(ep)) == ep and
 *  NEXT(PREV(ep)) == ep). FREESIZE is used only to get the size field
 *  from FREE blocks - in this implementation, free blocks have a tag
 *  bit of 0 so no masking is necessary to operate on the SIZEFIELD when
 *  a block is free. We take advantage of that as a minor optimization.
 */
#define SIZEFIELD(p)            ((p)->size)
#define SIZE(p)                 ((size_t) (SIZEFIELD(p) & SIZEMASK))
#define ALLOCMASK(n)            ((n) | ALLOCED)
#define FREESIZE(p)             SIZEFIELD(p)
/*
 *  FREEMASK should be (n) & SIZEMASK, but since (n) will always have
 *  the hi bit off after the conversion from bytes requested by the user
 *  to words.
 */
#define FREEMASK(n)             (n)
#define TAG(p)                  (SIZEFIELD(p) & ~SIZEMASK)

#ifdef CSRI_DEBUG
#define REALSIZE(sp)            (((sp)+1)->size)
#endif                          /* CSRI_DEBUG */

#define NEXT(ep)                (((ep)-1)->next)
#define PREV(ep)                (((ep)-2)->prev)

/*
 *  HEADERWORDS is the real block header in an allocated block - the
 *  free block header uses extra words in the block itself
 */
#ifdef CSRI_DEBUG
#define HEADERWORDS             2       /* Start boundary tag + real size in bytes */
#else                           /* ! CSRI_DEBUG */
#define HEADERWORDS             1       /* Start boundary tag */
#endif                          /* CSRI_DEBUG */

#define TRAILERWORDS            1

#define FREEHEADERWORDS         1       /* Start boundary tag */

#define FREETRAILERWORDS        3       /* next and prev, end boundary tag */

#define ALLOC_OVERHEAD  (HEADERWORDS + TRAILERWORDS)
#define FREE_OVERHEAD   (FREEHEADERWORDS + FREETRAILERWORDS)

/*
 *  The allocator views memory as a list of non-contiguous arenas. (If
 *  successive sbrks() return contiguous blocks, they are colaesced into
 *  one arena - if a program never calls sbrk() other than malloc(),
 *  then there should only be one arena. This malloc will however
 *  happily coexist with other allocators calling sbrk() and uses only
 *  the blocks given to it by sbrk. It expects the same courtesy from
 *  other allocators. The arenas are chained into a linked list using
 *  the first word of each block as a pointer to the next arena. The
 *  second word of the arena, and the last word, contain fake boundary
 *  tags that are permanantly marked allocated, so that no attempt is
 *  made to coalesce past them. See the code in dumpheap for more info.
 */
#define ARENASTART              2       /* next ptr + fake start tag */

#ifdef CSRI_DEBUG
  /* 
   * 1 for prev link in free block - next link is absorbed by header
   * REALSIZE word
   */
#define FIXEDOVERHEAD           (1 + ALLOC_OVERHEAD)
#else                           /* ! CSRI_DEBUG */
  /* 1 for prev link, 1 for next link, + header and trailer */
#define FIXEDOVERHEAD           (2 + ALLOC_OVERHEAD)
#endif                          /* CSRI_DEBUG */

/* 
 * Check that pointer is safe to dereference i.e. actually points
 * somewhere within the heap and is properly aligned.
 */
#define PTR_IN_HEAP(p) \
        ((p) > _malloc_loword && (p) < _malloc_hiword && \
         ALIGNPTR(p) == ((univptr_t) (p)))

/* Check that the size field is valid */
#define VALID_START_SIZE_FIELD(sp) \
        (PTR_IN_HEAP((sp) + SIZE(sp) - 1) && \
         SIZEFIELD(sp) == SIZEFIELD((sp) + SIZE(sp) - 1))

#define VALID_END_SIZE_FIELD(ep) \
        (PTR_IN_HEAP((ep) - SIZE(ep) + 1) && \
         SIZEFIELD(ep) == SIZEFIELD((ep) - SIZE(ep) + 1))


#define ulong unsigned long

#ifdef CSRI_DEBUG
  /* 
   * Byte that is stored at the end of each block if the requested size
   * of the block is not a multiple of sizeof(Word). (If it is a multiple
   * of sizeof(Word), then we don't need to put the magic because the
   * endboundary tag will be corrupted and the tests that check the
   * validity of the boundary tag should detect it
   */
#ifndef u_char
#define u_char          unsigned char
#endif                          /* u_char */

#define MAGIC_BYTE              ((u_char) '\252')

  /* 
   * Check if size of the block is identical to requested size. Typical
   * tests will be of the form DONT_NEED_MAGIC(p) || something for
   * short-circuited protection, because blocks where DONT_NEED_MAGIC is
   * true will be tested for boundary tag detection so we don't need the
   * magic byte at the end.
   */
#define DONT_NEED_MAGIC(sp) \
        (REALSIZE(sp) == ((SIZE(sp) - ALLOC_OVERHEAD) * sizeof(Word)))

  /*
   * VALID_REALSIZE must not be used if either DONT_NEED_MAGIC or TOO_SMALL
   * are true
   */
#define VALID_REALSIZE(sp) \
        (REALSIZE(sp) < ((SIZE(sp) - ALLOC_OVERHEAD)*sizeof(Word)))

  /* Location of the magic byte */
#define MAGIC_PTR(sp)           ((u_char *)((sp) + HEADERWORDS) + REALSIZE(sp))

  /*
   * malloc code should only use the next three macros SET_REALSIZE,
   * VALID_MAGIC and TOO_SMALL, since they are the only ones which have
   * non-CSRI_DEBUG (null) alternatives
   */

  /* Macro sets the realsize of a block if necessary */
#define SET_REALSIZE(sp, n) \
        (TOO_SMALL(sp) ? 0 : \
         (REALSIZE(sp) = (n), \
          DONT_NEED_MAGIC(sp) || (*MAGIC_PTR(sp) = MAGIC_BYTE)))

  /* Macro tests that the magic byte is valid if it exists */
#define VALID_MAGIC(sp) \
        (TOO_SMALL(sp) || DONT_NEED_MAGIC(sp) || \
         (VALID_REALSIZE(sp) && (*MAGIC_PTR(sp) == MAGIC_BYTE)))

  /*
   * Bytes left over memalign may be too small to hold the real size, they
   * may be 1 word, i.e start and end tag stored in same word!
   */
#define TOO_SMALL(sp) (SIZE(sp) < ALLOC_OVERHEAD)

#else                           /* ! CSRI_DEBUG */
#define SET_REALSIZE(sp, n)
#define VALID_MAGIC(sp) (1)
#define TOO_SMALL(sp)           (0)
#endif                          /* CSRI_DEBUG */

/* 
 *  Check that a free list ptr points to a block with something pointing
 *  back. This is the only reason we use a doubly linked free list.
 */
#define VALID_NEXT_PTR(ep) (PTR_IN_HEAP(NEXT(ep)) && PREV(NEXT(ep)) == (ep))
#define VALID_PREV_PTR(ep) (PTR_IN_HEAP(PREV(ep)) && NEXT(PREV(ep)) == (ep))

/*
 *  quick bit-arithmetic to check a number (including 1) is a power of two.
 */
#define is_power_of_2(x) ((((x) - 1) & (x)) == 0)

/*
 *  An array to try and keep track of the distribution of sizes of
 *  malloc'ed blocks
 */
#ifdef CSRI_PROFILESIZES
#define MAXPROFILESIZE 2*1024
#define COUNTSIZE(nw) (_malloc_scount[((nw) < MAXPROFILESIZE) ? (nw) : 0]++)
#else
#define COUNTSIZE(nw)
#endif

#ifndef USESTDIO
  /* 
   * Much better not to use stdio - stdio calls malloc() and can
   * therefore cause problems when debugging heap corruption. However,
   * there's no guaranteed way to turn off buffering on a FILE pointer in
   * ANSI.  This is a vile kludge!
   */
#define fputs(s, f)             write(fileno(f), (s), strlen(s))
#define setvbuf(f, s, n, l)     __nothing()
#define fflush(f)               __nothing()
#endif                          /* USESTDIO */

#ifdef CSRI_TRACE
  /* 
   * Prints a trace string. For convenience, x is an
   * sprintf(_malloc_statsbuf, ...) or strcpy(_malloc_statsbuf, ...);
   * something which puts the appropriate text to be printed in
   * _malloc_statsbuf - ugly, but more convenient than making x a string.
   */
#define PRCSRI_TRACE(x) \
  if (_malloc_tracing) { \
        (void) x; \
        (void) fputs(_malloc_statsbuf, stderr); \
  } else \
        _malloc_tracing += 0
#else
#define PRCSRI_TRACE(x)
#endif

#ifdef CSRI_DEBUG
#define CHECKHEAP() \
  if (_malloc_debugging >= 2) \
        (void) mal_verify(_malloc_debugging >= 3); \
  else \
        _malloc_debugging += 0

#define CHECKFREEPTR(ep, msg) \
  if (_malloc_debugging >= 1) { \
        ASSERT_EP(PTR_IN_HEAP(ep), "pointer outside heap", (msg), (ep)); \
        ASSERT_EP(TAG(ep) == FREE, "already-allocated block", (msg), (ep)); \
        ASSERT_EP(VALID_END_SIZE_FIELD(ep), "corrupt block", msg, (ep)); \
        ASSERT_EP(VALID_NEXT_PTR(ep), "corrupt link to next free block", (msg), (ep)); \
        ASSERT_EP(VALID_PREV_PTR(ep), "corrupt link to previous free block", (msg), (ep)); \
  } else \
        _malloc_debugging += 0

#define CHECKALLOCPTR(sp, msg) \
  if (_malloc_debugging >= 1) { \
        ASSERT_SP(PTR_IN_HEAP(sp), "pointer outside heap", (msg), (sp)); \
        ASSERT_SP(TAG(sp) != FREE, "already-freed block", (msg), (sp)); \
        ASSERT_SP(VALID_START_SIZE_FIELD(sp), "corrupt block", (msg), (sp)); \
        ASSERT_SP(VALID_MAGIC(sp), "block with end overwritten", (msg), (sp)); \
  } else \
        _malloc_debugging += 0

#else                           /* !CSRI_DEBUG */
#define CHECKHEAP()
#define CHECKFREEPTR(ep, msg)
#define CHECKALLOCPTR(sp, msg)
#endif                          /* CSRI_DEBUG */

#define FREEMAGIC               '\125'

/*
 *  Memory functions but in words. We just call memset/memcpy, and hope
 *  that someone has optimized them. If you are on pure 4.2BSD, either
 *  redefine these in terms of bcopy/your own memcpy, or
 *  get the functions from one of 4.3src/Henry Spencer's strings
 *  package/C News src
 */
#define MEMSET(p, c, n) \
        (void) memset((univptr_t) (p), (c), (memsize_t) ((n) * sizeof(Word)))
#define MEMCPY(p1, p2, n) \
        (void) memcpy((univptr_t) (p1), (univptr_t) (p2), \
                                  (memsize_t) ((n) * sizeof(Word)))


#ifdef CSRI_DEBUG
#define DMEMSET(p, n)   MEMSET((p), FREEMAGIC, (n))
#else
#define DMEMSET(p, n)
#endif

/* 
 *  Thanks to Hugh Redelmeier for pointing out that an rcsid is "a
 *  variable accessed in a way not obvious to the compiler", so should
 *  be called volatile. Amazing - a use for const volatile...
 */
#ifndef RCSID                   /* define RCSID(x) to nothing if don't want the rcs headers */
#if defined(lint) || defined(__STRICT_ANSI__)
#define RCSID(x)
#else
#define RCSID(x)                static const volatile char *rcsid = x ;
#endif
#endif

#endif  /* __DEFS_H__ */                        /* Do not add anything after this line */

/*  Author: Mark Moraes <moraes@csri.toronto.edu> */

/*
 *  All globals are names starting with _malloc, which should not clash
 *  with anything else.
 */
/*
 *  Remember to initialize the variable in globals.c if you want, and
 *  provide an alternative short name in globrename.h
 */
/* $Id: csrimalloc.c 1.23.1.8 Wed, 26 May 2004 09:52:42 -0500 dunemush $ */
#ifndef __GLOBALRENAME_H__
#define __GLOBALRENAME_H__
/*
 *  Renaming all external symbols that are internal to the malloc to be
 *  unique within 6 characters for machines whose linkers just can't keep
 *  up. We hope the cpp is smart enough - if not, get GNU cccp or the
 *  cpp that comes with X Windows Version 11 Release 3.
 */
#ifdef SHORTNAMES
#define _malloc_minchunk        __MAL1_minchunk

#define _malloc_rovers          __MAL2_rovers
#define _malloc_binmax          __MALH_binmax
#define _malloc_firstbin        __MALG_firstbin
#define _malloc_lastbin         __MAL3_lastbin
#define _malloc_hiword          __MAL4_hiword
#define _malloc_loword          __MAL5_loword

#define _malloc_sbrkunits       __MAL6_sbrkunits

#define _malloc_mem                     __MAL7_mem

#define _malloc_tracing         __MAL8_tracing
#define _malloc_statsbuf        __MALA_statsbuf

#define _malloc_leaktrace       __MALB_leaktrace

#ifdef CSRI_PROFILESIZES
#define _malloc_scount          __MALC_scount
#endif                          /* CSRI_PROFILESIZES */

#ifdef CSRI_DEBUG
/*
 *  0 or 1 means checking all pointers before using them. Reasonably
 *  thorough.  2 means check the entire heap on every call to
 *  malloc/free/realloc/memalign. (the rest call these)
 */
#define _malloc_debugging       __MALD_debugging
#endif                          /* CSRI_DEBUG */
#define _malloc_version         __MALE_version

#define _malloc_memfunc         __MALF_memfunc

#endif  /* SHORTNAMES */                        /* Do not add anything after this line */
#endif  /* __GLOBALRENAME_H__ */                         /* Do not add anything after this line */
const char *_malloc_version =
  "CSRI, University of Toronto Malloc Version 1.18alpha";

/*
 *  _malloc_minchunk is the minimum number of units that a block can be
 *  cut down to.  If the difference between the required block size, and
 *  the first available block is greater than _malloc_minchunk, the
 *  block is chopped into two pieces, else the whole block is returned.
 *  The larger this is, the less fragmentation there will be, but the
 *  greater the waste. The actual minimum size of a block is therefore
 *  _malloc_minchunk*sizeof(Word) This consists of one word each for the
 *  boundary tags, one for the next and one for the prev pointers in a
 *  free block.
 */
size_t _malloc_minchunk = FIXEDOVERHEAD;

/*
 * _malloc_rovers is the array of pointers into that each point 'someplace'
 * into a list of free blocks smaller than a specified size. We start our
 * search for a block from _malloc_rovers, thus starting the search at a
 * different place everytime, rather than at the start of the list.  This
 * improves performance considerably, sez Knuth
 */
Word *_malloc_rovers[MAXBINS + 1] = { NULL };

const size_t _malloc_binmax[MAXBINS] = {
  8, 16, 32, 64, 128, 256, 512, 1024
};

int _malloc_firstbin = 0;
int _malloc_lastbin = 0;
Word *_malloc_hiword = NULL;
Word *_malloc_loword = NULL;

/* 
 *  _malloc_sbrkunits is the multiple of sizeof(Word) to actually use in
 *  sbrk() calls - _malloc_sbrkunits should be large enough that sbrk
 *  isn't called too often, but small enough that any program that
 *  mallocs a few bytes doesn't end up being very large. I've set it to
 *  1K resulting in a sbrk'ed size of 8K. This is (coincidentally!) the
 *  pagesize on Suns.  I think that this seems a reasonable number for
 *  modern programs that malloc heavily. For small programs, you may
 *  want to set it to a lower number.
 */
size_t _malloc_sbrkunits = DEF_SBRKUNITS;

Word *_malloc_mem = NULL;

/*
 *  Do not call any output routine other than fputs() - use sprintf() if
 *  you want to format something before printing. We don't want stdio
 *  calling malloc() if we can help it
 */
int _malloc_tracing = 0;        /* No tracing */
char _malloc_statsbuf[128];

int _malloc_leaktrace = 0;

#ifdef CSRI_PROFILESIZES
int _malloc_scount[MAXPROFILESIZE];
#endif                          /* CSRI_PROFILESIZES */

#ifdef CSRI_DEBUG
/*
 *  0 or 1 means checking all pointers before using them. Reasonably
 *  thorough.  2 means check the entire heap on every call to
 *  malloc/free/realloc/memalign. (the rest call these)
 */
int _malloc_debugging = 0;
#endif                          /* CSRI_DEBUG */

univptr_t(*_malloc_memfunc) proto((size_t)) = _mal_sbrk;

#ifndef __GLOBALS_H__
#define __GLOBALS_H__
/*
 *  Remember to initialize the variable in globals.c if you want, and
 *  provide an alternative short name in globrename.h
 */

    extern
      size_t
      _malloc_minchunk;

    extern Word *
      _malloc_rovers[];
    extern const
      size_t
      _malloc_binmax[];
    extern int
      _malloc_firstbin;
    extern int
      _malloc_lastbin;
    extern Word *
      _malloc_