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