Commit | Line | Data |
---|---|---|
714e064b JB |
1 | /* DO NOT EDIT THIS FILE -- it is automagically generated. -*- C -*- */ |
2 | ||
3 | #define _MALLOC_INTERNAL | |
4 | ||
5 | /* The malloc headers and source files from the C library follow here. */ | |
6 | ||
7 | /* Declarations for `malloc' and friends. | |
8 | Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. | |
9 | Written May 1989 by Mike Haertel. | |
10 | ||
11 | This library is free software; you can redistribute it and/or | |
12 | modify it under the terms of the GNU Library General Public License as | |
13 | published by the Free Software Foundation; either version 2 of the | |
14 | License, or (at your option) any later version. | |
15 | ||
16 | This library is distributed in the hope that it will be useful, | |
17 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
19 | Library General Public License for more details. | |
20 | ||
21 | You should have received a copy of the GNU Library General Public | |
22 | License along with this library; see the file COPYING.LIB. If | |
23 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
24 | Cambridge, MA 02139, USA. | |
25 | ||
26 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
27 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
28 | ||
29 | #ifndef _MALLOC_H | |
30 | ||
31 | #define _MALLOC_H 1 | |
32 | ||
33 | #ifdef __cplusplus | |
34 | extern "C" | |
35 | { | |
36 | #endif | |
37 | ||
38 | #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) | |
39 | #undef __P | |
40 | #define __P(args) args | |
41 | #undef __const | |
42 | #define __const const | |
43 | #undef __ptr_t | |
44 | #define __ptr_t void * | |
45 | #else /* Not C++ or ANSI C. */ | |
46 | #undef __P | |
47 | #define __P(args) () | |
48 | #undef __const | |
49 | #define __const | |
50 | #undef __ptr_t | |
51 | #define __ptr_t char * | |
52 | #endif /* C++ or ANSI C. */ | |
53 | ||
54 | #ifndef NULL | |
55 | #define NULL 0 | |
56 | #endif | |
57 | ||
58 | #ifdef __STDC__ | |
59 | #include <stddef.h> | |
60 | #else | |
61 | #ifdef VMS /* The following are defined in stdio.h, but we need it NOW! | |
62 | But do NOT do it with defines here, for then, VAX C is going | |
63 | to barf when it gets to stdio.h and the typedefs in there! */ | |
64 | typedef unsigned int size_t; | |
65 | typedef int ptrdiff_t; | |
66 | #else /* not VMS */ | |
67 | #undef size_t | |
68 | #define size_t unsigned int | |
69 | #undef ptrdiff_t | |
70 | #define ptrdiff_t int | |
71 | #endif /* VMS */ | |
72 | #endif | |
73 | ||
74 | ||
75 | /* Allocate SIZE bytes of memory. */ | |
76 | extern __ptr_t malloc __P ((size_t __size)); | |
77 | /* Re-allocate the previously allocated block | |
78 | in __ptr_t, making the new block SIZE bytes long. */ | |
79 | extern __ptr_t realloc __P ((__ptr_t __ptr, size_t __size)); | |
80 | /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ | |
81 | extern __ptr_t calloc __P ((size_t __nmemb, size_t __size)); | |
82 | /* Free a block allocated by `malloc', `realloc' or `calloc'. */ | |
83 | extern void free __P ((__ptr_t __ptr)); | |
84 | ||
85 | /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ | |
86 | extern __ptr_t memalign __P ((size_t __alignment, size_t __size)); | |
87 | ||
88 | /* Allocate SIZE bytes on a page boundary. */ | |
89 | extern __ptr_t valloc __P ((size_t __size)); | |
90 | ||
91 | #ifdef VMS | |
92 | /* VMS hooks to deal with two heaps */ | |
93 | /* Allocate SIZE bytes of memory. */ | |
94 | extern __ptr_t __vms_malloc __P ((size_t __size)); | |
95 | /* Re-allocate the previously allocated block | |
96 | in __ptr_t, making the new block SIZE bytes long. */ | |
97 | extern __ptr_t __vms_realloc __P ((__ptr_t __ptr, size_t __size)); | |
98 | /* Free a block allocated by `malloc', `realloc' or `calloc'. */ | |
99 | extern void __vms_free __P ((__ptr_t __ptr)); | |
100 | #endif | |
101 | ||
102 | #ifdef _MALLOC_INTERNAL | |
103 | ||
104 | #include <stdio.h> /* Harmless, gets __GNU_LIBRARY__ defined. */ | |
105 | ||
106 | #if defined(HAVE_CONFIG_H) || defined(emacs) | |
18160b98 | 107 | #include <config.h> |
714e064b JB |
108 | #endif |
109 | ||
110 | #if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) | |
111 | #include <string.h> | |
112 | #else | |
113 | #ifndef memset | |
114 | #define memset(s, zero, n) bzero ((s), (n)) | |
115 | #endif | |
116 | #ifndef memcpy | |
117 | #define memcpy(d, s, n) bcopy ((s), (d), (n)) | |
118 | #endif | |
119 | #ifndef memmove | |
120 | #define memmove(d, s, n) bcopy ((s), (d), (n)) | |
121 | #endif | |
122 | #endif | |
123 | ||
124 | ||
125 | #if defined(__GNU_LIBRARY__) || defined(__STDC__) | |
126 | #include <limits.h> | |
127 | #else | |
128 | #define CHAR_BIT 8 | |
129 | #endif | |
130 | ||
131 | /* The allocator divides the heap into blocks of fixed size; large | |
132 | requests receive one or more whole blocks, and small requests | |
133 | receive a fragment of a block. Fragment sizes are powers of two, | |
134 | and all fragments of a block are the same size. When all the | |
135 | fragments in a block have been freed, the block itself is freed. */ | |
136 | #define INT_BIT (CHAR_BIT * sizeof(int)) | |
137 | #ifdef VMS | |
138 | #define BLOCKLOG 9 | |
139 | #else | |
140 | #define BLOCKLOG (INT_BIT > 16 ? 12 : 9) | |
141 | #endif | |
142 | #define BLOCKSIZE (1 << BLOCKLOG) | |
143 | #define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) | |
144 | ||
145 | /* Determine the amount of memory spanned by the initial heap table | |
146 | (not an absolute limit). */ | |
147 | #define HEAP (INT_BIT > 16 ? 4194304 : 65536) | |
148 | ||
149 | /* Number of contiguous free blocks allowed to build up at the end of | |
150 | memory before they will be returned to the system. */ | |
151 | #define FINAL_FREE_BLOCKS 8 | |
152 | ||
153 | /* Data structure giving per-block information. */ | |
154 | typedef union | |
155 | { | |
156 | /* Heap information for a busy block. */ | |
157 | struct | |
158 | { | |
159 | /* Zero for a large block, or positive giving the | |
160 | logarithm to the base two of the fragment size. */ | |
161 | int type; | |
162 | union | |
163 | { | |
164 | struct | |
165 | { | |
166 | size_t nfree; /* Free fragments in a fragmented block. */ | |
167 | size_t first; /* First free fragment of the block. */ | |
168 | } frag; | |
169 | /* Size (in blocks) of a large cluster. */ | |
170 | size_t size; | |
171 | } info; | |
172 | } busy; | |
173 | /* Heap information for a free block | |
174 | (that may be the first of a free cluster). */ | |
175 | struct | |
176 | { | |
177 | size_t size; /* Size (in blocks) of a free cluster. */ | |
178 | size_t next; /* Index of next free cluster. */ | |
179 | size_t prev; /* Index of previous free cluster. */ | |
180 | } free; | |
181 | } malloc_info; | |
182 | ||
183 | /* Pointer to first block of the heap. */ | |
184 | extern char *_heapbase; | |
185 | ||
186 | /* Table indexed by block number giving per-block information. */ | |
187 | extern malloc_info *_heapinfo; | |
188 | ||
189 | /* Address to block number and vice versa. */ | |
190 | #define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) | |
191 | #define ADDRESS(B) ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase)) | |
192 | ||
193 | /* Current search index for the heap table. */ | |
194 | extern size_t _heapindex; | |
195 | ||
196 | /* Limit of valid info table indices. */ | |
197 | extern size_t _heaplimit; | |
198 | ||
199 | /* Doubly linked lists of free fragments. */ | |
200 | struct list | |
201 | { | |
202 | struct list *next; | |
203 | struct list *prev; | |
204 | }; | |
205 | ||
206 | /* Free list headers for each fragment size. */ | |
207 | extern struct list _fraghead[]; | |
208 | ||
209 | /* List of blocks allocated with `memalign' (or `valloc'). */ | |
210 | struct alignlist | |
211 | { | |
212 | struct alignlist *next; | |
213 | __ptr_t aligned; /* The address that memaligned returned. */ | |
214 | __ptr_t exact; /* The address that malloc returned. */ | |
215 | }; | |
216 | extern struct alignlist *_aligned_blocks; | |
217 | ||
218 | /* Instrumentation. */ | |
219 | extern size_t _chunks_used; | |
220 | extern size_t _bytes_used; | |
221 | extern size_t _chunks_free; | |
222 | extern size_t _bytes_free; | |
223 | ||
224 | /* Internal version of `free' used in `morecore' (malloc.c). */ | |
225 | extern void _free_internal __P ((__ptr_t __ptr)); | |
226 | ||
227 | #endif /* _MALLOC_INTERNAL. */ | |
228 | ||
229 | /* Underlying allocation function; successive calls should | |
230 | return contiguous pieces of memory. */ | |
231 | /* It does NOT always return contiguous pieces of memory on VMS. */ | |
232 | extern __ptr_t (*__morecore) __P ((ptrdiff_t __size)); | |
233 | ||
234 | /* Underlying deallocation function. It accepts both a pointer and | |
235 | a size to back up. It is implementation dependent what is really | |
236 | used. */ | |
237 | extern __ptr_t (*__lesscore) __P ((__ptr_t __ptr, ptrdiff_t __size)); | |
238 | ||
239 | /* Default value of `__morecore'. */ | |
240 | extern __ptr_t __default_morecore __P ((ptrdiff_t __size)); | |
241 | ||
242 | /* Default value of `__lesscore'. */ | |
243 | extern __ptr_t __default_lesscore __P ((__ptr_t __ptr, ptrdiff_t __size)); | |
244 | ||
245 | #ifdef VMS | |
246 | /* Default value of `__morecore'. */ | |
247 | extern __ptr_t __vms_morecore __P ((ptrdiff_t __size)); | |
248 | ||
249 | /* Default value of `__lesscore'. */ | |
250 | extern __ptr_t __vms_lesscore __P ((__ptr_t __ptr, ptrdiff_t __size)); | |
251 | #endif | |
252 | ||
253 | /* If not NULL, this function is called after each time | |
254 | `__morecore' is called to increase the data size. */ | |
255 | extern void (*__after_morecore_hook) __P ((void)); | |
256 | ||
257 | /* If not NULL, this function is called after each time | |
258 | `__lesscore' is called to increase the data size. */ | |
259 | extern void (*__after_lesscore_hook) __P ((void)); | |
260 | ||
261 | /* Nonzero if `malloc' has been called and done its initialization. */ | |
262 | extern int __malloc_initialized; | |
263 | ||
264 | /* Hooks for debugging versions. */ | |
265 | extern void (*__free_hook) __P ((__ptr_t __ptr)); | |
266 | extern __ptr_t (*__malloc_hook) __P ((size_t __size)); | |
267 | extern __ptr_t (*__realloc_hook) __P ((__ptr_t __ptr, size_t __size)); | |
268 | ||
269 | /* Activate a standard collection of debugging hooks. */ | |
270 | extern int mcheck __P ((void (*__func) __P ((void)))); | |
271 | ||
272 | /* Activate a standard collection of tracing hooks. */ | |
273 | extern void mtrace __P ((void)); | |
274 | ||
275 | /* Statistics available to the user. */ | |
276 | struct mstats | |
277 | { | |
278 | size_t bytes_total; /* Total size of the heap. */ | |
279 | size_t chunks_used; /* Chunks allocated by the user. */ | |
280 | size_t bytes_used; /* Byte total of user-allocated chunks. */ | |
281 | size_t chunks_free; /* Chunks in the free list. */ | |
282 | size_t bytes_free; /* Byte total of chunks in the free list. */ | |
283 | }; | |
284 | ||
285 | /* Pick up the current statistics. */ | |
286 | extern struct mstats mstats __P ((void)); | |
287 | ||
288 | /* Call WARNFUN with a warning message when memory usage is high. */ | |
289 | extern void memory_warnings __P ((__ptr_t __start, | |
290 | void (*__warnfun) __P ((__const char *)))); | |
291 | ||
292 | ||
293 | /* Relocating allocator. */ | |
294 | ||
295 | /* Allocate SIZE bytes, and store the address in *HANDLEPTR. */ | |
296 | extern __ptr_t r_alloc __P ((__ptr_t *__handleptr, size_t __size)); | |
297 | ||
298 | /* Free the storage allocated in HANDLEPTR. */ | |
299 | extern void r_alloc_free __P ((__ptr_t *__handleptr)); | |
300 | ||
301 | /* Adjust the block at HANDLEPTR to be SIZE bytes long. */ | |
302 | extern __ptr_t r_re_alloc __P ((__ptr_t *__handleptr, size_t __size)); | |
303 | ||
304 | ||
305 | #ifdef __cplusplus | |
306 | } | |
307 | #endif | |
308 | ||
309 | #endif /* malloc.h */ | |
310 | /* Memory allocator `malloc'. | |
311 | Copyright 1990, 1991, 1992, 1993 Free Software Foundation | |
312 | Written May 1989 by Mike Haertel. | |
313 | ||
314 | This library is free software; you can redistribute it and/or | |
315 | modify it under the terms of the GNU Library General Public License as | |
316 | published by the Free Software Foundation; either version 2 of the | |
317 | License, or (at your option) any later version. | |
318 | ||
319 | This library is distributed in the hope that it will be useful, | |
320 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
321 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
322 | Library General Public License for more details. | |
323 | ||
324 | You should have received a copy of the GNU Library General Public | |
325 | License along with this library; see the file COPYING.LIB. If | |
326 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
327 | Cambridge, MA 02139, USA. | |
328 | ||
329 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
330 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
331 | ||
332 | #ifndef _MALLOC_INTERNAL | |
333 | #define _MALLOC_INTERNAL | |
334 | #include <malloc.h> | |
335 | #endif | |
336 | ||
337 | #ifdef VMS | |
338 | /* How to really get more memory. */ | |
339 | __ptr_t (*__morecore) __P ((ptrdiff_t __size)) = __vms_morecore; | |
340 | #else | |
341 | /* How to really get more memory. */ | |
342 | __ptr_t (*__morecore) __P ((ptrdiff_t __size)) = __default_morecore; | |
343 | #endif | |
344 | ||
345 | /* Debugging hook for `malloc'. */ | |
346 | #ifdef VMS | |
347 | __ptr_t (*__malloc_hook) __P ((size_t __size)) = __vms_malloc; | |
348 | #else | |
349 | __ptr_t (*__malloc_hook) __P ((size_t __size)); | |
350 | #endif | |
351 | ||
352 | /* Pointer to the base of the first block. */ | |
353 | char *_heapbase; | |
354 | ||
355 | /* Block information table. Allocated with align/__free (not malloc/free). */ | |
356 | malloc_info *_heapinfo; | |
357 | ||
358 | /* Number of info entries. */ | |
359 | static size_t heapsize; | |
360 | ||
361 | /* Search index in the info table. */ | |
362 | size_t _heapindex; | |
363 | ||
364 | /* Limit of valid info table indices. */ | |
365 | size_t _heaplimit; | |
366 | ||
367 | /* Free lists for each fragment size. */ | |
368 | struct list _fraghead[BLOCKLOG]; | |
369 | ||
370 | /* Instrumentation. */ | |
371 | size_t _chunks_used; | |
372 | size_t _bytes_used; | |
373 | size_t _chunks_free; | |
374 | size_t _bytes_free; | |
375 | ||
376 | /* Are you experienced? */ | |
377 | int __malloc_initialized; | |
378 | ||
379 | void (*__after_morecore_hook) __P ((void)); | |
380 | ||
381 | /* Aligned allocation. */ | |
382 | static __ptr_t align __P ((size_t)); | |
383 | static __ptr_t | |
384 | align (size) | |
385 | size_t size; | |
386 | { | |
387 | __ptr_t result; | |
388 | unsigned long int adj; | |
389 | ||
390 | result = (*__morecore) (size); | |
391 | adj = (unsigned long int) ((unsigned long int) ((char *) result - | |
392 | (char *) NULL)) % BLOCKSIZE; | |
393 | if (adj != 0) | |
394 | { | |
395 | adj = BLOCKSIZE - adj; | |
396 | (void) (*__morecore) (adj); | |
397 | result = (char *) result + adj; | |
398 | } | |
399 | ||
400 | if (__after_morecore_hook) | |
401 | (*__after_morecore_hook) (); | |
402 | ||
403 | return result; | |
404 | } | |
405 | ||
406 | /* Set everything up and remember that we have. */ | |
407 | static int initialize __P ((void)); | |
408 | static int | |
409 | initialize () | |
410 | { | |
411 | #ifdef RL_DEBUG | |
412 | extern VMS_present_buffer(); | |
413 | printf("__malloc_initialized = %d\n", __malloc_initialized); | |
414 | VMS_present_buffer(); | |
415 | #endif | |
416 | heapsize = HEAP / BLOCKSIZE; | |
417 | _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info)); | |
418 | if (_heapinfo == NULL) | |
419 | return 0; | |
420 | memset (_heapinfo, 0, heapsize * sizeof (malloc_info)); | |
421 | _heapinfo[0].free.size = 0; | |
422 | _heapinfo[0].free.next = _heapinfo[0].free.prev = 0; | |
423 | _heapindex = 0; | |
424 | _heapbase = (char *) _heapinfo; | |
425 | #ifdef RL_DEBUG | |
426 | /* debug */ | |
427 | printf("_heapbase = 0%o/0x%x/%d\n", _heapbase, _heapbase, _heapbase); | |
428 | /* end debug */ | |
429 | #endif | |
430 | __malloc_initialized = 1; | |
431 | return 1; | |
432 | } | |
433 | ||
434 | /* Get neatly aligned memory, initializing or | |
435 | growing the heap info table as necessary. */ | |
436 | static __ptr_t morecore __P ((size_t)); | |
437 | static __ptr_t | |
438 | morecore (size) | |
439 | size_t size; | |
440 | { | |
441 | __ptr_t result; | |
442 | malloc_info *newinfo, *oldinfo; | |
443 | size_t newsize; | |
444 | ||
445 | result = align (size); | |
446 | if (result == NULL) | |
447 | return NULL; | |
448 | ||
449 | /* Check if we need to grow the info table. */ | |
450 | if ((size_t) BLOCK ((char *) result + size) > heapsize) | |
451 | { | |
452 | newsize = heapsize; | |
453 | while ((size_t) BLOCK ((char *) result + size) > newsize) | |
454 | newsize *= 2; | |
455 | newinfo = (malloc_info *) align (newsize * sizeof (malloc_info)); | |
456 | if (newinfo == NULL) | |
457 | { | |
458 | (*__lesscore) (result, size); | |
459 | return NULL; | |
460 | } | |
461 | memset (newinfo, 0, newsize * sizeof (malloc_info)); | |
462 | memcpy (newinfo, _heapinfo, heapsize * sizeof (malloc_info)); | |
463 | oldinfo = _heapinfo; | |
464 | newinfo[BLOCK (oldinfo)].busy.type = 0; | |
465 | newinfo[BLOCK (oldinfo)].busy.info.size | |
466 | = BLOCKIFY (heapsize * sizeof (malloc_info)); | |
467 | _heapinfo = newinfo; | |
468 | _free_internal (oldinfo); | |
469 | heapsize = newsize; | |
470 | } | |
471 | ||
472 | _heaplimit = BLOCK ((char *) result + size); | |
473 | return result; | |
474 | } | |
475 | ||
476 | /* Allocate memory from the heap. */ | |
477 | __ptr_t | |
478 | malloc (size) | |
479 | size_t size; | |
480 | { | |
481 | __ptr_t result; | |
482 | size_t block, blocks, lastblocks, start; | |
483 | register size_t i; | |
484 | struct list *next; | |
485 | ||
486 | if (size == 0) | |
487 | return NULL; | |
488 | ||
489 | if (__malloc_hook != NULL) | |
490 | return (*__malloc_hook) (size); | |
491 | ||
492 | if (!__malloc_initialized) | |
493 | if (!initialize ()) | |
494 | return NULL; | |
495 | ||
496 | if (size < sizeof (struct list)) | |
497 | size = sizeof (struct list); | |
498 | ||
499 | /* Determine the allocation policy based on the request size. */ | |
500 | if (size <= BLOCKSIZE / 2) | |
501 | { | |
502 | /* Small allocation to receive a fragment of a block. | |
503 | Determine the logarithm to base two of the fragment size. */ | |
504 | register size_t log = 1; | |
505 | --size; | |
506 | while ((size /= 2) != 0) | |
507 | ++log; | |
508 | ||
509 | /* Look in the fragment lists for a | |
510 | free fragment of the desired size. */ | |
511 | next = _fraghead[log].next; | |
512 | if (next != NULL) | |
513 | { | |
514 | /* There are free fragments of this size. | |
515 | Pop a fragment out of the fragment list and return it. | |
516 | Update the block's nfree and first counters. */ | |
517 | result = (__ptr_t) next; | |
518 | next->prev->next = next->next; | |
519 | if (next->next != NULL) | |
520 | next->next->prev = next->prev; | |
521 | block = BLOCK (result); | |
522 | if (--_heapinfo[block].busy.info.frag.nfree != 0) | |
523 | _heapinfo[block].busy.info.frag.first = (unsigned long int) | |
524 | ((unsigned long int) ((char *) next->next - (char *) NULL) | |
525 | % BLOCKSIZE) >> log; | |
526 | ||
527 | /* Update the statistics. */ | |
528 | ++_chunks_used; | |
529 | _bytes_used += 1 << log; | |
530 | --_chunks_free; | |
531 | _bytes_free -= 1 << log; | |
532 | } | |
533 | else | |
534 | { | |
535 | /* No free fragments of the desired size, so get a new block | |
536 | and break it into fragments, returning the first. */ | |
537 | result = malloc (BLOCKSIZE); | |
538 | if (result == NULL) | |
539 | return NULL; | |
540 | ||
541 | /* Link all fragments but the first into the free list. */ | |
542 | for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) | |
543 | { | |
544 | next = (struct list *) ((char *) result + (i << log)); | |
545 | #ifdef RL_DEBUG | |
546 | printf("DEBUG: malloc (%d): next = %p\n", size, next); | |
547 | #endif | |
548 | next->next = _fraghead[log].next; | |
549 | next->prev = &_fraghead[log]; | |
550 | next->prev->next = next; | |
551 | if (next->next != NULL) | |
552 | next->next->prev = next; | |
553 | } | |
554 | ||
555 | /* Initialize the nfree and first counters for this block. */ | |
556 | block = BLOCK (result); | |
557 | _heapinfo[block].busy.type = log; | |
558 | _heapinfo[block].busy.info.frag.nfree = i - 1; | |
559 | _heapinfo[block].busy.info.frag.first = i - 1; | |
560 | ||
561 | _chunks_free += (BLOCKSIZE >> log) - 1; | |
562 | _bytes_free += BLOCKSIZE - (1 << log); | |
563 | _bytes_used -= BLOCKSIZE - (1 << log); | |
564 | } | |
565 | } | |
566 | else | |
567 | { | |
568 | /* Large allocation to receive one or more blocks. | |
569 | Search the free list in a circle starting at the last place visited. | |
570 | If we loop completely around without finding a large enough | |
571 | space we will have to get more memory from the system. */ | |
572 | blocks = BLOCKIFY (size); | |
573 | start = block = _heapindex; | |
574 | while (_heapinfo[block].free.size < blocks) | |
575 | { | |
576 | block = _heapinfo[block].free.next; | |
577 | if (block == start) | |
578 | { | |
579 | /* Need to get more from the system. Check to see if | |
580 | the new core will be contiguous with the final free | |
581 | block; if so we don't need to get as much. */ | |
582 | block = _heapinfo[0].free.prev; | |
583 | lastblocks = _heapinfo[block].free.size; | |
584 | if (_heaplimit != 0 && block + lastblocks == _heaplimit && | |
585 | (*__morecore) (0) == ADDRESS (block + lastblocks) && | |
586 | (morecore ((blocks - lastblocks) * BLOCKSIZE)) != NULL) | |
587 | { | |
588 | _heapinfo[block].free.size = blocks; | |
589 | _bytes_free += (blocks - lastblocks) * BLOCKSIZE; | |
590 | continue; | |
591 | } | |
592 | result = morecore (blocks * BLOCKSIZE); | |
593 | if (result == NULL) | |
594 | return NULL; | |
595 | block = BLOCK (result); | |
596 | _heapinfo[block].busy.type = 0; | |
597 | _heapinfo[block].busy.info.size = blocks; | |
598 | ++_chunks_used; | |
599 | _bytes_used += blocks * BLOCKSIZE; | |
600 | return result; | |
601 | } | |
602 | } | |
603 | ||
604 | /* At this point we have found a suitable free list entry. | |
605 | Figure out how to remove what we need from the list. */ | |
606 | result = ADDRESS (block); | |
607 | if (_heapinfo[block].free.size > blocks) | |
608 | { | |
609 | /* The block we found has a bit left over, | |
610 | so relink the tail end back into the free list. */ | |
611 | _heapinfo[block + blocks].free.size | |
612 | = _heapinfo[block].free.size - blocks; | |
613 | _heapinfo[block + blocks].free.next | |
614 | = _heapinfo[block].free.next; | |
615 | _heapinfo[block + blocks].free.prev | |
616 | = _heapinfo[block].free.prev; | |
617 | _heapinfo[_heapinfo[block].free.prev].free.next | |
618 | = _heapinfo[_heapinfo[block].free.next].free.prev | |
619 | = _heapindex = block + blocks; | |
620 | } | |
621 | else | |
622 | { | |
623 | /* The block exactly matches our requirements, | |
624 | so just remove it from the list. */ | |
625 | _heapinfo[_heapinfo[block].free.next].free.prev | |
626 | = _heapinfo[block].free.prev; | |
627 | _heapinfo[_heapinfo[block].free.prev].free.next | |
628 | = _heapindex = _heapinfo[block].free.next; | |
629 | --_chunks_free; | |
630 | } | |
631 | ||
632 | _heapinfo[block].busy.type = 0; | |
633 | _heapinfo[block].busy.info.size = blocks; | |
634 | ++_chunks_used; | |
635 | _bytes_used += blocks * BLOCKSIZE; | |
636 | _bytes_free -= blocks * BLOCKSIZE; | |
637 | } | |
638 | ||
639 | return result; | |
640 | } | |
641 | /* Free a block of memory allocated by `malloc'. | |
642 | Copyright 1990, 1991, 1992 Free Software Foundation | |
643 | Written May 1989 by Mike Haertel. | |
644 | ||
645 | This library is free software; you can redistribute it and/or | |
646 | modify it under the terms of the GNU Library General Public License as | |
647 | published by the Free Software Foundation; either version 2 of the | |
648 | License, or (at your option) any later version. | |
649 | ||
650 | This library is distributed in the hope that it will be useful, | |
651 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
652 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
653 | Library General Public License for more details. | |
654 | ||
655 | You should have received a copy of the GNU Library General Public | |
656 | License along with this library; see the file COPYING.LIB. If | |
657 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
658 | Cambridge, MA 02139, USA. | |
659 | ||
660 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
661 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
662 | ||
663 | #ifndef _MALLOC_INTERNAL | |
664 | #define _MALLOC_INTERNAL | |
665 | #include <malloc.h> | |
666 | #endif | |
667 | ||
668 | #ifdef VMS | |
669 | /* How to really get more memory. */ | |
670 | __ptr_t (*__lesscore) __P ((__ptr_t __ptr,ptrdiff_t __size)) = __vms_lesscore; | |
671 | #else | |
672 | /* How to really get more memory. */ | |
673 | __ptr_t (*__lesscore) __P ((__ptr_t __ptr,ptrdiff_t __size)) = __default_lesscore; | |
674 | #endif | |
675 | ||
676 | /* Debugging hook for free. */ | |
677 | #ifdef VMS | |
678 | void (*__free_hook) __P ((__ptr_t __ptr)) = __vms_free; | |
679 | #else | |
680 | void (*__free_hook) __P ((__ptr_t __ptr)); | |
681 | #endif | |
682 | ||
683 | /* List of blocks allocated by memalign. */ | |
684 | struct alignlist *_aligned_blocks = NULL; | |
685 | ||
686 | /* Return memory to the heap. | |
687 | Like `free' but don't call a __free_hook if there is one. */ | |
688 | void | |
689 | _free_internal (ptr) | |
690 | __ptr_t ptr; | |
691 | { | |
692 | int type; | |
693 | size_t block, blocks; | |
694 | register size_t i; | |
695 | struct list *prev, *next; | |
696 | ||
697 | block = BLOCK (ptr); | |
698 | ||
699 | type = _heapinfo[block].busy.type; | |
700 | switch (type) | |
701 | { | |
702 | case 0: | |
703 | /* Get as many statistics as early as we can. */ | |
704 | --_chunks_used; | |
705 | _bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE; | |
706 | _bytes_free += _heapinfo[block].busy.info.size * BLOCKSIZE; | |
707 | ||
708 | /* Find the free cluster previous to this one in the free list. | |
709 | Start searching at the last block referenced; this may benefit | |
710 | programs with locality of allocation. */ | |
711 | i = _heapindex; | |
712 | if (i > block) | |
713 | while (i > block) | |
714 | i = _heapinfo[i].free.prev; | |
715 | else | |
716 | { | |
717 | do | |
718 | i = _heapinfo[i].free.next; | |
719 | while (i > 0 && i < block); | |
720 | i = _heapinfo[i].free.prev; | |
721 | } | |
722 | ||
723 | /* Determine how to link this block into the free list. */ | |
724 | if (block == i + _heapinfo[i].free.size) | |
725 | { | |
726 | /* Coalesce this block with its predecessor. */ | |
727 | _heapinfo[i].free.size += _heapinfo[block].busy.info.size; | |
728 | block = i; | |
729 | } | |
730 | else | |
731 | { | |
732 | /* Really link this block back into the free list. */ | |
733 | _heapinfo[block].free.size = _heapinfo[block].busy.info.size; | |
734 | _heapinfo[block].free.next = _heapinfo[i].free.next; | |
735 | _heapinfo[block].free.prev = i; | |
736 | _heapinfo[i].free.next = block; | |
737 | _heapinfo[_heapinfo[block].free.next].free.prev = block; | |
738 | ++_chunks_free; | |
739 | } | |
740 | ||
741 | /* Now that the block is linked in, see if we can coalesce it | |
742 | with its successor (by deleting its successor from the list | |
743 | and adding in its size). */ | |
744 | if (block + _heapinfo[block].free.size == _heapinfo[block].free.next) | |
745 | { | |
746 | _heapinfo[block].free.size | |
747 | += _heapinfo[_heapinfo[block].free.next].free.size; | |
748 | _heapinfo[block].free.next | |
749 | = _heapinfo[_heapinfo[block].free.next].free.next; | |
750 | _heapinfo[_heapinfo[block].free.next].free.prev = block; | |
751 | --_chunks_free; | |
752 | } | |
753 | ||
754 | /* Now see if we can return stuff to the system. */ | |
755 | blocks = _heapinfo[block].free.size; | |
756 | if (blocks >= FINAL_FREE_BLOCKS && block + blocks == _heaplimit | |
757 | && (*__morecore) (0) == ADDRESS (block + blocks)) | |
758 | { | |
759 | register size_t bytes = blocks * BLOCKSIZE; | |
760 | _heaplimit -= blocks; | |
761 | (*__lesscore) (ADDRESS(block), bytes); | |
762 | _heapinfo[_heapinfo[block].free.prev].free.next | |
763 | = _heapinfo[block].free.next; | |
764 | _heapinfo[_heapinfo[block].free.next].free.prev | |
765 | = _heapinfo[block].free.prev; | |
766 | block = _heapinfo[block].free.prev; | |
767 | --_chunks_free; | |
768 | _bytes_free -= bytes; | |
769 | } | |
770 | ||
771 | /* Set the next search to begin at this block. */ | |
772 | _heapindex = block; | |
773 | break; | |
774 | ||
775 | default: | |
776 | /* Do some of the statistics. */ | |
777 | --_chunks_used; | |
778 | _bytes_used -= 1 << type; | |
779 | ++_chunks_free; | |
780 | _bytes_free += 1 << type; | |
781 | ||
782 | /* Get the address of the first free fragment in this block. */ | |
783 | prev = (struct list *) ((char *) ADDRESS (block) + | |
784 | (_heapinfo[block].busy.info.frag.first << type)); | |
785 | #ifdef RL_DEBUG | |
786 | printf("_free_internal(0%o/0x%x/%d) :\n", ptr, ptr, ptr); | |
787 | printf(" block = %d, type = %d, prev = 0%o/0x%x/%d\n", | |
788 | block, type, prev, prev, prev); | |
789 | printf(" _heapinfo[block=%d].busy.info.frag.nfree = %d\n", | |
790 | block, | |
791 | _heapinfo[block].busy.info.frag.nfree); | |
792 | #endif | |
793 | ||
794 | if (_heapinfo[block].busy.info.frag.nfree == (BLOCKSIZE >> type) - 1) | |
795 | { | |
796 | /* If all fragments of this block are free, remove them | |
797 | from the fragment list and free the whole block. */ | |
798 | next = prev; | |
799 | for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i) | |
800 | next = next->next; | |
801 | prev->prev->next = next; | |
802 | if (next != NULL) | |
803 | next->prev = prev->prev; | |
804 | _heapinfo[block].busy.type = 0; | |
805 | _heapinfo[block].busy.info.size = 1; | |
806 | ||
807 | /* Keep the statistics accurate. */ | |
808 | ++_chunks_used; | |
809 | _bytes_used += BLOCKSIZE; | |
810 | _chunks_free -= BLOCKSIZE >> type; | |
811 | _bytes_free -= BLOCKSIZE; | |
812 | ||
813 | free (ADDRESS (block)); | |
814 | } | |
815 | else if (_heapinfo[block].busy.info.frag.nfree != 0) | |
816 | { | |
817 | /* If some fragments of this block are free, link this | |
818 | fragment into the fragment list after the first free | |
819 | fragment of this block. */ | |
820 | #ifdef RL_DEBUG | |
821 | printf("There's a bug hiding here (%s:%d), so I will print some values\n", __FILE__, __LINE__); | |
822 | #endif | |
823 | next = (struct list *) ptr; | |
824 | #ifdef RL_DEBUG | |
825 | printf(" (struct list *)next (0%o / 0x%x / %d) ->\n", next, next, next); | |
826 | printf(" next = 0%o / 0x%x / %d\n", next->next,next->next,next->next); | |
827 | printf(" prev = 0%o / 0x%x / %d\n", next->prev,next->prev,next->prev); | |
828 | printf(" (struct list *)prev (0%o / 0x%x / %d)->\n", prev, prev, prev); | |
829 | printf(" next = 0%o / 0x%x / %d\n", prev->next,prev->next,prev->next); | |
830 | printf(" prev = 0%o / 0x%x / %d\n", prev->prev,prev->prev,prev->prev); | |
831 | #endif | |
832 | next->next = prev->next; | |
833 | next->prev = prev; | |
834 | prev->next = next; | |
835 | if (next->next != NULL) | |
836 | next->next->prev = next; | |
837 | ++_heapinfo[block].busy.info.frag.nfree; | |
838 | } | |
839 | else | |
840 | { | |
841 | /* No fragments of this block are free, so link this | |
842 | fragment into the fragment list and announce that | |
843 | it is the first free fragment of this block. */ | |
844 | prev = (struct list *) ptr; | |
845 | _heapinfo[block].busy.info.frag.nfree = 1; | |
846 | _heapinfo[block].busy.info.frag.first = (unsigned long int) | |
847 | ((unsigned long int) ((char *) ptr - (char *) NULL) | |
848 | % BLOCKSIZE >> type); | |
849 | prev->next = _fraghead[type].next; | |
850 | prev->prev = &_fraghead[type]; | |
851 | prev->prev->next = prev; | |
852 | if (prev->next != NULL) | |
853 | prev->next->prev = prev; | |
854 | } | |
855 | break; | |
856 | } | |
857 | } | |
858 | ||
859 | /* Return memory to the heap. */ | |
860 | void | |
861 | free (ptr) | |
862 | __ptr_t ptr; | |
863 | { | |
864 | register struct alignlist *l; | |
865 | ||
866 | if (ptr == NULL) | |
867 | return; | |
868 | ||
869 | for (l = _aligned_blocks; l != NULL; l = l->next) | |
870 | if (l->aligned == ptr) | |
871 | { | |
872 | l->aligned = NULL; /* Mark the slot in the list as free. */ | |
873 | ptr = l->exact; | |
874 | break; | |
875 | } | |
876 | ||
877 | if (__free_hook != NULL) | |
878 | (*__free_hook) (ptr); | |
879 | else | |
880 | _free_internal (ptr); | |
881 | } | |
882 | /* Change the size of a block allocated by `malloc'. | |
883 | Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. | |
884 | Written May 1989 by Mike Haertel. | |
885 | ||
886 | This library is free software; you can redistribute it and/or | |
887 | modify it under the terms of the GNU Library General Public License as | |
888 | published by the Free Software Foundation; either version 2 of the | |
889 | License, or (at your option) any later version. | |
890 | ||
891 | This library is distributed in the hope that it will be useful, | |
892 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
893 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
894 | Library General Public License for more details. | |
895 | ||
896 | You should have received a copy of the GNU Library General Public | |
897 | License along with this library; see the file COPYING.LIB. If | |
898 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
899 | Cambridge, MA 02139, USA. | |
900 | ||
901 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
902 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
903 | ||
904 | #ifndef _MALLOC_INTERNAL | |
905 | #define _MALLOC_INTERNAL | |
906 | #include <malloc.h> | |
907 | #endif | |
908 | ||
909 | #define min(A, B) ((A) < (B) ? (A) : (B)) | |
910 | ||
911 | /* Debugging hook for realloc. */ | |
912 | #ifdef VMS | |
913 | __ptr_t (*__realloc_hook) __P ((__ptr_t __ptr, size_t __size)) = __vms_realloc; | |
914 | #else | |
915 | __ptr_t (*__realloc_hook) __P ((__ptr_t __ptr, size_t __size)); | |
916 | #endif | |
917 | ||
918 | /* Resize the given region to the new size, returning a pointer | |
919 | to the (possibly moved) region. This is optimized for speed; | |
920 | some benchmarks seem to indicate that greater compactness is | |
921 | achieved by unconditionally allocating and copying to a | |
922 | new region. This module has incestuous knowledge of the | |
923 | internals of both free and malloc. */ | |
924 | __ptr_t | |
925 | realloc (ptr, size) | |
926 | __ptr_t ptr; | |
927 | size_t size; | |
928 | { | |
929 | __ptr_t result; | |
930 | int type; | |
931 | size_t block, blocks, oldlimit; | |
932 | ||
933 | if (size == 0) | |
934 | { | |
935 | free (ptr); | |
936 | return malloc (0); | |
937 | } | |
938 | else if (ptr == NULL) | |
939 | return malloc (size); | |
940 | ||
941 | if (__realloc_hook != NULL) | |
942 | return (*__realloc_hook) (ptr, size); | |
943 | ||
944 | block = BLOCK (ptr); | |
945 | ||
946 | type = _heapinfo[block].busy.type; | |
947 | switch (type) | |
948 | { | |
949 | case 0: | |
950 | /* Maybe reallocate a large block to a small fragment. */ | |
951 | if (size <= BLOCKSIZE / 2) | |
952 | { | |
953 | result = malloc (size); | |
954 | if (result != NULL) | |
955 | { | |
956 | memcpy (result, ptr, size); | |
957 | free (ptr); | |
958 | return result; | |
959 | } | |
960 | } | |
961 | ||
962 | /* The new size is a large allocation as well; | |
963 | see if we can hold it in place. */ | |
964 | blocks = BLOCKIFY (size); | |
965 | if (blocks < _heapinfo[block].busy.info.size) | |
966 | { | |
967 | /* The new size is smaller; return | |
968 | excess memory to the free list. */ | |
969 | _heapinfo[block + blocks].busy.type = 0; | |
970 | _heapinfo[block + blocks].busy.info.size | |
971 | = _heapinfo[block].busy.info.size - blocks; | |
972 | _heapinfo[block].busy.info.size = blocks; | |
973 | free (ADDRESS (block + blocks)); | |
974 | result = ptr; | |
975 | } | |
976 | else if (blocks == _heapinfo[block].busy.info.size) | |
977 | /* No size change necessary. */ | |
978 | result = ptr; | |
979 | else | |
980 | { | |
981 | /* Won't fit, so allocate a new region that will. | |
982 | Free the old region first in case there is sufficient | |
983 | adjacent free space to grow without moving. */ | |
984 | blocks = _heapinfo[block].busy.info.size; | |
985 | /* Prevent free from actually returning memory to the system. */ | |
986 | oldlimit = _heaplimit; | |
987 | _heaplimit = 0; | |
988 | free (ptr); | |
989 | _heaplimit = oldlimit; | |
990 | result = malloc (size); | |
991 | if (result == NULL) | |
992 | { | |
993 | /* Now we're really in trouble. We have to unfree | |
994 | the thing we just freed. Unfortunately it might | |
995 | have been coalesced with its neighbors. */ | |
996 | if (_heapindex == block) | |
997 | (void) malloc (blocks * BLOCKSIZE); | |
998 | else | |
999 | { | |
1000 | __ptr_t previous = malloc ((block - _heapindex) * BLOCKSIZE); | |
1001 | (void) malloc (blocks * BLOCKSIZE); | |
1002 | free (previous); | |
1003 | } | |
1004 | return NULL; | |
1005 | } | |
1006 | if (ptr != result) | |
1007 | memmove (result, ptr, blocks * BLOCKSIZE); | |
1008 | } | |
1009 | break; | |
1010 | ||
1011 | default: | |
1012 | /* Old size is a fragment; type is logarithm | |
1013 | to base two of the fragment size. */ | |
1014 | if (size > (size_t) (1 << (type - 1)) && size <= (size_t) (1 << type)) | |
1015 | /* The new size is the same kind of fragment. */ | |
1016 | result = ptr; | |
1017 | else | |
1018 | { | |
1019 | /* The new size is different; allocate a new space, | |
1020 | and copy the lesser of the new size and the old. */ | |
1021 | result = malloc (size); | |
1022 | if (result == NULL) | |
1023 | return NULL; | |
1024 | memcpy (result, ptr, min (size, (size_t) 1 << type)); | |
1025 | free (ptr); | |
1026 | } | |
1027 | break; | |
1028 | } | |
1029 | ||
1030 | return result; | |
1031 | } | |
1032 | /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. | |
1033 | ||
1034 | This library is free software; you can redistribute it and/or | |
1035 | modify it under the terms of the GNU Library General Public License as | |
1036 | published by the Free Software Foundation; either version 2 of the | |
1037 | License, or (at your option) any later version. | |
1038 | ||
1039 | This library is distributed in the hope that it will be useful, | |
1040 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1041 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1042 | Library General Public License for more details. | |
1043 | ||
1044 | You should have received a copy of the GNU Library General Public | |
1045 | License along with this library; see the file COPYING.LIB. If | |
1046 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1047 | Cambridge, MA 02139, USA. | |
1048 | ||
1049 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
1050 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1051 | ||
1052 | #ifndef _MALLOC_INTERNAL | |
1053 | #define _MALLOC_INTERNAL | |
1054 | #include <malloc.h> | |
1055 | #endif | |
1056 | ||
1057 | /* Allocate an array of NMEMB elements each SIZE bytes long. | |
1058 | The entire array is initialized to zeros. */ | |
1059 | __ptr_t | |
1060 | calloc (nmemb, size) | |
1061 | register size_t nmemb; | |
1062 | register size_t size; | |
1063 | { | |
1064 | register __ptr_t result = malloc (nmemb * size); | |
1065 | ||
1066 | if (result != NULL) | |
1067 | (void) memset (result, 0, nmemb * size); | |
1068 | ||
1069 | return result; | |
1070 | } | |
1071 | /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. | |
1072 | This file is part of the GNU C Library. | |
1073 | ||
1074 | The GNU C Library is free software; you can redistribute it and/or modify | |
1075 | it under the terms of the GNU General Public License as published by | |
1076 | the Free Software Foundation; either version 2, or (at your option) | |
1077 | any later version. | |
1078 | ||
1079 | The GNU C Library is distributed in the hope that it will be useful, | |
1080 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1081 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
1082 | GNU General Public License for more details. | |
1083 | ||
1084 | You should have received a copy of the GNU General Public License | |
1085 | along with the GNU C Library; see the file COPYING. If not, write to | |
1086 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
1087 | ||
1088 | #ifndef _MALLOC_INTERNAL | |
1089 | #define _MALLOC_INTERNAL | |
1090 | #include <malloc.h> | |
1091 | #endif | |
1092 | ||
1093 | #ifndef __GNU_LIBRARY__ | |
1094 | #define __sbrk sbrk | |
1095 | #ifdef VMS | |
1096 | #define __brk brk | |
1097 | #endif | |
1098 | #endif | |
1099 | ||
1100 | extern __ptr_t __sbrk __P ((int increment)); | |
1101 | ||
1102 | #ifndef NULL | |
1103 | #define NULL 0 | |
1104 | #endif | |
1105 | ||
1106 | #if defined(emacs) && defined(VMS) | |
1107 | /* Dumping of Emacs on VMS does not include the heap! | |
1108 | So let's make a huge array from which initial data will be | |
1109 | allocated. | |
1110 | ||
1111 | VMS_ALLOCATION_SIZE is the amount of memory we preallocate. | |
1112 | We don't want it to be too large, because it only gives a larger | |
1113 | dump file. The way to check how much is really used is to | |
1114 | make VMS_ALLOCATION_SIZE very large, to link Emacs with the | |
1115 | debugger, run Emacs, check how much was allocated. Then set | |
1116 | VMS_ALLOCATION_SIZE to something suitable, recompile gmalloc, | |
1117 | relink Emacs, and you should be off. | |
1118 | ||
1119 | N.B. This is experimental, but it worked quite fine on Emacs 18. | |
1120 | */ | |
1121 | #ifndef VMS_ALLOCATION_SIZE | |
1122 | #define VMS_ALLOCATION_SIZE (512*(512+128)) | |
1123 | #endif | |
1124 | ||
1125 | int vms_out_initial = 0; | |
1126 | char vms_initial_buffer[VMS_ALLOCATION_SIZE]; | |
1127 | char *vms_current_brk = vms_initial_buffer; | |
1128 | char *vms_end_brk = &vms_initial_buffer[VMS_ALLOCATION_SIZE-1]; | |
1129 | ||
1130 | __ptr_t | |
1131 | __vms_initial_morecore (increment) | |
1132 | ptrdiff_t increment; | |
1133 | { | |
1134 | __ptr_t result = NULL; | |
1135 | __ptr_t temp; | |
1136 | ||
1137 | /* It's far easier to make the alignment here than to make a | |
1138 | kludge in align () */ | |
1139 | #ifdef RL_DEBUG | |
1140 | printf(">>>foo... %p...", vms_current_brk); | |
1141 | #endif | |
1142 | vms_current_brk += (BLOCKSIZE - ((unsigned long) vms_current_brk | |
1143 | & (BLOCKSIZE - 1))) & (BLOCKSIZE - 1); | |
1144 | #ifdef RL_DEBUG | |
1145 | printf("bar... %p. (%d)\n", vms_current_brk, increment); | |
1146 | #endif | |
1147 | temp = vms_current_brk + (int) increment; | |
1148 | if (temp <= vms_end_brk) | |
1149 | { | |
1150 | if (increment >= 0) | |
1151 | result = vms_current_brk; | |
1152 | else | |
1153 | result = temp; | |
1154 | vms_current_brk = temp; | |
1155 | } | |
1156 | return result; | |
1157 | } | |
1158 | ||
1159 | __ptr_t | |
1160 | __vms_initial_lesscore (ptr, size) | |
1161 | __ptr_t ptr; | |
1162 | ptrdiff_t size; | |
1163 | { | |
1164 | if (ptr >= vms_initial_buffer | |
1165 | && ptr < vms_initial_buffer+VMS_ALLOCATION_SIZE) | |
1166 | { | |
1167 | vms_current_brk = ptr; | |
1168 | return vms_current_brk; | |
1169 | } | |
1170 | return vms_current_brk; | |
1171 | } | |
1172 | ||
1173 | VMS_present_buffer() | |
1174 | { | |
1175 | printf("Vms initial buffer starts at 0%o/0x%x/%d and ends at 0%o/0x%x/%d\n", | |
1176 | vms_initial_buffer, vms_initial_buffer, vms_initial_buffer, | |
1177 | vms_end_brk, vms_end_brk, vms_end_brk); | |
1178 | } | |
1179 | #endif /* defined(emacs) && defined(VMS) */ | |
1180 | ||
1181 | #ifdef VMS | |
1182 | /* Unfortunatelly, the VAX C sbrk() is buggy. For example, it returns | |
1183 | memory in 512 byte chunks (not a bug, but there's more), AND it | |
1184 | adds an extra 512 byte chunk if you ask for a multiple of 512 | |
1185 | bytes (you ask for 512 bytes, you get 1024 bytes...). And also, | |
1186 | the VAX C sbrk does not handle negative increments... | |
1187 | There's a similar problem with brk(). Even if you set the break | |
1188 | to an even page boundary, it gives you one extra page... */ | |
1189 | ||
1190 | static char vms_brk_info_fetched = -1; /* -1 if this is the first time, otherwise | |
1191 | bit 0 set if 'increment' needs adjustment | |
1192 | bit 1 set if the value to brk() needs adjustment */ | |
1193 | static char *vms_brk_start = 0; | |
1194 | static char *vms_brk_end = 0; | |
1195 | static char *vms_brk_current = 0; | |
1196 | #endif | |
1197 | ||
1198 | /* Allocate INCREMENT more bytes of data space, | |
1199 | and return the start of data space, or NULL on errors. | |
1200 | If INCREMENT is negative, shrink data space. */ | |
1201 | __ptr_t | |
1202 | __default_morecore (increment) | |
1203 | ptrdiff_t increment; | |
1204 | { | |
1205 | __ptr_t result; | |
1206 | #ifdef VMS | |
1207 | __ptr_t temp; | |
1208 | ||
1209 | #ifdef RL_DEBUG | |
1210 | printf("DEBUG: morecore: increment = %x\n", increment); | |
1211 | printf(" @ start: vms_brk_info_fetched = %x\n", vms_brk_info_fetched); | |
1212 | printf(" vms_brk_start = %p\n", vms_brk_start); | |
1213 | printf(" vms_brk_current = %p\n", vms_brk_current); | |
1214 | printf(" vms_brk_end = %p\n", vms_brk_end); | |
1215 | printf(" @ end: "); | |
1216 | #endif | |
1217 | ||
1218 | if (vms_brk_info_fetched < 0) | |
1219 | { | |
1220 | vms_brk_current = vms_brk_start = __sbrk (512); | |
1221 | vms_brk_end = __sbrk (0); | |
1222 | if (vms_brk_end - vms_brk_current == 1024) | |
1223 | vms_brk_info_fetched = 1; | |
1224 | else | |
1225 | vms_brk_info_fetched = 0; | |
1226 | vms_brk_end = brk(vms_brk_start); | |
1227 | if (vms_brk_end != vms_brk_start) | |
1228 | vms_brk_info_fetched |= 2; | |
1229 | #ifdef RL_DEBUG | |
1230 | printf("vms_brk_info_fetched = %x\n", vms_brk_info_fetched); | |
1231 | printf(" vms_brk_start = %p\n", vms_brk_start); | |
1232 | printf(" vms_brk_current = %p\n", vms_brk_current); | |
1233 | printf(" vms_brk_end = %p\n", vms_brk_end); | |
1234 | printf(" "); | |
1235 | #endif | |
1236 | } | |
1237 | ||
1238 | if (increment < 0) | |
1239 | { | |
1240 | printf("BZZZZZT! ERROR: __default_morecore does NOT take negative args\n"); | |
1241 | return NULL; | |
1242 | } | |
1243 | ||
1244 | if (increment > 0) | |
1245 | { | |
1246 | result = vms_brk_current; | |
1247 | temp = vms_brk_current + increment; | |
1248 | ||
1249 | if (temp > vms_brk_end) | |
1250 | { | |
1251 | __ptr_t foo; | |
1252 | ||
1253 | foo = __sbrk (0); | |
1254 | if (foo == vms_brk_end) | |
1255 | { | |
1256 | increment = temp - vms_brk_end; | |
1257 | if (increment > (vms_brk_info_fetched & 1)) | |
1258 | increment -= (vms_brk_info_fetched & 1); | |
1259 | foo = __sbrk(increment); | |
1260 | #ifdef RL_DEBUG | |
1261 | printf("__sbrk(%d) --> %p\n", increment, foo); | |
1262 | #endif | |
1263 | if (foo == (__ptr_t) -1) | |
1264 | return NULL; | |
1265 | #ifdef RL_DEBUG | |
1266 | printf(" "); | |
1267 | #endif | |
1268 | } | |
1269 | else | |
1270 | { | |
1271 | result = __sbrk (increment); | |
1272 | ||
1273 | if (result == (__ptr_t) -1) | |
1274 | return NULL; | |
1275 | ||
1276 | temp = result + increment; | |
1277 | } | |
1278 | ||
1279 | vms_brk_end = __sbrk(0); | |
1280 | } | |
1281 | vms_brk_current = temp; | |
1282 | #ifdef RL_DEBUG | |
1283 | printf("vms_brk_current = %p\n", vms_brk_current); | |
1284 | printf(" vms_brk_end = %p\n", vms_brk_end); | |
1285 | #endif | |
1286 | return result; | |
1287 | } | |
1288 | #ifdef RL_DEBUG | |
1289 | printf(" nothing more...\n"); | |
1290 | #endif | |
1291 | ||
1292 | /* OK, so the user wanted to check where the heap limit is. Let's | |
1293 | see if the system thinks it is where we think it is. */ | |
1294 | temp = __sbrk (0); | |
1295 | if (temp != vms_brk_end) | |
1296 | { | |
1297 | /* the value has changed. | |
1298 | Let's trust the system and modify our value */ | |
1299 | vms_brk_current = vms_brk_end = temp; | |
1300 | } | |
1301 | return vms_brk_current; | |
1302 | ||
1303 | #else /* not VMS */ | |
1304 | result = __sbrk ((int) increment); | |
1305 | if (result == (__ptr_t) -1) | |
1306 | return NULL; | |
1307 | return result; | |
1308 | #endif /* VMS */ | |
1309 | } | |
1310 | ||
1311 | __ptr_t | |
1312 | __default_lesscore (ptr, size) | |
1313 | __ptr_t ptr; | |
1314 | ptrdiff_t size; | |
1315 | { | |
1316 | #ifdef VMS | |
1317 | if (vms_brk_end != 0) | |
1318 | { | |
1319 | vms_brk_current = ptr; | |
1320 | if (vms_brk_current < vms_brk_start) | |
1321 | vms_brk_current = vms_brk_start; | |
1322 | vms_brk_end = (char *) vms_brk_current - | |
1323 | ((vms_brk_info_fetched >> 1) & 1); | |
1324 | #ifdef RL_DEBUG | |
1325 | printf("<<<bar... %p (%p (%p, %d))...", | |
1326 | vms_brk_end, vms_brk_current, ptr, size); | |
1327 | #endif | |
1328 | vms_brk_end = __brk (vms_brk_end); | |
1329 | #ifdef RL_DEBUG | |
1330 | printf("foo... %p.\n", vms_brk_end); | |
1331 | #endif | |
1332 | } | |
1333 | ||
1334 | return vms_brk_current; | |
1335 | #else /* not VMS */ | |
1336 | __default_morecore (-size); | |
1337 | #endif | |
1338 | } | |
1339 | ||
1340 | /* Allocate memory on a page boundary. | |
1341 | Copyright (C) 1991, 1992 Free Software Foundation, Inc. | |
1342 | ||
1343 | This library is free software; you can redistribute it and/or | |
1344 | modify it under the terms of the GNU Library General Public License as | |
1345 | published by the Free Software Foundation; either version 2 of the | |
1346 | License, or (at your option) any later version. | |
1347 | ||
1348 | This library is distributed in the hope that it will be useful, | |
1349 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1350 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1351 | Library General Public License for more details. | |
1352 | ||
1353 | You should have received a copy of the GNU Library General Public | |
1354 | License along with this library; see the file COPYING.LIB. If | |
1355 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1356 | Cambridge, MA 02139, USA. | |
1357 | ||
1358 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
1359 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1360 | ||
1361 | #ifndef _MALLOC_INTERNAL | |
1362 | #define _MALLOC_INTERNAL | |
1363 | #include <malloc.h> | |
1364 | #endif | |
1365 | ||
1366 | #if defined (emacs) || defined (HAVE_CONFIG_H) | |
1367 | #include "config.h" | |
1368 | #endif | |
1369 | ||
1370 | #ifdef __GNU_LIBRARY__ | |
1371 | extern size_t __getpagesize __P ((void)); | |
1372 | #else | |
1373 | #if !defined(USG) && !defined(VMS) | |
1374 | extern size_t getpagesize __P ((void)); | |
1375 | #define __getpagesize() getpagesize() | |
1376 | #else | |
1377 | #include <sys/param.h> | |
1378 | #ifdef EXEC_PAGESIZE | |
1379 | #define __getpagesize() EXEC_PAGESIZE | |
1380 | #else /* No EXEC_PAGESIZE. */ | |
1381 | #ifdef NBPG | |
1382 | #ifndef CLSIZE | |
1383 | #define CLSIZE 1 | |
1384 | #endif /* No CLSIZE. */ | |
1385 | #define __getpagesize() (NBPG * CLSIZE) | |
1386 | #else /* No NBPG. */ | |
1387 | #define __getpagesize() NBPC | |
1388 | #endif /* NBPG. */ | |
1389 | #endif /* EXEC_PAGESIZE. */ | |
1390 | #endif /* USG. */ | |
1391 | #endif | |
1392 | ||
1393 | static size_t pagesize; | |
1394 | ||
1395 | __ptr_t | |
1396 | valloc (size) | |
1397 | size_t size; | |
1398 | { | |
1399 | if (pagesize == 0) | |
1400 | pagesize = __getpagesize (); | |
1401 | ||
1402 | return memalign (pagesize, size); | |
1403 | } | |
1404 | /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. | |
1405 | ||
1406 | This library is free software; you can redistribute it and/or | |
1407 | modify it under the terms of the GNU Library General Public License as | |
1408 | published by the Free Software Foundation; either version 2 of the | |
1409 | License, or (at your option) any later version. | |
1410 | ||
1411 | This library is distributed in the hope that it will be useful, | |
1412 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1413 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1414 | Library General Public License for more details. | |
1415 | ||
1416 | You should have received a copy of the GNU Library General Public | |
1417 | License along with this library; see the file COPYING.LIB. If | |
1418 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1419 | Cambridge, MA 02139, USA. */ | |
1420 | ||
1421 | #ifndef _MALLOC_INTERNAL | |
1422 | #define _MALLOC_INTERNAL | |
1423 | #include <malloc.h> | |
1424 | #endif | |
1425 | ||
1426 | __ptr_t | |
1427 | memalign (alignment, size) | |
1428 | size_t alignment; | |
1429 | size_t size; | |
1430 | { | |
1431 | __ptr_t result; | |
1432 | unsigned long int adj; | |
1433 | ||
1434 | size = ((size + alignment - 1) / alignment) * alignment; | |
1435 | ||
1436 | result = malloc (size); | |
1437 | if (result == NULL) | |
1438 | return NULL; | |
1439 | adj = (unsigned long int) ((unsigned long int) ((char *) result - | |
1440 | (char *) NULL)) % alignment; | |
1441 | if (adj != 0) | |
1442 | { | |
1443 | struct alignlist *l; | |
1444 | for (l = _aligned_blocks; l != NULL; l = l->next) | |
1445 | if (l->aligned == NULL) | |
1446 | /* This slot is free. Use it. */ | |
1447 | break; | |
1448 | if (l == NULL) | |
1449 | { | |
1450 | l = (struct alignlist *) malloc (sizeof (struct alignlist)); | |
1451 | if (l == NULL) | |
1452 | { | |
1453 | free (result); | |
1454 | return NULL; | |
1455 | } | |
1456 | } | |
1457 | l->exact = result; | |
1458 | result = l->aligned = (char *) result + alignment - adj; | |
1459 | l->next = _aligned_blocks; | |
1460 | _aligned_blocks = l; | |
1461 | } | |
1462 | ||
1463 | return result; | |
1464 | } | |
1465 | ||
1466 | #ifdef VMS | |
1467 | struct vms_malloc_data | |
1468 | { | |
1469 | int __malloc_initialized; | |
1470 | char *_heapbase; | |
1471 | malloc_info *_heapinfo; | |
1472 | size_t heapsize; | |
1473 | size_t _heapindex; | |
1474 | size_t _heaplimit; | |
1475 | size_t _chunks_used; | |
1476 | size_t _bytes_used; | |
1477 | size_t _chunks_free; | |
1478 | size_t _bytes_free; | |
1479 | } ____vms_malloc_data[] = | |
1480 | { | |
1481 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, | |
1482 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } | |
1483 | }; | |
1484 | ||
1485 | struct vms_core_routines | |
1486 | { | |
1487 | __ptr_t (*__morecore) __P ((ptrdiff_t increment)); | |
1488 | __ptr_t (*__lesscore) __P ((__ptr_t address, ptrdiff_t increment)); | |
1489 | } ____vms_core_routines[] = | |
1490 | { | |
1491 | { __vms_initial_morecore, __vms_initial_lesscore }, | |
1492 | { __default_morecore, __default_lesscore }, | |
1493 | { 0, 0 } | |
1494 | }; | |
1495 | ||
1496 | static int current_vms_data = -1; | |
1497 | static int current_vms_core_routines = 0; | |
1498 | ||
1499 | static void use_vms_core_routines (int i) | |
1500 | { | |
1501 | current_vms_core_routines = i; | |
1502 | current_vms_data = i; | |
1503 | } | |
1504 | ||
1505 | static void use_vms_data (int i) | |
1506 | { | |
1507 | use_vms_core_routines (i); | |
1508 | __malloc_initialized = ____vms_malloc_data[i].__malloc_initialized; | |
1509 | _heapbase = ____vms_malloc_data[i]._heapbase; | |
1510 | _heapinfo = ____vms_malloc_data[i]._heapinfo; | |
1511 | heapsize = ____vms_malloc_data[i].heapsize; | |
1512 | _heapindex = ____vms_malloc_data[i]._heapindex; | |
1513 | _heaplimit = ____vms_malloc_data[i]._heaplimit; | |
1514 | _chunks_used = ____vms_malloc_data[i]._chunks_used; | |
1515 | _bytes_used = ____vms_malloc_data[i]._bytes_used; | |
1516 | _chunks_free = ____vms_malloc_data[i]._chunks_free; | |
1517 | _bytes_free = ____vms_malloc_data[i]._bytes_free; | |
1518 | } | |
1519 | ||
1520 | static void store_vms_data (int i) | |
1521 | { | |
1522 | ____vms_malloc_data[i].__malloc_initialized = __malloc_initialized; | |
1523 | ____vms_malloc_data[i]._heapbase = _heapbase; | |
1524 | ____vms_malloc_data[i]._heapinfo = _heapinfo; | |
1525 | ____vms_malloc_data[i].heapsize = heapsize; | |
1526 | ____vms_malloc_data[i]._heapindex = _heapindex; | |
1527 | ____vms_malloc_data[i]._heaplimit = _heaplimit; | |
1528 | ____vms_malloc_data[i]._chunks_used = _chunks_used; | |
1529 | ____vms_malloc_data[i]._bytes_used = _bytes_used; | |
1530 | ____vms_malloc_data[i]._chunks_free = _chunks_free; | |
1531 | ____vms_malloc_data[i]._bytes_free = _bytes_free; | |
1532 | } | |
1533 | ||
1534 | static void store_current_vms_data () | |
1535 | { | |
1536 | switch (current_vms_data) | |
1537 | { | |
1538 | case 0: | |
1539 | case 1: | |
1540 | store_vms_data (current_vms_data); | |
1541 | break; | |
1542 | } | |
1543 | } | |
1544 | ||
1545 | __ptr_t __vms_morecore (increment) | |
1546 | ptrdiff_t increment; | |
1547 | { | |
1548 | return | |
1549 | (*____vms_core_routines[current_vms_core_routines].__morecore) (increment); | |
1550 | } | |
1551 | ||
1552 | __ptr_t __vms_lesscore (ptr, increment) | |
1553 | __ptr_t ptr; | |
1554 | ptrdiff_t increment; | |
1555 | { | |
1556 | return | |
1557 | (*____vms_core_routines[current_vms_core_routines].__lesscore) (ptr,increment); | |
1558 | } | |
1559 | ||
1560 | __ptr_t __vms_malloc (size) | |
1561 | size_t size; | |
1562 | { | |
1563 | __ptr_t result; | |
1564 | int old_current_vms_data = current_vms_data; | |
1565 | ||
1566 | __malloc_hook = 0; | |
1567 | ||
1568 | store_current_vms_data (); | |
1569 | ||
1570 | if (____vms_malloc_data[0]._heapbase != 0) | |
1571 | use_vms_data (0); | |
1572 | else | |
1573 | use_vms_core_routines (0); | |
1574 | result = malloc (size); | |
1575 | store_vms_data (0); | |
1576 | if (result == NULL) | |
1577 | { | |
1578 | use_vms_data (1); | |
1579 | result = malloc (size); | |
1580 | store_vms_data (1); | |
1581 | vms_out_initial = 1; | |
1582 | } | |
1583 | __malloc_hook = __vms_malloc; | |
1584 | if (old_current_vms_data != -1) | |
1585 | use_vms_data (current_vms_data); | |
1586 | return result; | |
1587 | } | |
1588 | ||
1589 | void __vms_free (ptr) | |
1590 | __ptr_t ptr; | |
1591 | { | |
1592 | int old_current_vms_data = current_vms_data; | |
1593 | ||
1594 | __free_hook = 0; | |
1595 | ||
1596 | store_current_vms_data (); | |
1597 | ||
1598 | if (ptr >= vms_initial_buffer && ptr <= vms_end_brk) | |
1599 | { | |
1600 | use_vms_data (0); | |
1601 | free (ptr); | |
1602 | store_vms_data (0); | |
1603 | } | |
1604 | else | |
1605 | { | |
1606 | use_vms_data (1); | |
1607 | free (ptr); | |
1608 | store_vms_data (1); | |
1609 | if (_chunks_free == 0 && _chunks_used == 0) | |
1610 | vms_out_initial = 0; | |
1611 | } | |
1612 | __free_hook = __vms_free; | |
1613 | if (old_current_vms_data != -1) | |
1614 | use_vms_data (current_vms_data); | |
1615 | } | |
1616 | ||
1617 | __ptr_t __vms_realloc (ptr, size) | |
1618 | __ptr_t ptr; | |
1619 | size_t size; | |
1620 | { | |
1621 | __ptr_t result; | |
1622 | int old_current_vms_data = current_vms_data; | |
1623 | ||
1624 | __realloc_hook = 0; | |
1625 | ||
1626 | store_current_vms_data (); | |
1627 | ||
1628 | if (ptr >= vms_initial_buffer && ptr <= vms_end_brk) | |
1629 | { | |
1630 | use_vms_data (0); | |
1631 | result = realloc (ptr, size); | |
1632 | store_vms_data (0); | |
1633 | } | |
1634 | else | |
1635 | { | |
1636 | use_vms_data (1); | |
1637 | result = realloc (ptr, size); | |
1638 | store_vms_data (1); | |
1639 | } | |
1640 | __realloc_hook = __vms_realloc; | |
1641 | if (old_current_vms_data != -1) | |
1642 | use_vms_data (current_vms_data); | |
1643 | return result; | |
1644 | } | |
1645 | #endif /* VMS */ | |
1646 | /* Standard debugging hooks for `malloc'. | |
1647 | Copyright 1990, 1991, 1992 Free Software Foundation | |
1648 | Written May 1989 by Mike Haertel. | |
1649 | ||
1650 | This library is free software; you can redistribute it and/or | |
1651 | modify it under the terms of the GNU Library General Public License as | |
1652 | published by the Free Software Foundation; either version 2 of the | |
1653 | License, or (at your option) any later version. | |
1654 | ||
1655 | This library is distributed in the hope that it will be useful, | |
1656 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1657 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1658 | Library General Public License for more details. | |
1659 | ||
1660 | You should have received a copy of the GNU Library General Public | |
1661 | License along with this library; see the file COPYING.LIB. If | |
1662 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1663 | Cambridge, MA 02139, USA. | |
1664 | ||
1665 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
1666 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1667 | ||
1668 | #ifndef _MALLOC_INTERNAL | |
1669 | #define _MALLOC_INTERNAL | |
1670 | #include <malloc.h> | |
1671 | #endif | |
1672 | ||
1673 | /* Old hook values. */ | |
1674 | static void (*old_free_hook) __P ((__ptr_t ptr)); | |
1675 | static __ptr_t (*old_malloc_hook) __P ((size_t size)); | |
1676 | static __ptr_t (*old_realloc_hook) __P ((__ptr_t ptr, size_t size)); | |
1677 | ||
1678 | /* Function to call when something awful happens. */ | |
1679 | static void (*abortfunc) __P ((void)); | |
1680 | ||
1681 | /* Arbitrary magical numbers. */ | |
1682 | #define MAGICWORD 0xfedabeeb | |
1683 | #define MAGICBYTE ((char) 0xd7) | |
1684 | ||
1685 | struct hdr | |
1686 | { | |
1687 | size_t size; /* Exact size requested by user. */ | |
1688 | unsigned long int magic; /* Magic number to check header integrity. */ | |
1689 | }; | |
1690 | ||
1691 | static void checkhdr __P ((__const struct hdr *)); | |
1692 | static void | |
1693 | checkhdr (hdr) | |
1694 | __const struct hdr *hdr; | |
1695 | { | |
1696 | if (hdr->magic != MAGICWORD || ((char *) &hdr[1])[hdr->size] != MAGICBYTE) | |
1697 | (*abortfunc) (); | |
1698 | } | |
1699 | ||
1700 | static void freehook __P ((__ptr_t)); | |
1701 | static void | |
1702 | freehook (ptr) | |
1703 | __ptr_t ptr; | |
1704 | { | |
1705 | struct hdr *hdr = ((struct hdr *) ptr) - 1; | |
1706 | checkhdr (hdr); | |
1707 | hdr->magic = 0; | |
1708 | __free_hook = old_free_hook; | |
1709 | free (hdr); | |
1710 | __free_hook = freehook; | |
1711 | } | |
1712 | ||
1713 | static __ptr_t mallochook __P ((size_t)); | |
1714 | static __ptr_t | |
1715 | mallochook (size) | |
1716 | size_t size; | |
1717 | { | |
1718 | struct hdr *hdr; | |
1719 | ||
1720 | __malloc_hook = old_malloc_hook; | |
1721 | hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1); | |
1722 | __malloc_hook = mallochook; | |
1723 | if (hdr == NULL) | |
1724 | return NULL; | |
1725 | ||
1726 | hdr->size = size; | |
1727 | hdr->magic = MAGICWORD; | |
1728 | ((char *) &hdr[1])[size] = MAGICBYTE; | |
1729 | return (__ptr_t) (hdr + 1); | |
1730 | } | |
1731 | ||
1732 | static __ptr_t reallochook __P ((__ptr_t, size_t)); | |
1733 | static __ptr_t | |
1734 | reallochook (ptr, size) | |
1735 | __ptr_t ptr; | |
1736 | size_t size; | |
1737 | { | |
1738 | struct hdr *hdr = ((struct hdr *) ptr) - 1; | |
1739 | ||
1740 | checkhdr (hdr); | |
1741 | __free_hook = old_free_hook; | |
1742 | __malloc_hook = old_malloc_hook; | |
1743 | __realloc_hook = old_realloc_hook; | |
1744 | hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1); | |
1745 | __free_hook = freehook; | |
1746 | __malloc_hook = mallochook; | |
1747 | __realloc_hook = reallochook; | |
1748 | if (hdr == NULL) | |
1749 | return NULL; | |
1750 | ||
1751 | hdr->size = size; | |
1752 | ((char *) &hdr[1])[size] = MAGICBYTE; | |
1753 | return (__ptr_t) (hdr + 1); | |
1754 | } | |
1755 | ||
1756 | int | |
1757 | mcheck (func) | |
1758 | void (*func) __P ((void)); | |
1759 | { | |
1760 | extern void abort __P ((void)); | |
1761 | static int mcheck_used = 0; | |
1762 | ||
1763 | abortfunc = (func != NULL) ? func : abort; | |
1764 | ||
1765 | /* These hooks may not be safely inserted if malloc is already in use. */ | |
1766 | if (!__malloc_initialized && !mcheck_used) | |
1767 | { | |
1768 | old_free_hook = __free_hook; | |
1769 | __free_hook = freehook; | |
1770 | old_malloc_hook = __malloc_hook; | |
1771 | __malloc_hook = mallochook; | |
1772 | old_realloc_hook = __realloc_hook; | |
1773 | __realloc_hook = reallochook; | |
1774 | mcheck_used = 1; | |
1775 | } | |
1776 | ||
1777 | return mcheck_used ? 0 : -1; | |
1778 | } | |
1779 | /* More debugging hooks for `malloc'. | |
1780 | Copyright (C) 1991, 1992 Free Software Foundation, Inc. | |
1781 | Written April 2, 1991 by John Gilmore of Cygnus Support. | |
1782 | Based on mcheck.c by Mike Haertel. | |
1783 | ||
1784 | This library is free software; you can redistribute it and/or | |
1785 | modify it under the terms of the GNU Library General Public License as | |
1786 | published by the Free Software Foundation; either version 2 of the | |
1787 | License, or (at your option) any later version. | |
1788 | ||
1789 | This library is distributed in the hope that it will be useful, | |
1790 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1791 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1792 | Library General Public License for more details. | |
1793 | ||
1794 | You should have received a copy of the GNU Library General Public | |
1795 | License along with this library; see the file COPYING.LIB. If | |
1796 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1797 | Cambridge, MA 02139, USA. | |
1798 | ||
1799 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
1800 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1801 | ||
1802 | #ifndef _MALLOC_INTERNAL | |
1803 | #define _MALLOC_INTERNAL | |
1804 | #include <malloc.h> | |
1805 | #endif | |
1806 | ||
1807 | #include <stdio.h> | |
1808 | ||
1809 | #ifndef __GNU_LIBRARY__ | |
1810 | extern char *getenv (); | |
1811 | #else | |
1812 | #include <stdlib.h> | |
1813 | #endif | |
1814 | ||
1815 | static FILE *mallstream; | |
1816 | static char mallenv[]= "MALLOC_TRACE"; | |
1817 | static char mallbuf[BUFSIZ]; /* Buffer for the output. */ | |
1818 | ||
1819 | /* Address to breakpoint on accesses to... */ | |
1820 | __ptr_t mallwatch; | |
1821 | ||
1822 | /* Old hook values. */ | |
1823 | static __ptr_t (*tr_old_morecore) __P ((ptrdiff_t increment)); | |
1824 | static __ptr_t (*tr_old_lesscore) __P ((__ptr_t ptr, ptrdiff_t increment)); | |
1825 | static void (*tr_old_free_hook) __P ((__ptr_t ptr)); | |
1826 | static __ptr_t (*tr_old_malloc_hook) __P ((size_t size)); | |
1827 | static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr, size_t size)); | |
1828 | ||
1829 | /* This function is called when the block being alloc'd, realloc'd, or | |
1830 | freed has an address matching the variable "mallwatch". In a debugger, | |
1831 | set "mallwatch" to the address of interest, then put a breakpoint on | |
1832 | tr_break. */ | |
1833 | ||
1834 | void tr_break __P ((void)); | |
1835 | void | |
1836 | tr_break () | |
1837 | { | |
1838 | } | |
1839 | ||
1840 | static void tr_freehook __P ((__ptr_t)); | |
1841 | static void | |
1842 | tr_freehook (ptr) | |
1843 | __ptr_t ptr; | |
1844 | { | |
1845 | fprintf (mallstream, "- %p\n", ptr); /* Be sure to print it first. */ | |
1846 | if (ptr == mallwatch) | |
1847 | tr_break (); | |
1848 | __free_hook = tr_old_free_hook; | |
1849 | free (ptr); | |
1850 | __free_hook = tr_freehook; | |
1851 | } | |
1852 | ||
1853 | static __ptr_t tr_morecore __P ((ptrdiff_t)); | |
1854 | static __ptr_t | |
1855 | tr_morecore (increment) | |
1856 | ptrdiff_t increment; | |
1857 | { | |
1858 | __ptr_t p; | |
1859 | ||
1860 | __morecore = tr_old_morecore; | |
1861 | p = (__ptr_t) (*__morecore) (increment); | |
1862 | __morecore = tr_morecore; | |
1863 | ||
1864 | fprintf (mallstream, "$ %p %d\n", p, increment); | |
1865 | ||
1866 | return p; | |
1867 | } | |
1868 | ||
1869 | static __ptr_t tr_lesscore __P ((__ptr_t, ptrdiff_t)); | |
1870 | static __ptr_t | |
1871 | tr_lesscore (ptr, increment) | |
1872 | __ptr_t ptr; | |
1873 | ptrdiff_t increment; | |
1874 | { | |
1875 | __ptr_t p; | |
1876 | ||
1877 | __lesscore = tr_old_lesscore; | |
1878 | p = (__ptr_t) (*__lesscore) (ptr, increment); | |
1879 | __lesscore = tr_lesscore; | |
1880 | ||
1881 | fprintf (mallstream, "* %p (%p, %d)\n", p, ptr, increment); | |
1882 | ||
1883 | return p; | |
1884 | } | |
1885 | ||
1886 | static __ptr_t tr_mallochook __P ((size_t)); | |
1887 | static __ptr_t | |
1888 | tr_mallochook (size) | |
1889 | size_t size; | |
1890 | { | |
1891 | __ptr_t hdr; | |
1892 | ||
1893 | __malloc_hook = tr_old_malloc_hook; | |
1894 | hdr = (__ptr_t) malloc (size); | |
1895 | __malloc_hook = tr_mallochook; | |
1896 | ||
1897 | /* We could be printing a NULL here; that's OK. */ | |
1898 | fprintf (mallstream, "+ %p %x\n", hdr, size); | |
1899 | ||
1900 | if (hdr == mallwatch) | |
1901 | tr_break (); | |
1902 | ||
1903 | return hdr; | |
1904 | } | |
1905 | ||
1906 | static __ptr_t tr_reallochook __P ((__ptr_t, size_t)); | |
1907 | static __ptr_t | |
1908 | tr_reallochook (ptr, size) | |
1909 | __ptr_t ptr; | |
1910 | size_t size; | |
1911 | { | |
1912 | __ptr_t hdr; | |
1913 | ||
1914 | if (ptr == mallwatch) | |
1915 | tr_break (); | |
1916 | ||
1917 | __free_hook = tr_old_free_hook; | |
1918 | __malloc_hook = tr_old_malloc_hook; | |
1919 | __realloc_hook = tr_old_realloc_hook; | |
1920 | hdr = (__ptr_t) realloc (ptr, size); | |
1921 | __free_hook = tr_freehook; | |
1922 | __malloc_hook = tr_mallochook; | |
1923 | __realloc_hook = tr_reallochook; | |
1924 | if (hdr == NULL) | |
1925 | /* Failed realloc. */ | |
1926 | fprintf (mallstream, "! %p %x\n", ptr, size); | |
1927 | else | |
1928 | fprintf (mallstream, "< %p\n> %p %x\n", ptr, hdr, size); | |
1929 | ||
1930 | if (hdr == mallwatch) | |
1931 | tr_break (); | |
1932 | ||
1933 | return hdr; | |
1934 | } | |
1935 | ||
1936 | /* We enable tracing if either the environment variable MALLOC_TRACE | |
1937 | is set, or if the variable mallwatch has been patched to an address | |
1938 | that the debugging user wants us to stop on. When patching mallwatch, | |
1939 | don't forget to set a breakpoint on tr_break! */ | |
1940 | ||
1941 | void | |
1942 | mtrace () | |
1943 | { | |
1944 | char *mallfile; | |
1945 | ||
1946 | mallfile = getenv (mallenv); | |
1947 | if (mallfile != NULL || mallwatch != NULL) | |
1948 | { | |
1949 | mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w"); | |
1950 | if (mallstream != NULL) | |
1951 | { | |
1952 | /* Be sure it doesn't malloc its buffer! */ | |
1953 | setbuf (mallstream, mallbuf); | |
1954 | fprintf (mallstream, "= Start\n"); | |
1955 | #if defined(emacs) && defined(VMS) | |
1956 | fprintf (mallstream, "= Initial buffer spans %p -- %p\n", | |
1957 | vms_initial_buffer, vms_end_brk + 1); | |
1958 | #endif | |
1959 | tr_old_morecore = __morecore; | |
1960 | __morecore = tr_morecore; | |
1961 | tr_old_lesscore = __lesscore; | |
1962 | __lesscore = tr_lesscore; | |
1963 | tr_old_free_hook = __free_hook; | |
1964 | __free_hook = tr_freehook; | |
1965 | tr_old_malloc_hook = __malloc_hook; | |
1966 | __malloc_hook = tr_mallochook; | |
1967 | tr_old_realloc_hook = __realloc_hook; | |
1968 | __realloc_hook = tr_reallochook; | |
1969 | } | |
1970 | } | |
1971 | } | |
1972 | /* Access the statistics maintained by `malloc'. | |
1973 | Copyright 1990, 1991, 1992 Free Software Foundation | |
1974 | Written May 1989 by Mike Haertel. | |
1975 | ||
1976 | This library is free software; you can redistribute it and/or | |
1977 | modify it under the terms of the GNU Library General Public License as | |
1978 | published by the Free Software Foundation; either version 2 of the | |
1979 | License, or (at your option) any later version. | |
1980 | ||
1981 | This library is distributed in the hope that it will be useful, | |
1982 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1983 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
1984 | Library General Public License for more details. | |
1985 | ||
1986 | You should have received a copy of the GNU Library General Public | |
1987 | License along with this library; see the file COPYING.LIB. If | |
1988 | not, write to the Free Software Foundation, Inc., 675 Mass Ave, | |
1989 | Cambridge, MA 02139, USA. | |
1990 | ||
1991 | The author may be reached (Email) at the address mike@ai.mit.edu, | |
1992 | or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1993 | ||
1994 | #ifndef _MALLOC_INTERNAL | |
1995 | #define _MALLOC_INTERNAL | |
1996 | #include <malloc.h> | |
1997 | #endif | |
1998 | ||
1999 | struct mstats | |
2000 | mstats () | |
2001 | { | |
2002 | struct mstats result; | |
2003 | ||
2004 | result.bytes_total = (char *) (*__morecore) (0) - _heapbase; | |
2005 | result.chunks_used = _chunks_used; | |
2006 | result.bytes_used = _bytes_used; | |
2007 | result.chunks_free = _chunks_free; | |
2008 | result.bytes_free = _bytes_free; | |
2009 | return result; | |
2010 | } |