This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
b4be0316d2bfb8a9bea16f7123b3e1db4cadf29b
[perl5.git] / malloc.c
1 /*    malloc.c
2  *
3  */
4
5 #ifndef lint
6 #ifdef DEBUGGING
7 #define RCHECK
8 #endif
9 /*
10  * malloc.c (Caltech) 2/21/82
11  * Chris Kingsley, kingsley@cit-20.
12  *
13  * This is a very fast storage allocator.  It allocates blocks of a small 
14  * number of different sizes, and keeps free lists of each size.  Blocks that
15  * don't exactly fit are passed up to the next larger size.  In this 
16  * implementation, the available sizes are 2^n-4 (or 2^n-12) bytes long.
17  * If PACK_MALLOC is defined, small blocks are 2^n bytes long.
18  * This is designed for use in a program that uses vast quantities of memory,
19  * but bombs when it runs out. 
20  */
21
22 #include "EXTERN.h"
23 #include "perl.h"
24
25 #ifdef DEBUGGING
26 #undef DEBUG_m
27 #define DEBUG_m(a)  if (debug & 128)   a
28 #endif
29
30 /* I don't much care whether these are defined in sys/types.h--LAW */
31
32 #define u_char unsigned char
33 #define u_int unsigned int
34 #define u_short unsigned short
35
36 /* 286 and atarist like big chunks, which gives too much overhead. */
37 #if (defined(RCHECK) || defined(I286) || defined(atarist)) && defined(PACK_MALLOC)
38 #undef PACK_MALLOC
39 #endif 
40
41
42 /*
43  * The description below is applicable if PACK_MALLOC is not defined.
44  *
45  * The overhead on a block is at least 4 bytes.  When free, this space
46  * contains a pointer to the next free block, and the bottom two bits must
47  * be zero.  When in use, the first byte is set to MAGIC, and the second
48  * byte is the size index.  The remaining bytes are for alignment.
49  * If range checking is enabled and the size of the block fits
50  * in two bytes, then the top two bytes hold the size of the requested block
51  * plus the range checking words, and the header word MINUS ONE.
52  */
53 union   overhead {
54         union   overhead *ov_next;      /* when free */
55 #if MEM_ALIGNBYTES > 4
56         double  strut;                  /* alignment problems */
57 #endif
58         struct {
59                 u_char  ovu_magic;      /* magic number */
60                 u_char  ovu_index;      /* bucket # */
61 #ifdef RCHECK
62                 u_short ovu_size;       /* actual block size */
63                 u_int   ovu_rmagic;     /* range magic number */
64 #endif
65         } ovu;
66 #define ov_magic        ovu.ovu_magic
67 #define ov_index        ovu.ovu_index
68 #define ov_size         ovu.ovu_size
69 #define ov_rmagic       ovu.ovu_rmagic
70 };
71
72 #ifdef DEBUGGING
73 static void botch _((char *s));
74 #endif
75 static void morecore _((int bucket));
76 static int findbucket _((union overhead *freep, int srchlen));
77
78 #define MAGIC           0xff            /* magic # on accounting info */
79 #define RMAGIC          0x55555555      /* magic # on range info */
80 #ifdef RCHECK
81 #  define       RSLOP           sizeof (u_int)
82 #  ifdef TWO_POT_OPTIMIZE
83 #    define MAX_SHORT_BUCKET 12
84 #  else
85 #    define MAX_SHORT_BUCKET 13
86 #  endif 
87 #else
88 #  define       RSLOP           0
89 #endif
90
91 #ifdef PACK_MALLOC
92 /*
93  * In this case it is assumed that if we do sbrk() in 2K units, we
94  * will get 2K aligned blocks. The bucket number of the given subblock is
95  * on the boundary of 2K block which contains the subblock.
96  * Several following bytes contain the magic numbers for the subblocks
97  * in the block.
98  *
99  * Sizes of chunks are powers of 2 for chunks in buckets <=
100  * MAX_PACKED, after this they are (2^n - sizeof(union overhead)) (to
101  * get alignment right).
102  *
103  * We suppose that starts of all the chunks in a 2K block are in
104  * different 2^n-byte-long chunks.  If the top of the last chunk is
105  * aligned on a boundary of 2K block, this means that
106  * sizeof(union overhead)*"number of chunks" < 2^n, or
107  * sizeof(union overhead)*2K < 4^n, or n > 6 + log2(sizeof()/2)/2, if a
108  * chunk of size 2^n - overhead is used. Since this rules out n = 7
109  * for 8 byte alignment, we specialcase allocation of the first of 16
110  * 128-byte-long chunks.
111  *
112  * Note that with the above assumption we automatically have enough
113  * place for MAGIC at the start of 2K block.  Note also that we
114  * overlay union overhead over the chunk, thus the start of the chunk
115  * is immediately overwritten after freeing.
116  */
117 #  define MAX_PACKED 6
118 #  define MAX_2_POT_ALGO ((1<<(MAX_PACKED + 1)) - M_OVERHEAD)
119 #  define TWOK_MASK ((1<<11) - 1)
120 #  define TWOK_MASKED(x) ((u_int)(x) & ~TWOK_MASK)
121 #  define TWOK_SHIFT(x) ((u_int)(x) & TWOK_MASK)
122 #  define OV_INDEXp(block) ((u_char*)(TWOK_MASKED(block)))
123 #  define OV_INDEX(block) (*OV_INDEXp(block))
124 #  define OV_MAGIC(block,bucket) (*(OV_INDEXp(block) +                  \
125                                     (TWOK_SHIFT(block)>>(bucket + 3)) + \
126                                     (bucket > MAX_NONSHIFT ? 1 : 0)))
127 #  define CHUNK_SHIFT 0
128
129 static u_char n_blks[11 - 3]     = {224, 120, 62, 31, 16, 8, 4, 2};
130 static u_short blk_shift[11 - 3] = {256, 128, 64, 32, 
131                                     16*sizeof(union overhead), 
132                                     8*sizeof(union overhead), 
133                                     4*sizeof(union overhead), 
134                                     2*sizeof(union overhead), 
135 #  define MAX_NONSHIFT 2        /* Shift 64 greater than chunk 32. */
136 };
137
138 #else  /* !PACK_MALLOC */
139
140 #  define OV_MAGIC(block,bucket) (block)->ov_magic
141 #  define OV_INDEX(block) (block)->ov_index
142 #  define CHUNK_SHIFT 1
143 #endif /* !PACK_MALLOC */
144
145 #  define M_OVERHEAD (sizeof(union overhead) + RSLOP)
146
147 /*
148  * Big allocations are often of the size 2^n bytes. To make them a
149  * little bit better, make blocks of size 2^n+pagesize for big n.
150  */
151
152 #ifdef TWO_POT_OPTIMIZE
153
154 #  ifndef PERL_PAGESIZE
155 #    define PERL_PAGESIZE 4096
156 #  endif 
157 #  ifndef FIRST_BIG_TWO_POT
158 #    define FIRST_BIG_TWO_POT 14        /* 16K */
159 #  endif
160 #  define FIRST_BIG_BLOCK (1<<FIRST_BIG_TWO_POT) /* 16K */
161 /* If this value or more, check against bigger blocks. */
162 #  define FIRST_BIG_BOUND (FIRST_BIG_BLOCK - M_OVERHEAD)
163 /* If less than this value, goes into 2^n-overhead-block. */
164 #  define LAST_SMALL_BOUND ((FIRST_BIG_BLOCK>>1) - M_OVERHEAD)
165
166 #endif /* TWO_POT_OPTIMIZE */
167
168 #if defined(PERL_EMERGENCY_SBRK) && defined(PERL_CORE)
169
170 #ifndef BIG_SIZE
171 #  define BIG_SIZE (1<<16)              /* 64K */
172 #endif 
173
174 static char *emergency_buffer;
175 static MEM_SIZE emergency_buffer_size;
176
177 static char *
178 emergency_sbrk(size)
179     MEM_SIZE size;
180 {
181     if (size >= BIG_SIZE) {
182         /* Give the possibility to recover: */
183         die("Out of memory during request for %i bytes", size);
184         /* croak may eat too much memory. */
185     }
186
187     if (!emergency_buffer) {            
188         /* First offense, give a possibility to recover by dieing. */
189         /* No malloc involved here: */
190         GV **gvp = (GV**)hv_fetch(defstash, "^M", 2, 0);
191         SV *sv;
192         char *pv;
193
194         if (!gvp) gvp = (GV**)hv_fetch(defstash, "\015", 1, 0);
195         if (!gvp || !(sv = GvSV(*gvp)) || !SvPOK(sv) 
196             || (SvLEN(sv) < (1<<11) - M_OVERHEAD)) 
197             return (char *)-1;          /* Now die die die... */
198
199         /* Got it, now detach SvPV: */
200         pv = SvPV(sv, na);
201         /* Check alignment: */
202         if (((u_int)(pv - M_OVERHEAD)) & ((1<<11) - 1)) {
203             PerlIO_puts(PerlIO_stderr(),"Bad alignment of $^M!\n");
204             return (char *)-1;          /* die die die */
205         }
206
207         emergency_buffer = pv - M_OVERHEAD;
208         emergency_buffer_size = SvLEN(sv) + M_OVERHEAD;
209         SvPOK_off(sv);
210         SvREADONLY_on(sv);
211         die("Out of memory!");          /* croak may eat too much memory. */
212     }
213     else if (emergency_buffer_size >= size) {
214         emergency_buffer_size -= size;
215         return emergency_buffer + emergency_buffer_size;
216     }
217     
218     return (char *)-1;                  /* poor guy... */
219 }
220
221 #else /* !(defined(TWO_POT_OPTIMIZE) && defined(PERL_CORE)) */
222 #  define emergency_sbrk(size)  -1
223 #endif /* !(defined(TWO_POT_OPTIMIZE) && defined(PERL_CORE)) */
224
225 /*
226  * nextf[i] is the pointer to the next free block of size 2^(i+3).  The
227  * smallest allocatable block is 8 bytes.  The overhead information
228  * precedes the data area returned to the user.
229  */
230 #define NBUCKETS 30
231 static  union overhead *nextf[NBUCKETS];
232
233 #ifdef USE_PERL_SBRK
234 #define sbrk(a) Perl_sbrk(a)
235 char *  Perl_sbrk _((int size));
236 #else
237 extern  char *sbrk();
238 #endif
239
240 #ifdef DEBUGGING_MSTATS
241 /*
242  * nmalloc[i] is the difference between the number of mallocs and frees
243  * for a given block size.
244  */
245 static  u_int nmalloc[NBUCKETS];
246 static  u_int goodsbrk;
247 static  u_int sbrk_slack;
248 static  u_int start_slack;
249 #endif
250
251 #ifdef DEBUGGING
252 #define ASSERT(p)   if (!(p)) botch(STRINGIFY(p));  else
253 static void
254 botch(s)
255         char *s;
256 {
257         PerlIO_printf(PerlIO_stderr(), "assertion botched: %s\n", s);
258         abort();
259 }
260 #else
261 #define ASSERT(p)
262 #endif
263
264 Malloc_t
265 malloc(nbytes)
266         register MEM_SIZE nbytes;
267 {
268         register union overhead *p;
269         register int bucket = 0;
270         register MEM_SIZE shiftr;
271
272 #if defined(DEBUGGING) || defined(RCHECK)
273         MEM_SIZE size = nbytes;
274 #endif
275
276 #ifdef PERL_CORE
277 #ifdef HAS_64K_LIMIT
278         if (nbytes > 0xffff) {
279                 PerlIO_printf(PerlIO_stderr(),
280                               "Allocation too large: %lx\n", (long)nbytes);
281                 my_exit(1);
282         }
283 #endif /* HAS_64K_LIMIT */
284 #ifdef DEBUGGING
285         if ((long)nbytes < 0)
286                 croak("panic: malloc");
287 #endif
288 #endif /* PERL_CORE */
289
290         /*
291          * Convert amount of memory requested into
292          * closest block size stored in hash buckets
293          * which satisfies request.  Account for
294          * space used per block for accounting.
295          */
296 #ifdef PACK_MALLOC
297         if (nbytes == 0)
298             nbytes = 1;
299         else if (nbytes > MAX_2_POT_ALGO)
300 #endif
301         {
302 #ifdef TWO_POT_OPTIMIZE
303                 if (nbytes >= FIRST_BIG_BOUND)
304                         nbytes -= PERL_PAGESIZE;
305 #endif 
306                 nbytes += M_OVERHEAD;
307                 nbytes = (nbytes + 3) &~ 3; 
308         }
309         shiftr = (nbytes - 1) >> 2;
310         /* apart from this loop, this is O(1) */
311         while (shiftr >>= 1)
312                 bucket++;
313         /*
314          * If nothing in hash bucket right now,
315          * request more memory from the system.
316          */
317         if (nextf[bucket] == NULL)    
318                 morecore(bucket);
319         if ((p = (union overhead *)nextf[bucket]) == NULL) {
320 #ifdef PERL_CORE
321                 if (!nomemok) {
322                     PerlIO_puts(PerlIO_stderr(),"Out of memory!\n");
323                     my_exit(1);
324                 }
325 #else
326                 return (NULL);
327 #endif
328         }
329
330 #ifdef PERL_CORE
331     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) malloc %ld bytes\n",
332         (unsigned long)(p+1),an++,(long)size));
333 #endif /* PERL_CORE */
334
335         /* remove from linked list */
336 #ifdef RCHECK
337         if (*((int*)p) & (sizeof(union overhead) - 1))
338             PerlIO_printf(PerlIO_stderr(), "Corrupt malloc ptr 0x%lx at 0x%lx\n",
339                 (unsigned long)*((int*)p),(unsigned long)p);
340 #endif
341         nextf[bucket] = p->ov_next;
342         OV_MAGIC(p, bucket) = MAGIC;
343 #ifndef PACK_MALLOC
344         OV_INDEX(p) = bucket;
345 #endif
346 #ifdef RCHECK
347         /*
348          * Record allocated size of block and
349          * bound space with magic numbers.
350          */
351         nbytes = (size + M_OVERHEAD + 3) &~ 3; 
352         if (nbytes <= 0x10000)
353                 p->ov_size = nbytes - 1;
354         p->ov_rmagic = RMAGIC;
355         *((u_int *)((caddr_t)p + nbytes - RSLOP)) = RMAGIC;
356 #endif
357         return ((Malloc_t)(p + CHUNK_SHIFT));
358 }
359
360 /*
361  * Allocate more memory to the indicated bucket.
362  */
363 static void
364 morecore(bucket)
365         register int bucket;
366 {
367         register union overhead *op;
368         register int rnu;       /* 2^rnu bytes will be requested */
369         register int nblks;     /* become nblks blocks of the desired size */
370         register MEM_SIZE siz, needed;
371         int slack = 0;
372
373         if (nextf[bucket])
374                 return;
375         if (bucket == (sizeof(MEM_SIZE)*8 - 3)) {
376             croak("Allocation too large");
377         }
378         /*
379          * Insure memory is allocated
380          * on a page boundary.  Should
381          * make getpageize call?
382          */
383 #ifndef atarist /* on the atari we dont have to worry about this */
384         op = (union overhead *)sbrk(0);
385 #  ifndef I286
386 #    ifdef PACK_MALLOC
387         if ((u_int)op & 0x7ff)
388                 (void)sbrk(slack = 2048 - ((u_int)op & 0x7ff));
389 #    else
390         if ((u_int)op & 0x3ff)
391                 (void)sbrk(slack = 1024 - ((u_int)op & 0x3ff));
392 #    endif
393 #    if defined(DEBUGGING_MSTATS)
394         sbrk_slack += slack;
395 #    endif
396 #  else
397         /* The sbrk(0) call on the I286 always returns the next segment */
398 #  endif
399 #endif /* atarist */
400
401 #if !(defined(I286) || defined(atarist))
402         /* take 2k unless the block is bigger than that */
403         rnu = (bucket <= 8) ? 11 : bucket + 3;
404 #else
405         /* take 16k unless the block is bigger than that 
406            (80286s like large segments!), probably good on the atari too */
407         rnu = (bucket <= 11) ? 14 : bucket + 3;
408 #endif
409         nblks = 1 << (rnu - (bucket + 3));  /* how many blocks to get */
410         needed = (MEM_SIZE)1 << rnu;
411 #ifdef TWO_POT_OPTIMIZE
412         needed += (bucket >= (FIRST_BIG_TWO_POT - 3) ? PERL_PAGESIZE : 0);
413 #endif 
414         op = (union overhead *)sbrk(needed);
415         /* no more room! */
416         if (op == (union overhead *)-1) {
417             op = (union overhead *)emergency_sbrk(needed);
418             if (op == (union overhead *)-1)
419                 return;
420         }
421 #ifdef DEBUGGING_MSTATS
422         goodsbrk += needed;
423 #endif  
424         /*
425          * Round up to minimum allocation size boundary
426          * and deduct from block count to reflect.
427          */
428 #ifndef I286
429 #  ifdef PACK_MALLOC
430         if ((u_int)op & 0x7ff)
431                 croak("panic: Off-page sbrk");
432 #  endif
433         if ((u_int)op & 7) {
434                 op = (union overhead *)(((MEM_SIZE)op + 8) &~ 7);
435                 nblks--;
436         }
437 #else
438         /* Again, this should always be ok on an 80286 */
439 #endif
440         /*
441          * Add new memory allocated to that on
442          * free list for this hash bucket.
443          */
444         siz = 1 << (bucket + 3);
445 #ifdef PACK_MALLOC
446         *(u_char*)op = bucket;  /* Fill index. */
447         if (bucket <= MAX_PACKED - 3) {
448             op = (union overhead *) ((char*)op + blk_shift[bucket]);
449             nblks = n_blks[bucket];
450 #  ifdef DEBUGGING_MSTATS
451             start_slack += blk_shift[bucket];
452 #  endif
453         } else if (bucket <= 11 - 1 - 3) {
454             op = (union overhead *) ((char*)op + blk_shift[bucket]);
455             /* nblks = n_blks[bucket]; */
456             siz -= sizeof(union overhead);
457         } else op++;            /* One chunk per block. */
458 #endif /* !PACK_MALLOC */
459         nextf[bucket] = op;
460 #ifdef DEBUGGING_MSTATS
461         nmalloc[bucket] += nblks;
462 #endif 
463         while (--nblks > 0) {
464                 op->ov_next = (union overhead *)((caddr_t)op + siz);
465                 op = (union overhead *)((caddr_t)op + siz);
466         }
467         /* Not all sbrks return zeroed memory.*/
468         op->ov_next = (union overhead *)NULL;
469 #ifdef PACK_MALLOC
470         if (bucket == 7 - 3) {  /* Special case, explanation is above. */
471             union overhead *n_op = nextf[7 - 3]->ov_next;
472             nextf[7 - 3] = (union overhead *)((caddr_t)nextf[7 - 3] 
473                                               - sizeof(union overhead));
474             nextf[7 - 3]->ov_next = n_op;
475         }
476 #endif /* !PACK_MALLOC */
477 }
478
479 Free_t
480 free(mp)
481         Malloc_t mp;
482 {   
483         register MEM_SIZE size;
484         register union overhead *op;
485         char *cp = (char*)mp;
486 #ifdef PACK_MALLOC
487         u_char bucket;
488 #endif 
489
490 #ifdef PERL_CORE
491     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) free\n",(unsigned long)cp,an++));
492 #endif /* PERL_CORE */
493
494         if (cp == NULL)
495                 return;
496         op = (union overhead *)((caddr_t)cp 
497                                 - sizeof (union overhead) * CHUNK_SHIFT);
498 #ifdef PACK_MALLOC
499         bucket = OV_INDEX(op);
500 #endif 
501         if (OV_MAGIC(op, bucket) != MAGIC) {
502                 static bad_free_warn = -1;
503                 if (bad_free_warn == -1) {
504                     char *pbf = getenv("PERL_BADFREE");
505                     bad_free_warn = (pbf) ? atoi(pbf) : 1;
506                 }
507                 if (!bad_free_warn)
508                     return;
509 #ifdef RCHECK
510                 warn("%s free() ignored",
511                     op->ov_rmagic == RMAGIC - 1 ? "Duplicate" : "Bad");
512 #else
513                 warn("Bad free() ignored");
514 #endif
515                 return;                         /* sanity */
516         }
517 #ifdef RCHECK
518         ASSERT(op->ov_rmagic == RMAGIC);
519         if (OV_INDEX(op) <= MAX_SHORT_BUCKET)
520                 ASSERT(*(u_int *)((caddr_t)op + op->ov_size + 1 - RSLOP) == RMAGIC);
521         op->ov_rmagic = RMAGIC - 1;
522 #endif
523         ASSERT(OV_INDEX(op) < NBUCKETS);
524         size = OV_INDEX(op);
525         op->ov_next = nextf[size];
526         nextf[size] = op;
527 }
528
529 /*
530  * When a program attempts "storage compaction" as mentioned in the
531  * old malloc man page, it realloc's an already freed block.  Usually
532  * this is the last block it freed; occasionally it might be farther
533  * back.  We have to search all the free lists for the block in order
534  * to determine its bucket: 1st we make one pass thru the lists
535  * checking only the first block in each; if that fails we search
536  * ``reall_srchlen'' blocks in each list for a match (the variable
537  * is extern so the caller can modify it).  If that fails we just copy
538  * however many bytes was given to realloc() and hope it's not huge.
539  */
540 int reall_srchlen = 4;  /* 4 should be plenty, -1 =>'s whole list */
541
542 Malloc_t
543 realloc(mp, nbytes)
544         Malloc_t mp; 
545         MEM_SIZE nbytes;
546 {   
547         register MEM_SIZE onb;
548         union overhead *op;
549         char *res;
550         register int i;
551         int was_alloced = 0;
552         char *cp = (char*)mp;
553
554 #ifdef DEBUGGING
555         MEM_SIZE size = nbytes;
556 #endif
557
558 #ifdef PERL_CORE
559 #ifdef HAS_64K_LIMIT
560         if (nbytes > 0xffff) {
561                 PerlIO_printf(PerlIO_stderr(),
562                               "Reallocation too large: %lx\n", size);
563                 my_exit(1);
564         }
565 #endif /* HAS_64K_LIMIT */
566         if (!cp)
567                 return malloc(nbytes);
568 #ifdef DEBUGGING
569         if ((long)nbytes < 0)
570                 croak("panic: realloc");
571 #endif
572 #endif /* PERL_CORE */
573
574         op = (union overhead *)((caddr_t)cp 
575                                 - sizeof (union overhead) * CHUNK_SHIFT);
576         i = OV_INDEX(op);
577         if (OV_MAGIC(op, i) == MAGIC) {
578                 was_alloced = 1;
579         } else {
580                 /*
581                  * Already free, doing "compaction".
582                  *
583                  * Search for the old block of memory on the
584                  * free list.  First, check the most common
585                  * case (last element free'd), then (this failing)
586                  * the last ``reall_srchlen'' items free'd.
587                  * If all lookups fail, then assume the size of
588                  * the memory block being realloc'd is the
589                  * smallest possible.
590                  */
591                 if ((i = findbucket(op, 1)) < 0 &&
592                     (i = findbucket(op, reall_srchlen)) < 0)
593                         i = 0;
594         }
595         onb = (1L << (i + 3)) - 
596 #ifdef PACK_MALLOC
597             (i <= (MAX_PACKED - 3) ? 0 : M_OVERHEAD)
598 #else
599             M_OVERHEAD
600 #endif
601 #ifdef TWO_POT_OPTIMIZE
602             + (i >= (FIRST_BIG_TWO_POT - 3) ? PERL_PAGESIZE : 0)
603 #endif
604             ;
605         /* 
606          *  avoid the copy if same size block.
607          *  We are not agressive with boundary cases. Note that it is
608          *  possible for small number of cases give false negative if
609          *  both new size and old one are in the bucket for
610          *  FIRST_BIG_TWO_POT, but the new one is near the lower end.
611          */
612         if (was_alloced &&
613             nbytes <= onb && (nbytes > ( (onb >> 1) - M_OVERHEAD )
614 #ifdef TWO_POT_OPTIMIZE
615                               || (i == (FIRST_BIG_TWO_POT - 3) 
616                                   && nbytes >= LAST_SMALL_BOUND )
617 #endif  
618                 )) {
619 #ifdef RCHECK
620                 /*
621                  * Record new allocated size of block and
622                  * bound space with magic numbers.
623                  */
624                 if (OV_INDEX(op) <= MAX_SHORT_BUCKET) {
625                         /*
626                          * Convert amount of memory requested into
627                          * closest block size stored in hash buckets
628                          * which satisfies request.  Account for
629                          * space used per block for accounting.
630                          */
631                         nbytes += M_OVERHEAD;
632                         nbytes = (nbytes + 3) &~ 3; 
633                         op->ov_size = nbytes - 1;
634                         *((u_int *)((caddr_t)op + nbytes - RSLOP)) = RMAGIC;
635                 }
636 #endif
637                 res = cp;
638         }
639         else {
640                 if ((res = (char*)malloc(nbytes)) == NULL)
641                         return (NULL);
642                 if (cp != res)                  /* common optimization */
643                         Copy(cp, res, (MEM_SIZE)(nbytes<onb?nbytes:onb), char);
644                 if (was_alloced)
645                         free(cp);
646         }
647
648 #ifdef PERL_CORE
649 #ifdef DEBUGGING
650     if (debug & 128) {
651         PerlIO_printf(PerlIO_stderr(), "0x%lx: (%05d) rfree\n",(unsigned long)res,an++);
652         PerlIO_printf(PerlIO_stderr(), "0x%lx: (%05d) realloc %ld bytes\n",
653             (unsigned long)res,an++,(long)size);
654     }
655 #endif
656 #endif /* PERL_CORE */
657         return ((Malloc_t)res);
658 }
659
660 /*
661  * Search ``srchlen'' elements of each free list for a block whose
662  * header starts at ``freep''.  If srchlen is -1 search the whole list.
663  * Return bucket number, or -1 if not found.
664  */
665 static int
666 findbucket(freep, srchlen)
667         union overhead *freep;
668         int srchlen;
669 {
670         register union overhead *p;
671         register int i, j;
672
673         for (i = 0; i < NBUCKETS; i++) {
674                 j = 0;
675                 for (p = nextf[i]; p && j != srchlen; p = p->ov_next) {
676                         if (p == freep)
677                                 return (i);
678                         j++;
679                 }
680         }
681         return (-1);
682 }
683
684 Malloc_t
685 calloc(elements, size)
686         register MEM_SIZE elements;
687         register MEM_SIZE size;
688 {
689     long sz = elements * size;
690     Malloc_t p = malloc(sz);
691
692     if (p) {
693         memset((void*)p, 0, sz);
694     }
695     return p;
696 }
697
698 #ifdef DEBUGGING_MSTATS
699 /*
700  * mstats - print out statistics about malloc
701  * 
702  * Prints two lines of numbers, one showing the length of the free list
703  * for each size category, the second showing the number of mallocs -
704  * frees for each size category.
705  */
706 void
707 dump_mstats(s)
708         char *s;
709 {
710         register int i, j;
711         register union overhead *p;
712         int topbucket=0, totfree=0, total=0;
713         u_int nfree[NBUCKETS];
714
715         for (i=0; i < NBUCKETS; i++) {
716                 for (j = 0, p = nextf[i]; p; p = p->ov_next, j++)
717                         ;
718                 nfree[i] = j;
719                 totfree += nfree[i]   * (1 << (i + 3));
720                 total += nmalloc[i] * (1 << (i + 3));
721                 if (nmalloc[i])
722                         topbucket = i;
723         }
724         if (s)
725                 PerlIO_printf(PerlIO_stderr(), "Memory allocation statistics %s (buckets 8..%d)\n",
726                         s, (1 << (topbucket + 3)) );
727         PerlIO_printf(PerlIO_stderr(), "%8d free:", totfree);
728         for (i=0; i <= topbucket; i++) {
729                 PerlIO_printf(PerlIO_stderr(), (i<5 || i==7)?" %5d": (i<9)?" %3d":" %d", nfree[i]);
730         }
731         PerlIO_printf(PerlIO_stderr(), "\n%8d used:", total - totfree);
732         for (i=0; i <= topbucket; i++) {
733                 PerlIO_printf(PerlIO_stderr(), (i<5 || i==7)?" %5d": (i<9)?" %3d":" %d", nmalloc[i] - nfree[i]);
734         }
735         PerlIO_printf(PerlIO_stderr(), "\nTotal sbrk(): %8d. Odd ends: sbrk(): %7d, malloc(): %7d bytes.\n",
736                       goodsbrk + sbrk_slack, sbrk_slack, start_slack);
737 }
738 #else
739 void
740 dump_mstats(s)
741     char *s;
742 {
743 }
744 #endif
745 #endif /* lint */
746
747
748 #ifdef USE_PERL_SBRK
749
750 #   ifdef NeXT
751 #      define PERL_SBRK_VIA_MALLOC
752 #   endif
753
754 #   ifdef PERL_SBRK_VIA_MALLOC
755 #      if defined(HIDEMYMALLOC) || defined(EMBEDMYMALLOC)
756 #         undef malloc
757 #      else
758 #         include "Error: -DPERL_SBRK_VIA_MALLOC needs -D(HIDE|EMBED)MYMALLOC"
759 #      endif
760
761 /* it may seem schizophrenic to use perl's malloc and let it call system */
762 /* malloc, the reason for that is only the 3.2 version of the OS that had */
763 /* frequent core dumps within nxzonefreenolock. This sbrk routine put an */
764 /* end to the cores */
765
766 #      define SYSTEM_ALLOC(a) malloc(a)
767
768 #   endif  /* PERL_SBRK_VIA_MALLOC */
769
770 static IV Perl_sbrk_oldchunk;
771 static long Perl_sbrk_oldsize;
772
773 #   define PERLSBRK_32_K (1<<15)
774 #   define PERLSBRK_64_K (1<<16)
775
776 char *
777 Perl_sbrk(size)
778 int size;
779 {
780     IV got;
781     int small, reqsize;
782
783     if (!size) return 0;
784 #ifdef PERL_CORE
785     reqsize = size; /* just for the DEBUG_m statement */
786 #endif
787     if (size <= Perl_sbrk_oldsize) {
788         got = Perl_sbrk_oldchunk;
789         Perl_sbrk_oldchunk += size;
790         Perl_sbrk_oldsize -= size;
791     } else {
792       if (size >= PERLSBRK_32_K) {
793         small = 0;
794       } else {
795 #ifndef PERL_CORE
796         reqsize = size;
797 #endif
798         size = PERLSBRK_64_K;
799         small = 1;
800       }
801       got = (IV)SYSTEM_ALLOC(size);
802       if (small) {
803         /* Chunk is small, register the rest for future allocs. */
804         Perl_sbrk_oldchunk = got + reqsize;
805         Perl_sbrk_oldsize = size - reqsize;
806       }
807     }
808
809 #ifdef PERL_CORE
810     DEBUG_m(PerlIO_printf(PerlIO_stderr(), "sbrk malloc size %ld (reqsize %ld), left size %ld, give addr 0x%lx\n",
811                     size, reqsize, Perl_sbrk_oldsize, got));
812 #endif
813
814     return (void *)got;
815 }
816
817 #endif /* ! defined USE_PERL_SBRK */