-/* $Header: malloc.c,v 4.0 91/03/20 01:28:52 lwall Locked $
+/* $RCSfile: malloc.c,v $$Revision: 4.1 $$Date: 92/08/07 18:24:25 $
*
* $Log: malloc.c,v $
+ * Revision 4.1 92/08/07 18:24:25 lwall
+ *
+ * Revision 4.0.1.4 92/06/08 14:28:38 lwall
+ * patch20: removed implicit int declarations on functions
+ * patch20: hash tables now split only if the memory is available to do so
+ * patch20: realloc(0, size) now does malloc in case library routines call it
+ *
+ * Revision 4.0.1.3 91/11/05 17:57:40 lwall
+ * patch11: safe malloc code now integrated into Perl's malloc when possible
+ *
+ * Revision 4.0.1.2 91/06/07 11:20:45 lwall
+ * patch4: many, many itty-bitty portability fixes
+ *
+ * Revision 4.0.1.1 91/04/11 17:48:31 lwall
+ * patch1: Configure now figures out malloc ptr type
+ *
* Revision 4.0 91/03/20 01:28:52 lwall
* 4.0 baseline.
*
*/
#ifndef lint
+/*SUPPRESS 592*/
static char sccsid[] = "@(#)malloc.c 4.3 (Berkeley) 9/16/83";
#ifdef DEBUGGING
#include "EXTERN.h"
#include "perl.h"
-static findbucket(), morecore();
+static int findbucket();
+static int morecore();
/* I don't much care whether these are defined in sys/types.h--LAW */
#ifdef debug
#define ASSERT(p) if (!(p)) botch("p"); else
-static
+static void
botch(s)
char *s;
{
#define ASSERT(p)
#endif
-char *
+MALLOCPTRTYPE *
malloc(nbytes)
- register unsigned nbytes;
+ register MEM_SIZE nbytes;
{
register union overhead *p;
register int bucket = 0;
- register unsigned shiftr;
+ register MEM_SIZE shiftr;
+
+#ifdef safemalloc
+#ifdef DEBUGGING
+ MEM_SIZE size = nbytes;
+#endif
+
+#ifdef MSDOS
+ if (nbytes > 0xffff) {
+ fprintf(stderr, "Allocation too large: %lx\n", (long)nbytes);
+ my_exit(1);
+ }
+#endif /* MSDOS */
+#ifdef DEBUGGING
+ if ((long)nbytes < 0)
+ croak("panic: malloc");
+#endif
+#endif /* safemalloc */
/*
* Convert amount of memory requested into
*/
if (nextf[bucket] == NULL)
morecore(bucket);
- if ((p = (union overhead *)nextf[bucket]) == NULL)
+ if ((p = (union overhead *)nextf[bucket]) == NULL) {
+#ifdef safemalloc
+ if (!nomemok) {
+ fputs("Out of memory!\n", stderr);
+ my_exit(1);
+ }
+#else
return (NULL);
+#endif
+ }
+
+#ifdef safemalloc
+#if !(defined(I286) || defined(atarist))
+ DEBUG_m(fprintf(stderr,"0x%x: (%05d) malloc %ld bytes\n",p+1,an++,(long)size));
+#else
+ DEBUG_m(fprintf(stderr,"0x%lx: (%05d) malloc %ld bytes\n",p+1,an++,(long)size));
+#endif
+#endif /* safemalloc */
+
/* remove from linked list */
#ifdef RCHECK
if (*((int*)p) & (sizeof(union overhead) - 1))
-#ifndef I286
+#if !(defined(I286) || defined(atarist))
fprintf(stderr,"Corrupt malloc ptr 0x%x at 0x%x\n",*((int*)p),p);
#else
fprintf(stderr,"Corrupt malloc ptr 0x%lx at 0x%lx\n",*((int*)p),p);
p->ov_rmagic = RMAGIC;
*((u_int *)((caddr_t)p + nbytes - RSLOP)) = RMAGIC;
#endif
- return ((char *)(p + 1));
+ return ((MALLOCPTRTYPE *)(p + 1));
}
/*
register union overhead *op;
register int rnu; /* 2^rnu bytes will be requested */
register int nblks; /* become nblks blocks of the desired size */
- register int siz;
+ register MEM_SIZE siz;
if (nextf[bucket])
return;
* on a page boundary. Should
* make getpageize call?
*/
+#ifndef atarist /* on the atari we dont have to worry about this */
op = (union overhead *)sbrk(0);
#ifndef I286
if ((int)op & 0x3ff)
#else
/* The sbrk(0) call on the I286 always returns the next segment */
#endif
+#endif /* atarist */
-#ifndef I286
+#if !(defined(I286) || defined(atarist))
/* take 2k unless the block is bigger than that */
rnu = (bucket <= 8) ? 11 : bucket + 3;
#else
/* take 16k unless the block is bigger than that
- (80286s like large segments!) */
+ (80286s like large segments!), probably good on the atari too */
rnu = (bucket <= 11) ? 14 : bucket + 3;
#endif
nblks = 1 << (rnu - (bucket + 3)); /* how many blocks to get */
if (rnu < bucket)
rnu = bucket;
- op = (union overhead *)sbrk(1 << rnu);
+ op = (union overhead *)sbrk(1L << rnu);
/* no more room! */
if ((int)op == -1)
return;
*/
#ifndef I286
if ((int)op & 7) {
- op = (union overhead *)(((int)op + 8) &~ 7);
+ op = (union overhead *)(((MEM_SIZE)op + 8) &~ 7);
nblks--;
}
#else
}
void
-free(cp)
- char *cp;
+free(mp)
+ MALLOCPTRTYPE *mp;
{
- register int size;
+ register MEM_SIZE size;
register union overhead *op;
+ char *cp = (char*)mp;
+
+#ifdef safemalloc
+#if !(defined(I286) || defined(atarist))
+ DEBUG_m(fprintf(stderr,"0x%x: (%05d) free\n",cp,an++));
+#else
+ DEBUG_m(fprintf(stderr,"0x%lx: (%05d) free\n",cp,an++));
+#endif
+#endif /* safemalloc */
if (cp == NULL)
return;
*/
int reall_srchlen = 4; /* 4 should be plenty, -1 =>'s whole list */
-char *
-realloc(cp, nbytes)
- char *cp;
- unsigned nbytes;
+MALLOCPTRTYPE *
+realloc(mp, nbytes)
+ MALLOCPTRTYPE *mp;
+ MEM_SIZE nbytes;
{
- register u_int onb;
+ register MEM_SIZE onb;
union overhead *op;
char *res;
register int i;
int was_alloced = 0;
+ char *cp = (char*)mp;
+
+#ifdef safemalloc
+#ifdef DEBUGGING
+ MEM_SIZE size = nbytes;
+#endif
+
+#ifdef MSDOS
+ if (nbytes > 0xffff) {
+ fprintf(stderr, "Reallocation too large: %lx\n", size);
+ my_exit(1);
+ }
+#endif /* MSDOS */
+ if (!cp)
+ return malloc(nbytes);
+#ifdef DEBUGGING
+ if ((long)nbytes < 0)
+ croak("panic: realloc");
+#endif
+#endif /* safemalloc */
- if (cp == NULL)
- return (malloc(nbytes));
op = (union overhead *)((caddr_t)cp - sizeof (union overhead));
if (op->ov_magic == MAGIC) {
was_alloced++;
(i = findbucket(op, reall_srchlen)) < 0)
i = 0;
}
- onb = (1 << (i + 3)) - sizeof (*op) - RSLOP;
+ onb = (1L << (i + 3)) - sizeof (*op) - RSLOP;
/* avoid the copy if same size block */
if (was_alloced &&
nbytes <= onb && nbytes > (onb >> 1) - sizeof(*op) - RSLOP) {
*((u_int *)((caddr_t)op + nbytes - RSLOP)) = RMAGIC;
}
#endif
- return(cp);
+ res = cp;
}
- if ((res = malloc(nbytes)) == NULL)
- return (NULL);
- if (cp != res) /* common optimization */
- (void)bcopy(cp, res, (int)((nbytes < onb) ? nbytes : onb));
- if (was_alloced)
- free(cp);
- return (res);
+ else {
+ if ((res = (char*)malloc(nbytes)) == NULL)
+ return (NULL);
+ if (cp != res) /* common optimization */
+ Copy(cp, res, (MEM_SIZE)(nbytes<onb?nbytes:onb), char);
+ if (was_alloced)
+ free(cp);
+ }
+
+#ifdef safemalloc
+#ifdef DEBUGGING
+# if !(defined(I286) || defined(atarist))
+ if (debug & 128) {
+ fprintf(stderr,"0x%x: (%05d) rfree\n",res,an++);
+ fprintf(stderr,"0x%x: (%05d) realloc %ld bytes\n",res,an++,(long)size);
+ }
+# else
+ if (debug & 128) {
+ fprintf(stderr,"0x%lx: (%05d) rfree\n",res,an++);
+ fprintf(stderr,"0x%lx: (%05d) realloc %ld bytes\n",res,an++,(long)size);
+ }
+# endif
+#endif
+#endif /* safemalloc */
+ return ((MALLOCPTRTYPE*)res);
}
/*
* header starts at ``freep''. If srchlen is -1 search the whole list.
* Return bucket number, or -1 if not found.
*/
-static
+static int
findbucket(freep, srchlen)
union overhead *freep;
int srchlen;
* for each size category, the second showing the number of mallocs -
* frees for each size category.
*/
+void
mstats(s)
char *s;
{
projects / p5sagit/p5-mst-13.2.git / blobdiff