![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to malloc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to malloc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 ! root 1: /* dynamic memory allocation for GNU. ! 2: Copyright (C) 1985, 1987 Free Software Foundation, Inc. ! 3: ! 4: NO WARRANTY ! 5: ! 6: BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY ! 7: NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT ! 8: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, ! 9: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS" ! 10: WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, ! 11: BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND ! 12: FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY ! 13: AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE ! 14: DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR ! 15: CORRECTION. ! 16: ! 17: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. ! 18: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY ! 19: WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE ! 20: LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR ! 21: OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE ! 22: USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR ! 23: DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR ! 24: A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS ! 25: PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH ! 26: DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. ! 27: ! 28: GENERAL PUBLIC LICENSE TO COPY ! 29: ! 30: 1. You may copy and distribute verbatim copies of this source file ! 31: as you receive it, in any medium, provided that you conspicuously and ! 32: appropriately publish on each copy a valid copyright notice "Copyright ! 33: (C) 1985 Free Software Foundation, Inc."; and include following the ! 34: copyright notice a verbatim copy of the above disclaimer of warranty ! 35: and of this License. You may charge a distribution fee for the ! 36: physical act of transferring a copy. ! 37: ! 38: 2. You may modify your copy or copies of this source file or ! 39: any portion of it, and copy and distribute such modifications under ! 40: the terms of Paragraph 1 above, provided that you also do the following: ! 41: ! 42: a) cause the modified files to carry prominent notices stating ! 43: that you changed the files and the date of any change; and ! 44: ! 45: b) cause the whole of any work that you distribute or publish, ! 46: that in whole or in part contains or is a derivative of this ! 47: program or any part thereof, to be licensed at no charge to all ! 48: third parties on terms identical to those contained in this ! 49: License Agreement (except that you may choose to grant more extensive ! 50: warranty protection to some or all third parties, at your option). ! 51: ! 52: c) You may charge a distribution fee for the physical act of ! 53: transferring a copy, and you may at your option offer warranty ! 54: protection in exchange for a fee. ! 55: ! 56: Mere aggregation of another unrelated program with this program (or its ! 57: derivative) on a volume of a storage or distribution medium does not bring ! 58: the other program under the scope of these terms. ! 59: ! 60: 3. You may copy and distribute this program (or a portion or derivative ! 61: of it, under Paragraph 2) in object code or executable form under the terms ! 62: of Paragraphs 1 and 2 above provided that you also do one of the following: ! 63: ! 64: a) accompany it with the complete corresponding machine-readable ! 65: source code, which must be distributed under the terms of ! 66: Paragraphs 1 and 2 above; or, ! 67: ! 68: b) accompany it with a written offer, valid for at least three ! 69: years, to give any third party free (except for a nominal ! 70: shipping charge) a complete machine-readable copy of the ! 71: corresponding source code, to be distributed under the terms of ! 72: Paragraphs 1 and 2 above; or, ! 73: ! 74: c) accompany it with the information you received as to where the ! 75: corresponding source code may be obtained. (This alternative is ! 76: allowed only for noncommercial distribution and only if you ! 77: received the program in object code or executable form alone.) ! 78: ! 79: For an executable file, complete source code means all the source code for ! 80: all modules it contains; but, as a special exception, it need not include ! 81: source code for modules which are standard libraries that accompany the ! 82: operating system on which the executable file runs. ! 83: ! 84: 4. You may not copy, sublicense, distribute or transfer this program ! 85: except as expressly provided under this License Agreement. Any attempt ! 86: otherwise to copy, sublicense, distribute or transfer this program is void and ! 87: your rights to use the program under this License agreement shall be ! 88: automatically terminated. However, parties who have received computer ! 89: software programs from you with this License Agreement will not have ! 90: their licenses terminated so long as such parties remain in full compliance. ! 91: ! 92: 5. If you wish to incorporate parts of this program into other free ! 93: programs whose distribution conditions are different, write to the Free ! 94: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet ! 95: worked out a simple rule that can be stated here, but we will often permit ! 96: this. We will be guided by the two goals of preserving the free status of ! 97: all derivatives of our free software and of promoting the sharing and reuse of ! 98: software. ! 99: ! 100: ! 101: In other words, you are welcome to use, share and improve this program. ! 102: You are forbidden to forbid anyone else to use, share and improve ! 103: what you give them. Help stamp out software-hoarding! */ ! 104: ! 105: ! 106: /* ! 107: * @(#)nmalloc.c 1 (Caltech) 2/21/82 ! 108: * ! 109: * U of M Modified: 20 Jun 1983 ACT: strange hacks for Emacs ! 110: * ! 111: * Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD. ! 112: * ! 113: * This is a very fast storage allocator. It allocates blocks of a small ! 114: * number of different sizes, and keeps free lists of each size. Blocks ! 115: * that don't exactly fit are passed up to the next larger size. In this ! 116: * implementation, the available sizes are (2^n)-4 (or -16) bytes long. ! 117: * This is designed for use in a program that uses vast quantities of ! 118: * memory, but bombs when it runs out. To make it a little better, it ! 119: * warns the user when he starts to get near the end. ! 120: * ! 121: * June 84, ACT: modified rcheck code to check the range given to malloc, ! 122: * rather than the range determined by the 2-power used. ! 123: * ! 124: * Jan 85, RMS: calls malloc_warning to issue warning on nearly full. ! 125: * No longer Emacs-specific; can serve as all-purpose malloc for GNU. ! 126: * You should call malloc_init to reinitialize after loading dumped Emacs. ! 127: * Call malloc_stats to get info on memory stats if MSTATS turned on. ! 128: * realloc knows how to return same block given, just changing its size, ! 129: * if the power of 2 is correct. ! 130: */ ! 131: ! 132: /* ! 133: * nextf[i] is the pointer to the next free block of size 2^(i+3). The ! 134: * smallest allocatable block is 8 bytes. The overhead information will ! 135: * go in the first int of the block, and the returned pointer will point ! 136: * to the second. ! 137: * ! 138: #ifdef MSTATS ! 139: * nmalloc[i] is the difference between the number of mallocs and frees ! 140: * for a given block size. ! 141: #endif MSTATS ! 142: */ ! 143: ! 144: #ifdef emacs ! 145: /* config.h specifies which kind of system this is. */ ! 146: #include "config.h" ! 147: #else ! 148: ! 149: /* Determine which kind of system this is. */ ! 150: #include <signal.h> ! 151: #ifndef SIGTSTP ! 152: #ifndef VMS ! 153: #ifndef USG ! 154: #define USG ! 155: #endif ! 156: #endif /* not VMS */ ! 157: #else /* SIGTSTP */ ! 158: #ifdef SIGIO ! 159: #define BSD4_2 ! 160: #endif /* SIGIO */ ! 161: #endif /* SIGTSTP */ ! 162: ! 163: #endif /* not emacs */ ! 164: ! 165: /* Define getpagesize () if the system does not. */ ! 166: #include "getpagesize.h" ! 167: ! 168: #ifndef BSD4_2 ! 169: #ifndef USG ! 170: #include <sys/vlimit.h> /* warn the user when near the end */ ! 171: #endif /* not USG */ ! 172: #else /* if BSD4_2 */ ! 173: #include <sys/time.h> ! 174: #include <sys/resource.h> ! 175: #endif /* BSD4_2 */ ! 176: ! 177: extern char *start_of_data (); ! 178: ! 179: #ifdef BSD ! 180: #ifndef DATA_SEG_BITS ! 181: #define start_of_data() &etext ! 182: #endif ! 183: #endif ! 184: ! 185: #ifndef emacs ! 186: #define start_of_data() &etext ! 187: #endif ! 188: ! 189: #define ISALLOC ((char) 0xf7) /* magic byte that implies allocation */ ! 190: #define ISFREE ((char) 0x54) /* magic byte that implies free block */ ! 191: /* this is for error checking only */ ! 192: #define ISMEMALIGN ((char) 0xd6) /* Stored before the value returned by ! 193: memalign, with the rest of the word ! 194: being the distance to the true ! 195: beginning of the block. */ ! 196: ! 197: extern char etext; ! 198: ! 199: /* These two are for user programs to look at, when they are interested. */ ! 200: ! 201: unsigned int malloc_sbrk_used; /* amount of data space used now */ ! 202: unsigned int malloc_sbrk_unused; /* amount more we can have */ ! 203: ! 204: /* start of data space; can be changed by calling init_malloc */ ! 205: static char *data_space_start; ! 206: ! 207: #ifdef MSTATS ! 208: static int nmalloc[30]; ! 209: static int nmal, nfre; ! 210: #endif /* MSTATS */ ! 211: ! 212: /* If range checking is not turned on, all we have is a flag indicating ! 213: whether memory is allocated, an index in nextf[], and a size field; to ! 214: realloc() memory we copy either size bytes or 1<<(index+3) bytes depending ! 215: on whether the former can hold the exact size (given the value of ! 216: 'index'). If range checking is on, we always need to know how much space ! 217: is allocated, so the 'size' field is never used. */ ! 218: ! 219: struct mhead { ! 220: char mh_alloc; /* ISALLOC or ISFREE */ ! 221: char mh_index; /* index in nextf[] */ ! 222: /* Remainder are valid only when block is allocated */ ! 223: unsigned short mh_size; /* size, if < 0x10000 */ ! 224: #ifdef rcheck ! 225: unsigned mh_nbytes; /* number of bytes allocated */ ! 226: int mh_magic4; /* should be == MAGIC4 */ ! 227: #endif /* rcheck */ ! 228: }; ! 229: ! 230: /* Access free-list pointer of a block. ! 231: It is stored at block + 4. ! 232: This is not a field in the mhead structure ! 233: because we want sizeof (struct mhead) ! 234: to describe the overhead for when the block is in use, ! 235: and we do not want the free-list pointer to count in that. */ ! 236: ! 237: #define CHAIN(a) \ ! 238: (*(struct mhead **) (sizeof (char *) + (char *) (a))) ! 239: ! 240: #ifdef rcheck ! 241: ! 242: /* To implement range checking, we write magic values in at the beginning and ! 243: end of each allocated block, and make sure they are undisturbed whenever a ! 244: free or a realloc occurs. */ ! 245: /* Written in each of the 4 bytes following the block's real space */ ! 246: #define MAGIC1 0x55 ! 247: /* Written in the 4 bytes before the block's real space */ ! 248: #define MAGIC4 0x55555555 ! 249: #define ASSERT(p) if (!(p)) botch("p"); else ! 250: #define EXTRA 4 /* 4 bytes extra for MAGIC1s */ ! 251: #else ! 252: #define ASSERT(p) ! 253: #define EXTRA 0 ! 254: #endif /* rcheck */ ! 255: ! 256: ! 257: /* nextf[i] is free list of blocks of size 2**(i + 3) */ ! 258: ! 259: static struct mhead *nextf[30]; ! 260: ! 261: /* busy[i] is nonzero while allocation of block size i is in progress. */ ! 262: ! 263: static char busy[30]; ! 264: ! 265: /* Number of bytes of writable memory we can expect to be able to get */ ! 266: static unsigned int lim_data; ! 267: ! 268: /* Level number of warnings already issued. ! 269: 0 -- no warnings issued. ! 270: 1 -- 75% warning already issued. ! 271: 2 -- 85% warning already issued. ! 272: */ ! 273: static int warnlevel; ! 274: ! 275: /* Function to call to issue a warning; ! 276: 0 means don't issue them. */ ! 277: static void (*warnfunction) (); ! 278: ! 279: /* nonzero once initial bunch of free blocks made */ ! 280: static int gotpool; ! 281: ! 282: char *_malloc_base; ! 283: ! 284: static void getpool (); ! 285: ! 286: /* Cause reinitialization based on job parameters; ! 287: also declare where the end of pure storage is. */ ! 288: void ! 289: malloc_init (start, warnfun) ! 290: char *start; ! 291: void (*warnfun) (); ! 292: { ! 293: if (start) ! 294: data_space_start = start; ! 295: lim_data = 0; ! 296: warnlevel = 0; ! 297: warnfunction = warnfun; ! 298: } ! 299: ! 300: /* Return the maximum size to which MEM can be realloc'd ! 301: without actually requiring copying. */ ! 302: ! 303: int ! 304: malloc_usable_size (mem) ! 305: char *mem; ! 306: { ! 307: int blocksize = 8 << (((struct mhead *) mem) - 1) -> mh_index; ! 308: ! 309: return blocksize - sizeof (struct mhead) - EXTRA; ! 310: } ! 311: ! 312: static void ! 313: morecore (nu) /* ask system for more memory */ ! 314: register int nu; /* size index to get more of */ ! 315: { ! 316: char *sbrk (); ! 317: register char *cp; ! 318: register int nblks; ! 319: register unsigned int siz; ! 320: int oldmask; ! 321: ! 322: #ifdef BSD ! 323: #ifndef BSD4_1 ! 324: /* ?? There was a suggestion not to block SIGILL, somehow for GDB's sake. */ ! 325: oldmask = sigsetmask (-1); ! 326: #endif ! 327: #endif ! 328: ! 329: if (!data_space_start) ! 330: { ! 331: data_space_start = start_of_data (); ! 332: } ! 333: ! 334: if (lim_data == 0) ! 335: get_lim_data (); ! 336: ! 337: /* On initial startup, get two blocks of each size up to 1k bytes */ ! 338: if (!gotpool) ! 339: { getpool (); getpool (); gotpool = 1; } ! 340: ! 341: /* Find current end of memory and issue warning if getting near max */ ! 342: ! 343: #ifndef VMS ! 344: /* Maximum virtual memory on VMS is difficult to calculate since it ! 345: * depends on several dynmacially changing things. Also, alignment ! 346: * isn't that important. That is why much of the code here is ifdef'ed ! 347: * out for VMS systems. ! 348: */ ! 349: cp = sbrk (0); ! 350: siz = cp - data_space_start; ! 351: ! 352: if (warnfunction) ! 353: switch (warnlevel) ! 354: { ! 355: case 0: ! 356: if (siz > (lim_data / 4) * 3) ! 357: { ! 358: warnlevel++; ! 359: (*warnfunction) ("Warning: past 75% of memory limit"); ! 360: } ! 361: break; ! 362: case 1: ! 363: if (siz > (lim_data / 20) * 17) ! 364: { ! 365: warnlevel++; ! 366: (*warnfunction) ("Warning: past 85% of memory limit"); ! 367: } ! 368: break; ! 369: case 2: ! 370: if (siz > (lim_data / 20) * 19) ! 371: { ! 372: warnlevel++; ! 373: (*warnfunction) ("Warning: past 95% of memory limit"); ! 374: } ! 375: break; ! 376: } ! 377: ! 378: if ((int) cp & 0x3ff) /* land on 1K boundaries */ ! 379: sbrk (1024 - ((int) cp & 0x3ff)); ! 380: #endif /* not VMS */ ! 381: ! 382: /* Take at least 2k, and figure out how many blocks of the desired size ! 383: we're about to get */ ! 384: nblks = 1; ! 385: if ((siz = nu) < 8) ! 386: nblks = 1 << ((siz = 8) - nu); ! 387: ! 388: if ((cp = sbrk (1 << (siz + 3))) == (char *) -1) ! 389: { ! 390: #ifdef BSD ! 391: #ifndef BSD4_1 ! 392: sigsetmask (oldmask); ! 393: #endif ! 394: #endif ! 395: return; /* no more room! */ ! 396: } ! 397: malloc_sbrk_used = siz; ! 398: malloc_sbrk_unused = lim_data - siz; ! 399: ! 400: #ifndef VMS ! 401: if ((int) cp & 7) ! 402: { /* shouldn't happen, but just in case */ ! 403: cp = (char *) (((int) cp + 8) & ~7); ! 404: nblks--; ! 405: } ! 406: #endif /* not VMS */ ! 407: ! 408: /* save new header and link the nblks blocks together */ ! 409: nextf[nu] = (struct mhead *) cp; ! 410: siz = 1 << (nu + 3); ! 411: while (1) ! 412: { ! 413: ((struct mhead *) cp) -> mh_alloc = ISFREE; ! 414: ((struct mhead *) cp) -> mh_index = nu; ! 415: if (--nblks <= 0) break; ! 416: CHAIN ((struct mhead *) cp) = (struct mhead *) (cp + siz); ! 417: cp += siz; ! 418: } ! 419: CHAIN ((struct mhead *) cp) = 0; ! 420: ! 421: #ifdef BSD ! 422: #ifndef BSD4_1 ! 423: sigsetmask (oldmask); ! 424: #endif ! 425: #endif ! 426: } ! 427: ! 428: static void ! 429: getpool () ! 430: { ! 431: register int nu; ! 432: char * sbrk (); ! 433: register char *cp = sbrk (0); ! 434: ! 435: if ((int) cp & 0x3ff) /* land on 1K boundaries */ ! 436: sbrk (1024 - ((int) cp & 0x3ff)); ! 437: ! 438: /* Record address of start of space allocated by malloc. */ ! 439: if (_malloc_base == 0) ! 440: _malloc_base = cp; ! 441: ! 442: /* Get 2k of storage */ ! 443: ! 444: cp = sbrk (04000); ! 445: if (cp == (char *) -1) ! 446: return; ! 447: ! 448: /* Divide it into an initial 8-word block ! 449: plus one block of size 2**nu for nu = 3 ... 10. */ ! 450: ! 451: CHAIN (cp) = nextf[0]; ! 452: nextf[0] = (struct mhead *) cp; ! 453: ((struct mhead *) cp) -> mh_alloc = ISFREE; ! 454: ((struct mhead *) cp) -> mh_index = 0; ! 455: cp += 8; ! 456: ! 457: for (nu = 0; nu < 7; nu++) ! 458: { ! 459: CHAIN (cp) = nextf[nu]; ! 460: nextf[nu] = (struct mhead *) cp; ! 461: ((struct mhead *) cp) -> mh_alloc = ISFREE; ! 462: ((struct mhead *) cp) -> mh_index = nu; ! 463: cp += 8 << nu; ! 464: } ! 465: } ! 466: ! 467: char * ! 468: malloc (n) /* get a block */ ! 469: unsigned n; ! 470: { ! 471: register struct mhead *p; ! 472: register unsigned int nbytes; ! 473: register int nunits = 0; ! 474: ! 475: /* Figure out how many bytes are required, rounding up to the nearest ! 476: multiple of 8, then figure out which nestf[] area to use. ! 477: Both the beginning of the header and the beginning of the ! 478: block should be on an eight byte boundary. */ ! 479: nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7; ! 480: { ! 481: register unsigned int shiftr = (nbytes - 1) >> 2; ! 482: ! 483: while (shiftr >>= 1) ! 484: nunits++; ! 485: } ! 486: ! 487: /* In case this is reentrant use of malloc from signal handler, ! 488: pick a block size that no other malloc level is currently ! 489: trying to allocate. That's the easiest harmless way not to ! 490: interfere with the other level of execution. */ ! 491: while (busy[nunits]) nunits++; ! 492: busy[nunits] = 1; ! 493: ! 494: /* If there are no blocks of the appropriate size, go get some */ ! 495: /* COULD SPLIT UP A LARGER BLOCK HERE ... ACT */ ! 496: if (nextf[nunits] == 0) ! 497: morecore (nunits); ! 498: ! 499: /* Get one block off the list, and set the new list head */ ! 500: if ((p = nextf[nunits]) == 0) ! 501: { ! 502: busy[nunits] = 0; ! 503: return 0; ! 504: } ! 505: nextf[nunits] = CHAIN (p); ! 506: busy[nunits] = 0; ! 507: ! 508: /* Check for free block clobbered */ ! 509: /* If not for this check, we would gobble a clobbered free chain ptr */ ! 510: /* and bomb out on the NEXT allocate of this size block */ ! 511: if (p -> mh_alloc != ISFREE || p -> mh_index != nunits) ! 512: #ifdef rcheck ! 513: botch ("block on free list clobbered"); ! 514: #else /* not rcheck */ ! 515: abort (); ! 516: #endif /* not rcheck */ ! 517: ! 518: /* Fill in the info, and if range checking, set up the magic numbers */ ! 519: p -> mh_alloc = ISALLOC; ! 520: #ifdef rcheck ! 521: p -> mh_nbytes = n; ! 522: p -> mh_magic4 = MAGIC4; ! 523: { ! 524: /* Get the location n after the beginning of the user's space. */ ! 525: register char *m = (char *) p + ((sizeof *p + 7) & ~7) + n; ! 526: ! 527: *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1; ! 528: } ! 529: #else /* not rcheck */ ! 530: p -> mh_size = n; ! 531: #endif /* not rcheck */ ! 532: #ifdef MSTATS ! 533: nmalloc[nunits]++; ! 534: nmal++; ! 535: #endif /* MSTATS */ ! 536: return (char *) p + ((sizeof *p + 7) & ~7); ! 537: } ! 538: ! 539: free (mem) ! 540: char *mem; ! 541: { ! 542: register struct mhead *p; ! 543: { ! 544: register char *ap = mem; ! 545: ! 546: if (ap == 0) ! 547: return; ! 548: ! 549: p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7)); ! 550: if (p -> mh_alloc == ISMEMALIGN) ! 551: { ! 552: ap -= p->mh_size; ! 553: p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7)); ! 554: } ! 555: ! 556: #ifndef rcheck ! 557: if (p -> mh_alloc != ISALLOC) ! 558: abort (); ! 559: ! 560: #else rcheck ! 561: if (p -> mh_alloc != ISALLOC) ! 562: { ! 563: if (p -> mh_alloc == ISFREE) ! 564: botch ("free: Called with already freed block argument\n"); ! 565: else ! 566: botch ("free: Called with bad argument\n"); ! 567: } ! 568: ! 569: ASSERT (p -> mh_magic4 == MAGIC4); ! 570: ap += p -> mh_nbytes; ! 571: ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1); ! 572: ASSERT (*ap++ == MAGIC1); ASSERT (*ap == MAGIC1); ! 573: #endif /* rcheck */ ! 574: } ! 575: { ! 576: register int nunits = p -> mh_index; ! 577: ! 578: ASSERT (nunits <= 29); ! 579: p -> mh_alloc = ISFREE; ! 580: ! 581: /* Protect against signal handlers calling malloc. */ ! 582: busy[nunits] = 1; ! 583: /* Put this block on the free list. */ ! 584: CHAIN (p) = nextf[nunits]; ! 585: nextf[nunits] = p; ! 586: busy[nunits] = 0; ! 587: ! 588: #ifdef MSTATS ! 589: nmalloc[nunits]--; ! 590: nfre++; ! 591: #endif /* MSTATS */ ! 592: } ! 593: } ! 594: ! 595: char * ! 596: realloc (mem, n) ! 597: char *mem; ! 598: register unsigned n; ! 599: { ! 600: register struct mhead *p; ! 601: register unsigned int tocopy; ! 602: register unsigned int nbytes; ! 603: register int nunits; ! 604: ! 605: if (mem == 0) ! 606: return malloc (n); ! 607: p = (struct mhead *) (mem - ((sizeof *p + 7) & ~7)); ! 608: nunits = p -> mh_index; ! 609: ASSERT (p -> mh_alloc == ISALLOC); ! 610: #ifdef rcheck ! 611: ASSERT (p -> mh_magic4 == MAGIC4); ! 612: { ! 613: register char *m = mem + (tocopy = p -> mh_nbytes); ! 614: ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1); ! 615: ASSERT (*m++ == MAGIC1); ASSERT (*m == MAGIC1); ! 616: } ! 617: #else /* not rcheck */ ! 618: if (p -> mh_index >= 13) ! 619: tocopy = (1 << (p -> mh_index + 3)) - ((sizeof *p + 7) & ~7); ! 620: else ! 621: tocopy = p -> mh_size; ! 622: #endif /* not rcheck */ ! 623: ! 624: /* See if desired size rounds to same power of 2 as actual size. */ ! 625: nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7; ! 626: ! 627: /* If ok, use the same block, just marking its size as changed. */ ! 628: if (nbytes > (4 << nunits) && nbytes <= (8 << nunits)) ! 629: { ! 630: #ifdef rcheck ! 631: register char *m = mem + tocopy; ! 632: *m++ = 0; *m++ = 0; *m++ = 0; *m++ = 0; ! 633: p-> mh_nbytes = n; ! 634: m = mem + n; ! 635: *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1; ! 636: #else /* not rcheck */ ! 637: p -> mh_size = n; ! 638: #endif /* not rcheck */ ! 639: return mem; ! 640: } ! 641: ! 642: if (n < tocopy) ! 643: tocopy = n; ! 644: { ! 645: register char *new; ! 646: ! 647: if ((new = malloc (n)) == 0) ! 648: return 0; ! 649: bcopy (mem, new, tocopy); ! 650: free (mem); ! 651: return new; ! 652: } ! 653: } ! 654: ! 655: #ifndef VMS ! 656: ! 657: char * ! 658: memalign (alignment, size) ! 659: unsigned alignment, size; ! 660: { ! 661: register char *ptr = malloc (size + alignment); ! 662: register char *aligned; ! 663: register struct mhead *p; ! 664: ! 665: if (ptr == 0) ! 666: return 0; ! 667: /* If entire block has the desired alignment, just accept it. */ ! 668: if (((int) ptr & (alignment - 1)) == 0) ! 669: return ptr; ! 670: /* Otherwise, get address of byte in the block that has that alignment. */ ! 671: aligned = (char *) (((int) ptr + alignment - 1) & -alignment); ! 672: ! 673: /* Store a suitable indication of how to free the block, ! 674: so that free can find the true beginning of it. */ ! 675: p = (struct mhead *) aligned - 1; ! 676: p -> mh_size = aligned - ptr; ! 677: p -> mh_alloc = ISMEMALIGN; ! 678: return aligned; ! 679: } ! 680: ! 681: #ifndef HPUX ! 682: /* This runs into trouble with getpagesize on HPUX. ! 683: Patching out seems cleaner than the ugly fix needed. */ ! 684: char * ! 685: valloc (size) ! 686: { ! 687: return memalign (getpagesize (), size); ! 688: } ! 689: #endif /* not HPUX */ ! 690: #endif /* not VMS */ ! 691: ! 692: #ifdef MSTATS ! 693: /* Return statistics describing allocation of blocks of size 2**n. */ ! 694: ! 695: struct mstats_value ! 696: { ! 697: int blocksize; ! 698: int nfree; ! 699: int nused; ! 700: }; ! 701: ! 702: struct mstats_value ! 703: malloc_stats (size) ! 704: int size; ! 705: { ! 706: struct mstats_value v; ! 707: register int i; ! 708: register struct mhead *p; ! 709: ! 710: v.nfree = 0; ! 711: ! 712: if (size < 0 || size >= 30) ! 713: { ! 714: v.blocksize = 0; ! 715: v.nused = 0; ! 716: return v; ! 717: } ! 718: ! 719: v.blocksize = 1 << (size + 3); ! 720: v.nused = nmalloc[size]; ! 721: ! 722: for (p = nextf[size]; p; p = CHAIN (p)) ! 723: v.nfree++; ! 724: ! 725: return v; ! 726: } ! 727: int ! 728: malloc_mem_used () ! 729: { ! 730: int i; ! 731: int size_used; ! 732: ! 733: size_used = 0; ! 734: ! 735: for (i = 0; i < 30; i++) ! 736: { ! 737: int allocation_size = 1 << (i + 3); ! 738: struct mhead *p; ! 739: ! 740: size_used += nmalloc[i] * allocation_size; ! 741: } ! 742: ! 743: return size_used; ! 744: } ! 745: ! 746: int ! 747: malloc_mem_free () ! 748: { ! 749: int i; ! 750: int size_unused; ! 751: ! 752: size_unused = 0; ! 753: ! 754: for (i = 0; i < 30; i++) ! 755: { ! 756: int allocation_size = 1 << (i + 3); ! 757: struct mhead *p; ! 758: ! 759: for (p = nextf[i]; p ; p = CHAIN (p)) ! 760: size_unused += allocation_size; ! 761: } ! 762: ! 763: return size_unused; ! 764: } ! 765: #endif /* MSTATS */ ! 766: ! 767: /* ! 768: * This function returns the total number of bytes that the process ! 769: * will be allowed to allocate via the sbrk(2) system call. On ! 770: * BSD systems this is the total space allocatable to stack and ! 771: * data. On USG systems this is the data space only. ! 772: */ ! 773: ! 774: #ifdef USG ! 775: ! 776: get_lim_data () ! 777: { ! 778: extern long ulimit (); ! 779: ! 780: #ifdef ULIMIT_BREAK_VALUE ! 781: lim_data = ULIMIT_BREAK_VALUE; ! 782: #else ! 783: lim_data = ulimit (3, 0); ! 784: #endif ! 785: ! 786: lim_data -= (long) data_space_start; ! 787: } ! 788: ! 789: #else /* not USG */ ! 790: #ifndef BSD4_2 ! 791: ! 792: get_lim_data () ! 793: { ! 794: lim_data = vlimit (LIM_DATA, -1); ! 795: } ! 796: ! 797: #else /* BSD4_2 */ ! 798: ! 799: get_lim_data () ! 800: { ! 801: struct rlimit XXrlimit; ! 802: ! 803: getrlimit (RLIMIT_DATA, &XXrlimit); ! 804: #ifdef RLIM_INFINITY ! 805: lim_data = XXrlimit.rlim_cur & RLIM_INFINITY; /* soft limit */ ! 806: #else ! 807: lim_data = XXrlimit.rlim_cur; /* soft limit */ ! 808: #endif ! 809: } ! 810: ! 811: #endif /* BSD4_2 */ ! 812: #endif /* not USG */ ! 813: ! 814: #ifdef VMS ! 815: /* There is a problem when dumping and restoring things on VMS. Calls ! 816: * to SBRK don't necessarily result in contiguous allocation. Dumping ! 817: * doesn't work when it isn't. Therefore, we make the initial ! 818: * allocation contiguous by allocating a big chunk, and do SBRKs from ! 819: * there. Once Emacs has dumped there is no reason to continue ! 820: * contiguous allocation, malloc doesn't depend on it. ! 821: * ! 822: * There is a further problem of using brk and sbrk while using VMS C ! 823: * run time library routines malloc, calloc, etc. The documentation ! 824: * says that this is a no-no, although I'm not sure why this would be ! 825: * a problem. In any case, we remove the necessity to call brk and ! 826: * sbrk, by calling calloc (to assure zero filled data) rather than ! 827: * sbrk. ! 828: * ! 829: * VMS_ALLOCATION_SIZE is the size of the allocation array. This ! 830: * should be larger than the malloc size before dumping. Making this ! 831: * too large will result in the startup procedure slowing down since ! 832: * it will require more space and time to map it in. ! 833: * ! 834: * The value for VMS_ALLOCATION_SIZE in the following define was determined ! 835: * by running emacs linked (and a large allocation) with the debugger and ! 836: * looking to see how much storage was used. The allocation was 201 pages, ! 837: * so I rounded it up to a power of two. ! 838: */ ! 839: #ifndef VMS_ALLOCATION_SIZE ! 840: #define VMS_ALLOCATION_SIZE (512*256) ! 841: #endif ! 842: ! 843: /* Use VMS RTL definitions */ ! 844: #undef sbrk ! 845: #undef brk ! 846: #undef malloc ! 847: int vms_out_initial = 0; ! 848: char vms_initial_buffer[VMS_ALLOCATION_SIZE]; ! 849: static char *vms_current_brk = &vms_initial_buffer; ! 850: static char *vms_end_brk = &vms_initial_buffer[VMS_ALLOCATION_SIZE-1]; ! 851: ! 852: #include <stdio.h> ! 853: ! 854: char * ! 855: sys_sbrk (incr) ! 856: int incr; ! 857: { ! 858: char *sbrk(), *temp, *ptr; ! 859: ! 860: if (vms_out_initial) ! 861: { ! 862: /* out of initial allocation... */ ! 863: if (!(temp = malloc (incr))) ! 864: temp = (char *) -1; ! 865: } ! 866: else ! 867: { ! 868: /* otherwise, go out of our area */ ! 869: ptr = vms_current_brk + incr; /* new current_brk */ ! 870: if (ptr <= vms_end_brk) ! 871: { ! 872: temp = vms_current_brk; ! 873: vms_current_brk = ptr; ! 874: } ! 875: else ! 876: { ! 877: vms_out_initial = 1; /* mark as out of initial allocation */ ! 878: if (!(temp = malloc (incr))) ! 879: temp = (char *) -1; ! 880: } ! 881: } ! 882: return temp; ! 883: } ! 884: #endif /* VMS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.