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