1 /* This file is no longer automatically generated from libc. */
3 #define _MALLOC_INTERNAL
5 /* The malloc headers and source files from the C library follow here. */
7 /* Declarations for `malloc' and friends.
8 Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004,
9 2005, 2006, 2007 Free Software Foundation, Inc.
10 Written May 1989 by Mike Haertel.
12 This library is free software; you can redistribute it and/or
13 modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation; either version 2 of the
15 License, or (at your option) any later version.
17 This library is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU General Public
23 License along with this library; see the file COPYING. If
24 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
25 Fifth Floor, Boston, MA 02110-1301, USA.
27 The author may be reached (Email) at the address mike@ai.mit.edu,
28 or (US mail) as Mike Haertel c/o Free Software Foundation. */
34 #ifdef _MALLOC_INTERNAL
40 #ifdef HAVE_GTK_AND_PTHREAD
44 #if ((defined __cplusplus || (defined (__STDC__) && __STDC__) \
45 || defined STDC_HEADERS || defined PROTOTYPES) \
46 && ! defined (BROKEN_PROTOTYPES))
50 #define __ptr_t void *
51 #else /* Not C++ or ANSI C. */
55 #define __ptr_t char *
56 #endif /* C++ or ANSI C. */
58 #if defined(_LIBC) || defined(STDC_HEADERS) || defined(USG)
62 #define memset(s, zero, n) bzero ((s), (n))
65 #define memcpy(d, s, n) bcopy ((s), (d), (n))
84 #endif /* _MALLOC_INTERNAL. */
94 #define __malloc_size_t size_t
95 #define __malloc_ptrdiff_t ptrdiff_t
100 #define __malloc_size_t __SIZE_TYPE__
103 #ifndef __malloc_size_t
104 #define __malloc_size_t unsigned int
106 #define __malloc_ptrdiff_t int
113 #ifndef FREE_RETURN_TYPE
114 #define FREE_RETURN_TYPE void
118 /* Allocate SIZE bytes of memory. */
119 extern __ptr_t malloc
PP ((__malloc_size_t __size
));
120 /* Re-allocate the previously allocated block
121 in __ptr_t, making the new block SIZE bytes long. */
122 extern __ptr_t realloc
PP ((__ptr_t __ptr
, __malloc_size_t __size
));
123 /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */
124 extern __ptr_t calloc
PP ((__malloc_size_t __nmemb
, __malloc_size_t __size
));
125 /* Free a block allocated by `malloc', `realloc' or `calloc'. */
126 extern FREE_RETURN_TYPE free
PP ((__ptr_t __ptr
));
128 /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */
129 #if ! (defined (_MALLOC_INTERNAL) && __DJGPP__ - 0 == 1) /* Avoid conflict. */
130 extern __ptr_t memalign
PP ((__malloc_size_t __alignment
,
131 __malloc_size_t __size
));
134 /* Allocate SIZE bytes on a page boundary. */
135 #if ! (defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC))
136 extern __ptr_t valloc
PP ((__malloc_size_t __size
));
140 #ifdef _MALLOC_INTERNAL
142 /* The allocator divides the heap into blocks of fixed size; large
143 requests receive one or more whole blocks, and small requests
144 receive a fragment of a block. Fragment sizes are powers of two,
145 and all fragments of a block are the same size. When all the
146 fragments in a block have been freed, the block itself is freed. */
147 #define INT_BIT (CHAR_BIT * sizeof(int))
148 #define BLOCKLOG (INT_BIT > 16 ? 12 : 9)
149 #define BLOCKSIZE (1 << BLOCKLOG)
150 #define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE)
152 /* Determine the amount of memory spanned by the initial heap table
153 (not an absolute limit). */
154 #define HEAP (INT_BIT > 16 ? 4194304 : 65536)
156 /* Number of contiguous free blocks allowed to build up at the end of
157 memory before they will be returned to the system. */
158 #define FINAL_FREE_BLOCKS 8
160 /* Data structure giving per-block information. */
163 /* Heap information for a busy block. */
166 /* Zero for a large (multiblock) object, or positive giving the
167 logarithm to the base two of the fragment size. */
173 __malloc_size_t nfree
; /* Free frags in a fragmented block. */
174 __malloc_size_t first
; /* First free fragment of the block. */
176 /* For a large object, in its first block, this has the number
177 of blocks in the object. In the other blocks, this has a
178 negative number which says how far back the first block is. */
179 __malloc_ptrdiff_t size
;
182 /* Heap information for a free block
183 (that may be the first of a free cluster). */
186 __malloc_size_t size
; /* Size (in blocks) of a free cluster. */
187 __malloc_size_t next
; /* Index of next free cluster. */
188 __malloc_size_t prev
; /* Index of previous free cluster. */
192 /* Pointer to first block of the heap. */
193 extern char *_heapbase
;
195 /* Table indexed by block number giving per-block information. */
196 extern malloc_info
*_heapinfo
;
198 /* Address to block number and vice versa. */
199 #define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
200 #define ADDRESS(B) ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase))
202 /* Current search index for the heap table. */
203 extern __malloc_size_t _heapindex
;
205 /* Limit of valid info table indices. */
206 extern __malloc_size_t _heaplimit
;
208 /* Doubly linked lists of free fragments. */
215 /* Free list headers for each fragment size. */
216 extern struct list _fraghead
[];
218 /* List of blocks allocated with `memalign' (or `valloc'). */
221 struct alignlist
*next
;
222 __ptr_t aligned
; /* The address that memaligned returned. */
223 __ptr_t exact
; /* The address that malloc returned. */
225 extern struct alignlist
*_aligned_blocks
;
227 /* Instrumentation. */
228 extern __malloc_size_t _chunks_used
;
229 extern __malloc_size_t _bytes_used
;
230 extern __malloc_size_t _chunks_free
;
231 extern __malloc_size_t _bytes_free
;
233 /* Internal versions of `malloc', `realloc', and `free'
234 used when these functions need to call each other.
235 They are the same but don't call the hooks. */
236 extern __ptr_t _malloc_internal
PP ((__malloc_size_t __size
));
237 extern __ptr_t _realloc_internal
PP ((__ptr_t __ptr
, __malloc_size_t __size
));
238 extern void _free_internal
PP ((__ptr_t __ptr
));
239 extern __ptr_t _malloc_internal_nolock
PP ((__malloc_size_t __size
));
240 extern __ptr_t _realloc_internal_nolock
PP ((__ptr_t __ptr
, __malloc_size_t __size
));
241 extern void _free_internal_nolock
PP ((__ptr_t __ptr
));
244 extern pthread_mutex_t _malloc_mutex
, _aligned_blocks_mutex
;
245 #define LOCK() pthread_mutex_lock (&_malloc_mutex)
246 #define UNLOCK() pthread_mutex_unlock (&_malloc_mutex)
247 #define LOCK_ALIGNED_BLOCKS() pthread_mutex_lock (&_aligned_blocks_mutex)
248 #define UNLOCK_ALIGNED_BLOCKS() pthread_mutex_unlock (&_aligned_blocks_mutex)
252 #define LOCK_ALIGNED_BLOCKS()
253 #define UNLOCK_ALIGNED_BLOCKS()
256 #endif /* _MALLOC_INTERNAL. */
258 /* Given an address in the middle of a malloc'd object,
259 return the address of the beginning of the object. */
260 extern __ptr_t malloc_find_object_address
PP ((__ptr_t __ptr
));
262 /* Underlying allocation function; successive calls should
263 return contiguous pieces of memory. */
264 extern __ptr_t (*__morecore
) PP ((__malloc_ptrdiff_t __size
));
266 /* Default value of `__morecore'. */
267 extern __ptr_t __default_morecore
PP ((__malloc_ptrdiff_t __size
));
269 /* If not NULL, this function is called after each time
270 `__morecore' is called to increase the data size. */
271 extern void (*__after_morecore_hook
) PP ((void));
273 /* Number of extra blocks to get each time we ask for more core.
274 This reduces the frequency of calling `(*__morecore)'. */
275 extern __malloc_size_t __malloc_extra_blocks
;
277 /* Nonzero if `malloc' has been called and done its initialization. */
278 extern int __malloc_initialized
;
279 /* Function called to initialize malloc data structures. */
280 extern int __malloc_initialize
PP ((void));
282 /* Hooks for debugging versions. */
283 extern void (*__malloc_initialize_hook
) PP ((void));
284 extern void (*__free_hook
) PP ((__ptr_t __ptr
));
285 extern __ptr_t (*__malloc_hook
) PP ((__malloc_size_t __size
));
286 extern __ptr_t (*__realloc_hook
) PP ((__ptr_t __ptr
, __malloc_size_t __size
));
287 extern __ptr_t (*__memalign_hook
) PP ((__malloc_size_t __size
,
288 __malloc_size_t __alignment
));
290 /* Return values for `mprobe': these are the kinds of inconsistencies that
291 `mcheck' enables detection of. */
294 MCHECK_DISABLED
= -1, /* Consistency checking is not turned on. */
295 MCHECK_OK
, /* Block is fine. */
296 MCHECK_FREE
, /* Block freed twice. */
297 MCHECK_HEAD
, /* Memory before the block was clobbered. */
298 MCHECK_TAIL
/* Memory after the block was clobbered. */
301 /* Activate a standard collection of debugging hooks. This must be called
302 before `malloc' is ever called. ABORTFUNC is called with an error code
303 (see enum above) when an inconsistency is detected. If ABORTFUNC is
304 null, the standard function prints on stderr and then calls `abort'. */
305 extern int mcheck
PP ((void (*__abortfunc
) PP ((enum mcheck_status
))));
307 /* Check for aberrations in a particular malloc'd block. You must have
308 called `mcheck' already. These are the same checks that `mcheck' does
309 when you free or reallocate a block. */
310 extern enum mcheck_status mprobe
PP ((__ptr_t __ptr
));
312 /* Activate a standard collection of tracing hooks. */
313 extern void mtrace
PP ((void));
314 extern void muntrace
PP ((void));
316 /* Statistics available to the user. */
319 __malloc_size_t bytes_total
; /* Total size of the heap. */
320 __malloc_size_t chunks_used
; /* Chunks allocated by the user. */
321 __malloc_size_t bytes_used
; /* Byte total of user-allocated chunks. */
322 __malloc_size_t chunks_free
; /* Chunks in the free list. */
323 __malloc_size_t bytes_free
; /* Byte total of chunks in the free list. */
326 /* Pick up the current statistics. */
327 extern struct mstats mstats
PP ((void));
329 /* Call WARNFUN with a warning message when memory usage is high. */
330 extern void memory_warnings
PP ((__ptr_t __start
,
331 void (*__warnfun
) PP ((const char *))));
334 /* Relocating allocator. */
336 /* Allocate SIZE bytes, and store the address in *HANDLEPTR. */
337 extern __ptr_t r_alloc
PP ((__ptr_t
*__handleptr
, __malloc_size_t __size
));
339 /* Free the storage allocated in HANDLEPTR. */
340 extern void r_alloc_free
PP ((__ptr_t
*__handleptr
));
342 /* Adjust the block at HANDLEPTR to be SIZE bytes long. */
343 extern __ptr_t r_re_alloc
PP ((__ptr_t
*__handleptr
, __malloc_size_t __size
));
350 #endif /* malloc.h */
351 /* Memory allocator `malloc'.
352 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
353 Written May 1989 by Mike Haertel.
355 This library is free software; you can redistribute it and/or
356 modify it under the terms of the GNU General Public License as
357 published by the Free Software Foundation; either version 2 of the
358 License, or (at your option) any later version.
360 This library is distributed in the hope that it will be useful,
361 but WITHOUT ANY WARRANTY; without even the implied warranty of
362 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
363 General Public License for more details.
365 You should have received a copy of the GNU General Public
366 License along with this library; see the file COPYING. If
367 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
368 Fifth Floor, Boston, MA 02110-1301, USA.
370 The author may be reached (Email) at the address mike@ai.mit.edu,
371 or (US mail) as Mike Haertel c/o Free Software Foundation. */
373 #ifndef _MALLOC_INTERNAL
374 #define _MALLOC_INTERNAL
379 /* How to really get more memory. */
381 extern __ptr_t bss_sbrk
PP ((ptrdiff_t __size
));
382 extern int bss_sbrk_did_unexec
;
384 __ptr_t (*__morecore
) PP ((__malloc_ptrdiff_t __size
)) = __default_morecore
;
386 /* Debugging hook for `malloc'. */
387 __ptr_t (*__malloc_hook
) PP ((__malloc_size_t __size
));
389 /* Pointer to the base of the first block. */
392 /* Block information table. Allocated with align/__free (not malloc/free). */
393 malloc_info
*_heapinfo
;
395 /* Number of info entries. */
396 static __malloc_size_t heapsize
;
398 /* Search index in the info table. */
399 __malloc_size_t _heapindex
;
401 /* Limit of valid info table indices. */
402 __malloc_size_t _heaplimit
;
404 /* Free lists for each fragment size. */
405 struct list _fraghead
[BLOCKLOG
];
407 /* Instrumentation. */
408 __malloc_size_t _chunks_used
;
409 __malloc_size_t _bytes_used
;
410 __malloc_size_t _chunks_free
;
411 __malloc_size_t _bytes_free
;
413 /* Are you experienced? */
414 int __malloc_initialized
;
416 __malloc_size_t __malloc_extra_blocks
;
418 void (*__malloc_initialize_hook
) PP ((void));
419 void (*__after_morecore_hook
) PP ((void));
421 #if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE
423 /* Some code for hunting a bug writing into _heapinfo.
425 Call this macro with argument PROT non-zero to protect internal
426 malloc state against writing to it, call it with a zero argument to
427 make it readable and writable.
429 Note that this only works if BLOCKSIZE == page size, which is
430 the case on the i386. */
432 #include <sys/types.h>
433 #include <sys/mman.h>
435 static int state_protected_p
;
436 static __malloc_size_t last_state_size
;
437 static malloc_info
*last_heapinfo
;
440 protect_malloc_state (protect_p
)
443 /* If _heapinfo has been relocated, make sure its old location
444 isn't left read-only; it will be reused by malloc. */
445 if (_heapinfo
!= last_heapinfo
447 && state_protected_p
)
448 mprotect (last_heapinfo
, last_state_size
, PROT_READ
| PROT_WRITE
);
450 last_state_size
= _heaplimit
* sizeof *_heapinfo
;
451 last_heapinfo
= _heapinfo
;
453 if (protect_p
!= state_protected_p
)
455 state_protected_p
= protect_p
;
456 if (mprotect (_heapinfo
, last_state_size
,
457 protect_p
? PROT_READ
: PROT_READ
| PROT_WRITE
) != 0)
462 #define PROTECT_MALLOC_STATE(PROT) protect_malloc_state(PROT)
465 #define PROTECT_MALLOC_STATE(PROT) /* empty */
469 /* Aligned allocation. */
470 static __ptr_t align
PP ((__malloc_size_t
));
473 __malloc_size_t size
;
476 unsigned long int adj
;
478 /* align accepts an unsigned argument, but __morecore accepts a
479 signed one. This could lead to trouble if SIZE overflows a
480 signed int type accepted by __morecore. We just punt in that
481 case, since they are requesting a ludicrous amount anyway. */
482 if ((__malloc_ptrdiff_t
)size
< 0)
485 result
= (*__morecore
) (size
);
486 adj
= (unsigned long int) ((unsigned long int) ((char *) result
-
487 (char *) NULL
)) % BLOCKSIZE
;
491 adj
= BLOCKSIZE
- adj
;
492 new = (*__morecore
) (adj
);
493 result
= (char *) result
+ adj
;
496 if (__after_morecore_hook
)
497 (*__after_morecore_hook
) ();
502 /* Get SIZE bytes, if we can get them starting at END.
503 Return the address of the space we got.
504 If we cannot get space at END, fail and return 0. */
505 static __ptr_t get_contiguous_space
PP ((__malloc_ptrdiff_t
, __ptr_t
));
507 get_contiguous_space (size
, position
)
508 __malloc_ptrdiff_t size
;
514 before
= (*__morecore
) (0);
515 /* If we can tell in advance that the break is at the wrong place,
517 if (before
!= position
)
520 /* Allocate SIZE bytes and get the address of them. */
521 after
= (*__morecore
) (size
);
525 /* It was not contiguous--reject it. */
526 if (after
!= position
)
528 (*__morecore
) (- size
);
536 /* This is called when `_heapinfo' and `heapsize' have just
537 been set to describe a new info table. Set up the table
538 to describe itself and account for it in the statistics. */
539 static void register_heapinfo
PP ((void));
546 __malloc_size_t block
, blocks
;
548 block
= BLOCK (_heapinfo
);
549 blocks
= BLOCKIFY (heapsize
* sizeof (malloc_info
));
551 /* Account for the _heapinfo block itself in the statistics. */
552 _bytes_used
+= blocks
* BLOCKSIZE
;
555 /* Describe the heapinfo block itself in the heapinfo. */
556 _heapinfo
[block
].busy
.type
= 0;
557 _heapinfo
[block
].busy
.info
.size
= blocks
;
558 /* Leave back-pointers for malloc_find_address. */
560 _heapinfo
[block
+ blocks
].busy
.info
.size
= -blocks
;
564 static pthread_once_t malloc_init_once_control
= PTHREAD_ONCE_INIT
;
565 pthread_mutex_t _malloc_mutex
= PTHREAD_MUTEX_INITIALIZER
;
566 pthread_mutex_t _aligned_blocks_mutex
= PTHREAD_MUTEX_INITIALIZER
;
570 malloc_initialize_1 ()
576 if (__malloc_initialize_hook
)
577 (*__malloc_initialize_hook
) ();
579 /* We don't use recursive mutex because pthread_mutexattr_init may
580 call malloc internally. */
581 #if 0 /* defined (USE_PTHREAD) */
583 pthread_mutexattr_t attr
;
585 pthread_mutexattr_init (&attr
);
586 pthread_mutexattr_settype (&attr
, PTHREAD_MUTEX_RECURSIVE
);
587 pthread_mutex_init (&_malloc_mutex
, &attr
);
588 pthread_mutexattr_destroy (&attr
);
592 heapsize
= HEAP
/ BLOCKSIZE
;
593 _heapinfo
= (malloc_info
*) align (heapsize
* sizeof (malloc_info
));
594 if (_heapinfo
== NULL
)
596 memset (_heapinfo
, 0, heapsize
* sizeof (malloc_info
));
597 _heapinfo
[0].free
.size
= 0;
598 _heapinfo
[0].free
.next
= _heapinfo
[0].free
.prev
= 0;
600 _heapbase
= (char *) _heapinfo
;
601 _heaplimit
= BLOCK (_heapbase
+ heapsize
* sizeof (malloc_info
));
603 register_heapinfo ();
605 __malloc_initialized
= 1;
606 PROTECT_MALLOC_STATE (1);
610 /* Set everything up and remember that we have. */
612 __malloc_initialize ()
615 pthread_once (&malloc_init_once_control
, malloc_initialize_1
);
617 if (__malloc_initialized
)
620 malloc_initialize_1 ();
623 return __malloc_initialized
;
626 static int morecore_recursing
;
628 /* Get neatly aligned memory, initializing or
629 growing the heap info table as necessary. */
630 static __ptr_t morecore_nolock
PP ((__malloc_size_t
));
632 morecore_nolock (size
)
633 __malloc_size_t size
;
636 malloc_info
*newinfo
, *oldinfo
;
637 __malloc_size_t newsize
;
639 if (morecore_recursing
)
640 /* Avoid recursion. The caller will know how to handle a null return. */
643 result
= align (size
);
647 PROTECT_MALLOC_STATE (0);
649 /* Check if we need to grow the info table. */
650 if ((__malloc_size_t
) BLOCK ((char *) result
+ size
) > heapsize
)
652 /* Calculate the new _heapinfo table size. We do not account for the
653 added blocks in the table itself, as we hope to place them in
654 existing free space, which is already covered by part of the
659 while ((__malloc_size_t
) BLOCK ((char *) result
+ size
) > newsize
);
661 /* We must not reuse existing core for the new info table when called
662 from realloc in the case of growing a large block, because the
663 block being grown is momentarily marked as free. In this case
664 _heaplimit is zero so we know not to reuse space for internal
668 /* First try to allocate the new info table in core we already
669 have, in the usual way using realloc. If realloc cannot
670 extend it in place or relocate it to existing sufficient core,
671 we will get called again, and the code above will notice the
672 `morecore_recursing' flag and return null. */
673 int save
= errno
; /* Don't want to clobber errno with ENOMEM. */
674 morecore_recursing
= 1;
675 newinfo
= (malloc_info
*) _realloc_internal_nolock
676 (_heapinfo
, newsize
* sizeof (malloc_info
));
677 morecore_recursing
= 0;
682 /* We found some space in core, and realloc has put the old
683 table's blocks on the free list. Now zero the new part
684 of the table and install the new table location. */
685 memset (&newinfo
[heapsize
], 0,
686 (newsize
- heapsize
) * sizeof (malloc_info
));
693 /* Allocate new space for the malloc info table. */
696 newinfo
= (malloc_info
*) align (newsize
* sizeof (malloc_info
));
701 (*__morecore
) (-size
);
705 /* Is it big enough to record status for its own space?
707 if ((__malloc_size_t
) BLOCK ((char *) newinfo
708 + newsize
* sizeof (malloc_info
))
712 /* Must try again. First give back most of what we just got. */
713 (*__morecore
) (- newsize
* sizeof (malloc_info
));
717 /* Copy the old table to the beginning of the new,
718 and zero the rest of the new table. */
719 memcpy (newinfo
, _heapinfo
, heapsize
* sizeof (malloc_info
));
720 memset (&newinfo
[heapsize
], 0,
721 (newsize
- heapsize
) * sizeof (malloc_info
));
726 register_heapinfo ();
728 /* Reset _heaplimit so _free_internal never decides
729 it can relocate or resize the info table. */
731 _free_internal_nolock (oldinfo
);
732 PROTECT_MALLOC_STATE (0);
734 /* The new heap limit includes the new table just allocated. */
735 _heaplimit
= BLOCK ((char *) newinfo
+ heapsize
* sizeof (malloc_info
));
740 _heaplimit
= BLOCK ((char *) result
+ size
);
744 /* Allocate memory from the heap. */
746 _malloc_internal_nolock (size
)
747 __malloc_size_t size
;
750 __malloc_size_t block
, blocks
, lastblocks
, start
;
751 register __malloc_size_t i
;
754 /* ANSI C allows `malloc (0)' to either return NULL, or to return a
755 valid address you can realloc and free (though not dereference).
757 It turns out that some extant code (sunrpc, at least Ultrix's version)
758 expects `malloc (0)' to return non-NULL and breaks otherwise.
766 PROTECT_MALLOC_STATE (0);
768 if (size
< sizeof (struct list
))
769 size
= sizeof (struct list
);
771 #ifdef SUNOS_LOCALTIME_BUG
776 /* Determine the allocation policy based on the request size. */
777 if (size
<= BLOCKSIZE
/ 2)
779 /* Small allocation to receive a fragment of a block.
780 Determine the logarithm to base two of the fragment size. */
781 register __malloc_size_t log
= 1;
783 while ((size
/= 2) != 0)
786 /* Look in the fragment lists for a
787 free fragment of the desired size. */
788 next
= _fraghead
[log
].next
;
791 /* There are free fragments of this size.
792 Pop a fragment out of the fragment list and return it.
793 Update the block's nfree and first counters. */
794 result
= (__ptr_t
) next
;
795 next
->prev
->next
= next
->next
;
796 if (next
->next
!= NULL
)
797 next
->next
->prev
= next
->prev
;
798 block
= BLOCK (result
);
799 if (--_heapinfo
[block
].busy
.info
.frag
.nfree
!= 0)
800 _heapinfo
[block
].busy
.info
.frag
.first
= (unsigned long int)
801 ((unsigned long int) ((char *) next
->next
- (char *) NULL
)
804 /* Update the statistics. */
806 _bytes_used
+= 1 << log
;
808 _bytes_free
-= 1 << log
;
812 /* No free fragments of the desired size, so get a new block
813 and break it into fragments, returning the first. */
814 #ifdef GC_MALLOC_CHECK
815 result
= _malloc_internal_nolock (BLOCKSIZE
);
816 PROTECT_MALLOC_STATE (0);
817 #elif defined (USE_PTHREAD)
818 result
= _malloc_internal_nolock (BLOCKSIZE
);
820 result
= malloc (BLOCKSIZE
);
824 PROTECT_MALLOC_STATE (1);
828 /* Link all fragments but the first into the free list. */
829 next
= (struct list
*) ((char *) result
+ (1 << log
));
831 next
->prev
= &_fraghead
[log
];
832 _fraghead
[log
].next
= next
;
834 for (i
= 2; i
< (__malloc_size_t
) (BLOCKSIZE
>> log
); ++i
)
836 next
= (struct list
*) ((char *) result
+ (i
<< log
));
837 next
->next
= _fraghead
[log
].next
;
838 next
->prev
= &_fraghead
[log
];
839 next
->prev
->next
= next
;
840 next
->next
->prev
= next
;
843 /* Initialize the nfree and first counters for this block. */
844 block
= BLOCK (result
);
845 _heapinfo
[block
].busy
.type
= log
;
846 _heapinfo
[block
].busy
.info
.frag
.nfree
= i
- 1;
847 _heapinfo
[block
].busy
.info
.frag
.first
= i
- 1;
849 _chunks_free
+= (BLOCKSIZE
>> log
) - 1;
850 _bytes_free
+= BLOCKSIZE
- (1 << log
);
851 _bytes_used
-= BLOCKSIZE
- (1 << log
);
856 /* Large allocation to receive one or more blocks.
857 Search the free list in a circle starting at the last place visited.
858 If we loop completely around without finding a large enough
859 space we will have to get more memory from the system. */
860 blocks
= BLOCKIFY (size
);
861 start
= block
= _heapindex
;
862 while (_heapinfo
[block
].free
.size
< blocks
)
864 block
= _heapinfo
[block
].free
.next
;
867 /* Need to get more from the system. Get a little extra. */
868 __malloc_size_t wantblocks
= blocks
+ __malloc_extra_blocks
;
869 block
= _heapinfo
[0].free
.prev
;
870 lastblocks
= _heapinfo
[block
].free
.size
;
871 /* Check to see if the new core will be contiguous with the
872 final free block; if so we don't need to get as much. */
873 if (_heaplimit
!= 0 && block
+ lastblocks
== _heaplimit
&&
874 /* We can't do this if we will have to make the heap info
875 table bigger to accomodate the new space. */
876 block
+ wantblocks
<= heapsize
&&
877 get_contiguous_space ((wantblocks
- lastblocks
) * BLOCKSIZE
,
878 ADDRESS (block
+ lastblocks
)))
880 /* We got it contiguously. Which block we are extending
881 (the `final free block' referred to above) might have
882 changed, if it got combined with a freed info table. */
883 block
= _heapinfo
[0].free
.prev
;
884 _heapinfo
[block
].free
.size
+= (wantblocks
- lastblocks
);
885 _bytes_free
+= (wantblocks
- lastblocks
) * BLOCKSIZE
;
886 _heaplimit
+= wantblocks
- lastblocks
;
889 result
= morecore_nolock (wantblocks
* BLOCKSIZE
);
892 block
= BLOCK (result
);
893 /* Put the new block at the end of the free list. */
894 _heapinfo
[block
].free
.size
= wantblocks
;
895 _heapinfo
[block
].free
.prev
= _heapinfo
[0].free
.prev
;
896 _heapinfo
[block
].free
.next
= 0;
897 _heapinfo
[0].free
.prev
= block
;
898 _heapinfo
[_heapinfo
[block
].free
.prev
].free
.next
= block
;
900 /* Now loop to use some of that block for this allocation. */
904 /* At this point we have found a suitable free list entry.
905 Figure out how to remove what we need from the list. */
906 result
= ADDRESS (block
);
907 if (_heapinfo
[block
].free
.size
> blocks
)
909 /* The block we found has a bit left over,
910 so relink the tail end back into the free list. */
911 _heapinfo
[block
+ blocks
].free
.size
912 = _heapinfo
[block
].free
.size
- blocks
;
913 _heapinfo
[block
+ blocks
].free
.next
914 = _heapinfo
[block
].free
.next
;
915 _heapinfo
[block
+ blocks
].free
.prev
916 = _heapinfo
[block
].free
.prev
;
917 _heapinfo
[_heapinfo
[block
].free
.prev
].free
.next
918 = _heapinfo
[_heapinfo
[block
].free
.next
].free
.prev
919 = _heapindex
= block
+ blocks
;
923 /* The block exactly matches our requirements,
924 so just remove it from the list. */
925 _heapinfo
[_heapinfo
[block
].free
.next
].free
.prev
926 = _heapinfo
[block
].free
.prev
;
927 _heapinfo
[_heapinfo
[block
].free
.prev
].free
.next
928 = _heapindex
= _heapinfo
[block
].free
.next
;
932 _heapinfo
[block
].busy
.type
= 0;
933 _heapinfo
[block
].busy
.info
.size
= blocks
;
935 _bytes_used
+= blocks
* BLOCKSIZE
;
936 _bytes_free
-= blocks
* BLOCKSIZE
;
938 /* Mark all the blocks of the object just allocated except for the
939 first with a negative number so you can find the first block by
940 adding that adjustment. */
942 _heapinfo
[block
+ blocks
].busy
.info
.size
= -blocks
;
945 PROTECT_MALLOC_STATE (1);
951 _malloc_internal (size
)
952 __malloc_size_t size
;
957 result
= _malloc_internal_nolock (size
);
965 __malloc_size_t size
;
967 __ptr_t (*hook
) (__malloc_size_t
);
969 if (!__malloc_initialized
&& !__malloc_initialize ())
972 /* Copy the value of __malloc_hook to an automatic variable in case
973 __malloc_hook is modified in another thread between its
974 NULL-check and the use.
976 Note: Strictly speaking, this is not a right solution. We should
977 use mutexes to access non-read-only variables that are shared
978 among multiple threads. We just leave it for compatibility with
979 glibc malloc (i.e., assignments to __malloc_hook) for now. */
980 hook
= __malloc_hook
;
981 return (hook
!= NULL
? *hook
: _malloc_internal
) (size
);
986 /* On some ANSI C systems, some libc functions call _malloc, _free
987 and _realloc. Make them use the GNU functions. */
991 __malloc_size_t size
;
993 return malloc (size
);
1004 _realloc (ptr
, size
)
1006 __malloc_size_t size
;
1008 return realloc (ptr
, size
);
1012 /* Free a block of memory allocated by `malloc'.
1013 Copyright 1990, 1991, 1992, 1994, 1995 Free Software Foundation, Inc.
1014 Written May 1989 by Mike Haertel.
1016 This library is free software; you can redistribute it and/or
1017 modify it under the terms of the GNU General Public License as
1018 published by the Free Software Foundation; either version 2 of the
1019 License, or (at your option) any later version.
1021 This library is distributed in the hope that it will be useful,
1022 but WITHOUT ANY WARRANTY; without even the implied warranty of
1023 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1024 General Public License for more details.
1026 You should have received a copy of the GNU General Public
1027 License along with this library; see the file COPYING. If
1028 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1029 Fifth Floor, Boston, MA 02110-1301, USA.
1031 The author may be reached (Email) at the address mike@ai.mit.edu,
1032 or (US mail) as Mike Haertel c/o Free Software Foundation. */
1034 #ifndef _MALLOC_INTERNAL
1035 #define _MALLOC_INTERNAL
1040 /* Cope with systems lacking `memmove'. */
1042 #if (defined (MEMMOVE_MISSING) || \
1043 !defined(_LIBC) && !defined(STDC_HEADERS) && !defined(USG))
1045 #undef __malloc_safe_bcopy
1046 #define __malloc_safe_bcopy safe_bcopy
1048 /* This function is defined in realloc.c. */
1049 extern void __malloc_safe_bcopy
PP ((__ptr_t
, __ptr_t
, __malloc_size_t
));
1050 #define memmove(to, from, size) __malloc_safe_bcopy ((from), (to), (size))
1055 /* Debugging hook for free. */
1056 void (*__free_hook
) PP ((__ptr_t __ptr
));
1058 /* List of blocks allocated by memalign. */
1059 struct alignlist
*_aligned_blocks
= NULL
;
1061 /* Return memory to the heap.
1062 Like `_free_internal' but don't lock mutex. */
1064 _free_internal_nolock (ptr
)
1068 __malloc_size_t block
, blocks
;
1069 register __malloc_size_t i
;
1070 struct list
*prev
, *next
;
1072 const __malloc_size_t lesscore_threshold
1073 /* Threshold of free space at which we will return some to the system. */
1074 = FINAL_FREE_BLOCKS
+ 2 * __malloc_extra_blocks
;
1076 register struct alignlist
*l
;
1081 PROTECT_MALLOC_STATE (0);
1083 LOCK_ALIGNED_BLOCKS ();
1084 for (l
= _aligned_blocks
; l
!= NULL
; l
= l
->next
)
1085 if (l
->aligned
== ptr
)
1087 l
->aligned
= NULL
; /* Mark the slot in the list as free. */
1091 UNLOCK_ALIGNED_BLOCKS ();
1093 block
= BLOCK (ptr
);
1095 type
= _heapinfo
[block
].busy
.type
;
1099 /* Get as many statistics as early as we can. */
1101 _bytes_used
-= _heapinfo
[block
].busy
.info
.size
* BLOCKSIZE
;
1102 _bytes_free
+= _heapinfo
[block
].busy
.info
.size
* BLOCKSIZE
;
1104 /* Find the free cluster previous to this one in the free list.
1105 Start searching at the last block referenced; this may benefit
1106 programs with locality of allocation. */
1110 i
= _heapinfo
[i
].free
.prev
;
1114 i
= _heapinfo
[i
].free
.next
;
1115 while (i
> 0 && i
< block
);
1116 i
= _heapinfo
[i
].free
.prev
;
1119 /* Determine how to link this block into the free list. */
1120 if (block
== i
+ _heapinfo
[i
].free
.size
)
1122 /* Coalesce this block with its predecessor. */
1123 _heapinfo
[i
].free
.size
+= _heapinfo
[block
].busy
.info
.size
;
1128 /* Really link this block back into the free list. */
1129 _heapinfo
[block
].free
.size
= _heapinfo
[block
].busy
.info
.size
;
1130 _heapinfo
[block
].free
.next
= _heapinfo
[i
].free
.next
;
1131 _heapinfo
[block
].free
.prev
= i
;
1132 _heapinfo
[i
].free
.next
= block
;
1133 _heapinfo
[_heapinfo
[block
].free
.next
].free
.prev
= block
;
1137 /* Now that the block is linked in, see if we can coalesce it
1138 with its successor (by deleting its successor from the list
1139 and adding in its size). */
1140 if (block
+ _heapinfo
[block
].free
.size
== _heapinfo
[block
].free
.next
)
1142 _heapinfo
[block
].free
.size
1143 += _heapinfo
[_heapinfo
[block
].free
.next
].free
.size
;
1144 _heapinfo
[block
].free
.next
1145 = _heapinfo
[_heapinfo
[block
].free
.next
].free
.next
;
1146 _heapinfo
[_heapinfo
[block
].free
.next
].free
.prev
= block
;
1150 /* How many trailing free blocks are there now? */
1151 blocks
= _heapinfo
[block
].free
.size
;
1153 /* Where is the current end of accessible core? */
1154 curbrk
= (*__morecore
) (0);
1156 if (_heaplimit
!= 0 && curbrk
== ADDRESS (_heaplimit
))
1158 /* The end of the malloc heap is at the end of accessible core.
1159 It's possible that moving _heapinfo will allow us to
1160 return some space to the system. */
1162 __malloc_size_t info_block
= BLOCK (_heapinfo
);
1163 __malloc_size_t info_blocks
= _heapinfo
[info_block
].busy
.info
.size
;
1164 __malloc_size_t prev_block
= _heapinfo
[block
].free
.prev
;
1165 __malloc_size_t prev_blocks
= _heapinfo
[prev_block
].free
.size
;
1166 __malloc_size_t next_block
= _heapinfo
[block
].free
.next
;
1167 __malloc_size_t next_blocks
= _heapinfo
[next_block
].free
.size
;
1169 if (/* Win if this block being freed is last in core, the info table
1170 is just before it, the previous free block is just before the
1171 info table, and the two free blocks together form a useful
1172 amount to return to the system. */
1173 (block
+ blocks
== _heaplimit
&&
1174 info_block
+ info_blocks
== block
&&
1175 prev_block
!= 0 && prev_block
+ prev_blocks
== info_block
&&
1176 blocks
+ prev_blocks
>= lesscore_threshold
) ||
1177 /* Nope, not the case. We can also win if this block being
1178 freed is just before the info table, and the table extends
1179 to the end of core or is followed only by a free block,
1180 and the total free space is worth returning to the system. */
1181 (block
+ blocks
== info_block
&&
1182 ((info_block
+ info_blocks
== _heaplimit
&&
1183 blocks
>= lesscore_threshold
) ||
1184 (info_block
+ info_blocks
== next_block
&&
1185 next_block
+ next_blocks
== _heaplimit
&&
1186 blocks
+ next_blocks
>= lesscore_threshold
)))
1189 malloc_info
*newinfo
;
1190 __malloc_size_t oldlimit
= _heaplimit
;
1192 /* Free the old info table, clearing _heaplimit to avoid
1193 recursion into this code. We don't want to return the
1194 table's blocks to the system before we have copied them to
1195 the new location. */
1197 _free_internal_nolock (_heapinfo
);
1198 _heaplimit
= oldlimit
;
1200 /* Tell malloc to search from the beginning of the heap for
1201 free blocks, so it doesn't reuse the ones just freed. */
1204 /* Allocate new space for the info table and move its data. */
1205 newinfo
= (malloc_info
*) _malloc_internal_nolock (info_blocks
1207 PROTECT_MALLOC_STATE (0);
1208 memmove (newinfo
, _heapinfo
, info_blocks
* BLOCKSIZE
);
1209 _heapinfo
= newinfo
;
1211 /* We should now have coalesced the free block with the
1212 blocks freed from the old info table. Examine the entire
1213 trailing free block to decide below whether to return some
1215 block
= _heapinfo
[0].free
.prev
;
1216 blocks
= _heapinfo
[block
].free
.size
;
1219 /* Now see if we can return stuff to the system. */
1220 if (block
+ blocks
== _heaplimit
&& blocks
>= lesscore_threshold
)
1222 register __malloc_size_t bytes
= blocks
* BLOCKSIZE
;
1223 _heaplimit
-= blocks
;
1224 (*__morecore
) (-bytes
);
1225 _heapinfo
[_heapinfo
[block
].free
.prev
].free
.next
1226 = _heapinfo
[block
].free
.next
;
1227 _heapinfo
[_heapinfo
[block
].free
.next
].free
.prev
1228 = _heapinfo
[block
].free
.prev
;
1229 block
= _heapinfo
[block
].free
.prev
;
1231 _bytes_free
-= bytes
;
1235 /* Set the next search to begin at this block. */
1240 /* Do some of the statistics. */
1242 _bytes_used
-= 1 << type
;
1244 _bytes_free
+= 1 << type
;
1246 /* Get the address of the first free fragment in this block. */
1247 prev
= (struct list
*) ((char *) ADDRESS (block
) +
1248 (_heapinfo
[block
].busy
.info
.frag
.first
<< type
));
1250 if (_heapinfo
[block
].busy
.info
.frag
.nfree
== (BLOCKSIZE
>> type
) - 1)
1252 /* If all fragments of this block are free, remove them
1253 from the fragment list and free the whole block. */
1255 for (i
= 1; i
< (__malloc_size_t
) (BLOCKSIZE
>> type
); ++i
)
1257 prev
->prev
->next
= next
;
1259 next
->prev
= prev
->prev
;
1260 _heapinfo
[block
].busy
.type
= 0;
1261 _heapinfo
[block
].busy
.info
.size
= 1;
1263 /* Keep the statistics accurate. */
1265 _bytes_used
+= BLOCKSIZE
;
1266 _chunks_free
-= BLOCKSIZE
>> type
;
1267 _bytes_free
-= BLOCKSIZE
;
1269 #if defined (GC_MALLOC_CHECK) || defined (USE_PTHREAD)
1270 _free_internal_nolock (ADDRESS (block
));
1272 free (ADDRESS (block
));
1275 else if (_heapinfo
[block
].busy
.info
.frag
.nfree
!= 0)
1277 /* If some fragments of this block are free, link this
1278 fragment into the fragment list after the first free
1279 fragment of this block. */
1280 next
= (struct list
*) ptr
;
1281 next
->next
= prev
->next
;
1284 if (next
->next
!= NULL
)
1285 next
->next
->prev
= next
;
1286 ++_heapinfo
[block
].busy
.info
.frag
.nfree
;
1290 /* No fragments of this block are free, so link this
1291 fragment into the fragment list and announce that
1292 it is the first free fragment of this block. */
1293 prev
= (struct list
*) ptr
;
1294 _heapinfo
[block
].busy
.info
.frag
.nfree
= 1;
1295 _heapinfo
[block
].busy
.info
.frag
.first
= (unsigned long int)
1296 ((unsigned long int) ((char *) ptr
- (char *) NULL
)
1297 % BLOCKSIZE
>> type
);
1298 prev
->next
= _fraghead
[type
].next
;
1299 prev
->prev
= &_fraghead
[type
];
1300 prev
->prev
->next
= prev
;
1301 if (prev
->next
!= NULL
)
1302 prev
->next
->prev
= prev
;
1307 PROTECT_MALLOC_STATE (1);
1310 /* Return memory to the heap.
1311 Like `free' but don't call a __free_hook if there is one. */
1313 _free_internal (ptr
)
1317 _free_internal_nolock (ptr
);
1321 /* Return memory to the heap. */
1327 void (*hook
) (__ptr_t
) = __free_hook
;
1332 _free_internal (ptr
);
1335 /* Define the `cfree' alias for `free'. */
1337 weak_alias (free
, cfree
)
1346 /* Change the size of a block allocated by `malloc'.
1347 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
1348 Written May 1989 by Mike Haertel.
1350 This library is free software; you can redistribute it and/or
1351 modify it under the terms of the GNU General Public License as
1352 published by the Free Software Foundation; either version 2 of the
1353 License, or (at your option) any later version.
1355 This library is distributed in the hope that it will be useful,
1356 but WITHOUT ANY WARRANTY; without even the implied warranty of
1357 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1358 General Public License for more details.
1360 You should have received a copy of the GNU General Public
1361 License along with this library; see the file COPYING. If
1362 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1363 Fifth Floor, Boston, MA 02110-1301, USA.
1365 The author may be reached (Email) at the address mike@ai.mit.edu,
1366 or (US mail) as Mike Haertel c/o Free Software Foundation. */
1368 #ifndef _MALLOC_INTERNAL
1369 #define _MALLOC_INTERNAL
1375 /* Cope with systems lacking `memmove'. */
1376 #if (defined (MEMMOVE_MISSING) || \
1377 !defined(_LIBC) && !defined(STDC_HEADERS) && !defined(USG))
1380 #undef __malloc_safe_bcopy
1381 #define __malloc_safe_bcopy safe_bcopy
1384 /* Snarfed directly from Emacs src/dispnew.c:
1385 XXX Should use system bcopy if it handles overlap. */
1387 /* Like bcopy except never gets confused by overlap. */
1390 __malloc_safe_bcopy (afrom
, ato
, size
)
1393 __malloc_size_t size
;
1395 char *from
= afrom
, *to
= ato
;
1397 if (size
<= 0 || from
== to
)
1400 /* If the source and destination don't overlap, then bcopy can
1401 handle it. If they do overlap, but the destination is lower in
1402 memory than the source, we'll assume bcopy can handle that. */
1403 if (to
< from
|| from
+ size
<= to
)
1404 bcopy (from
, to
, size
);
1406 /* Otherwise, we'll copy from the end. */
1409 register char *endf
= from
+ size
;
1410 register char *endt
= to
+ size
;
1412 /* If TO - FROM is large, then we should break the copy into
1413 nonoverlapping chunks of TO - FROM bytes each. However, if
1414 TO - FROM is small, then the bcopy function call overhead
1415 makes this not worth it. The crossover point could be about
1416 anywhere. Since I don't think the obvious copy loop is too
1417 bad, I'm trying to err in its favor. */
1422 while (endf
!= from
);
1428 endt
-= (to
- from
);
1429 endf
-= (to
- from
);
1434 bcopy (endf
, endt
, to
- from
);
1437 /* If SIZE wasn't a multiple of TO - FROM, there will be a
1438 little left over. The amount left over is
1439 (endt + (to - from)) - to, which is endt - from. */
1440 bcopy (from
, to
, endt
- from
);
1447 extern void __malloc_safe_bcopy
PP ((__ptr_t
, __ptr_t
, __malloc_size_t
));
1448 #define memmove(to, from, size) __malloc_safe_bcopy ((from), (to), (size))
1454 #define min(A, B) ((A) < (B) ? (A) : (B))
1456 /* Debugging hook for realloc. */
1457 __ptr_t (*__realloc_hook
) PP ((__ptr_t __ptr
, __malloc_size_t __size
));
1459 /* Resize the given region to the new size, returning a pointer
1460 to the (possibly moved) region. This is optimized for speed;
1461 some benchmarks seem to indicate that greater compactness is
1462 achieved by unconditionally allocating and copying to a
1463 new region. This module has incestuous knowledge of the
1464 internals of both free and malloc. */
1466 _realloc_internal_nolock (ptr
, size
)
1468 __malloc_size_t size
;
1472 __malloc_size_t block
, blocks
, oldlimit
;
1476 _free_internal_nolock (ptr
);
1477 return _malloc_internal_nolock (0);
1479 else if (ptr
== NULL
)
1480 return _malloc_internal_nolock (size
);
1482 block
= BLOCK (ptr
);
1484 PROTECT_MALLOC_STATE (0);
1486 type
= _heapinfo
[block
].busy
.type
;
1490 /* Maybe reallocate a large block to a small fragment. */
1491 if (size
<= BLOCKSIZE
/ 2)
1493 result
= _malloc_internal_nolock (size
);
1496 memcpy (result
, ptr
, size
);
1497 _free_internal_nolock (ptr
);
1502 /* The new size is a large allocation as well;
1503 see if we can hold it in place. */
1504 blocks
= BLOCKIFY (size
);
1505 if (blocks
< _heapinfo
[block
].busy
.info
.size
)
1507 /* The new size is smaller; return
1508 excess memory to the free list. */
1509 _heapinfo
[block
+ blocks
].busy
.type
= 0;
1510 _heapinfo
[block
+ blocks
].busy
.info
.size
1511 = _heapinfo
[block
].busy
.info
.size
- blocks
;
1512 _heapinfo
[block
].busy
.info
.size
= blocks
;
1513 /* We have just created a new chunk by splitting a chunk in two.
1514 Now we will free this chunk; increment the statistics counter
1515 so it doesn't become wrong when _free_internal decrements it. */
1517 _free_internal_nolock (ADDRESS (block
+ blocks
));
1520 else if (blocks
== _heapinfo
[block
].busy
.info
.size
)
1521 /* No size change necessary. */
1525 /* Won't fit, so allocate a new region that will.
1526 Free the old region first in case there is sufficient
1527 adjacent free space to grow without moving. */
1528 blocks
= _heapinfo
[block
].busy
.info
.size
;
1529 /* Prevent free from actually returning memory to the system. */
1530 oldlimit
= _heaplimit
;
1532 _free_internal_nolock (ptr
);
1533 result
= _malloc_internal_nolock (size
);
1534 PROTECT_MALLOC_STATE (0);
1535 if (_heaplimit
== 0)
1536 _heaplimit
= oldlimit
;
1539 /* Now we're really in trouble. We have to unfree
1540 the thing we just freed. Unfortunately it might
1541 have been coalesced with its neighbors. */
1542 if (_heapindex
== block
)
1543 (void) _malloc_internal_nolock (blocks
* BLOCKSIZE
);
1547 = _malloc_internal_nolock ((block
- _heapindex
) * BLOCKSIZE
);
1548 (void) _malloc_internal_nolock (blocks
* BLOCKSIZE
);
1549 _free_internal_nolock (previous
);
1554 memmove (result
, ptr
, blocks
* BLOCKSIZE
);
1559 /* Old size is a fragment; type is logarithm
1560 to base two of the fragment size. */
1561 if (size
> (__malloc_size_t
) (1 << (type
- 1)) &&
1562 size
<= (__malloc_size_t
) (1 << type
))
1563 /* The new size is the same kind of fragment. */
1567 /* The new size is different; allocate a new space,
1568 and copy the lesser of the new size and the old. */
1569 result
= _malloc_internal_nolock (size
);
1572 memcpy (result
, ptr
, min (size
, (__malloc_size_t
) 1 << type
));
1573 _free_internal_nolock (ptr
);
1578 PROTECT_MALLOC_STATE (1);
1584 _realloc_internal (ptr
, size
)
1586 __malloc_size_t size
;
1591 result
= _realloc_internal_nolock (ptr
, size
);
1600 __malloc_size_t size
;
1602 __ptr_t (*hook
) (__ptr_t
, __malloc_size_t
);
1604 if (!__malloc_initialized
&& !__malloc_initialize ())
1607 hook
= __realloc_hook
;
1608 return (hook
!= NULL
? *hook
: _realloc_internal
) (ptr
, size
);
1610 /* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
1612 This library is free software; you can redistribute it and/or
1613 modify it under the terms of the GNU General Public License as
1614 published by the Free Software Foundation; either version 2 of the
1615 License, or (at your option) any later version.
1617 This library is distributed in the hope that it will be useful,
1618 but WITHOUT ANY WARRANTY; without even the implied warranty of
1619 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1620 General Public License for more details.
1622 You should have received a copy of the GNU General Public
1623 License along with this library; see the file COPYING. If
1624 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1625 Fifth Floor, Boston, MA 02110-1301, USA.
1627 The author may be reached (Email) at the address mike@ai.mit.edu,
1628 or (US mail) as Mike Haertel c/o Free Software Foundation. */
1630 #ifndef _MALLOC_INTERNAL
1631 #define _MALLOC_INTERNAL
1635 /* Allocate an array of NMEMB elements each SIZE bytes long.
1636 The entire array is initialized to zeros. */
1638 calloc (nmemb
, size
)
1639 register __malloc_size_t nmemb
;
1640 register __malloc_size_t size
;
1642 register __ptr_t result
= malloc (nmemb
* size
);
1645 (void) memset (result
, 0, nmemb
* size
);
1649 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
1650 This file is part of the GNU C Library.
1652 The GNU C Library is free software; you can redistribute it and/or modify
1653 it under the terms of the GNU General Public License as published by
1654 the Free Software Foundation; either version 2, or (at your option)
1657 The GNU C Library is distributed in the hope that it will be useful,
1658 but WITHOUT ANY WARRANTY; without even the implied warranty of
1659 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1660 GNU General Public License for more details.
1662 You should have received a copy of the GNU General Public License
1663 along with the GNU C Library; see the file COPYING. If not, write to
1664 the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
1665 MA 02110-1301, USA. */
1667 #ifndef _MALLOC_INTERNAL
1668 #define _MALLOC_INTERNAL
1672 #ifndef __GNU_LIBRARY__
1676 #ifdef __GNU_LIBRARY__
1677 /* It is best not to declare this and cast its result on foreign operating
1678 systems with potentially hostile include files. */
1681 extern __ptr_t __sbrk
PP ((ptrdiff_t increment
));
1688 /* Allocate INCREMENT more bytes of data space,
1689 and return the start of data space, or NULL on errors.
1690 If INCREMENT is negative, shrink data space. */
1692 __default_morecore (increment
)
1693 __malloc_ptrdiff_t increment
;
1697 if (!bss_sbrk_did_unexec
)
1699 return bss_sbrk (increment
);
1702 result
= (__ptr_t
) __sbrk (increment
);
1703 if (result
== (__ptr_t
) -1)
1707 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
1709 This library is free software; you can redistribute it and/or
1710 modify it under the terms of the GNU General Public License as
1711 published by the Free Software Foundation; either version 2 of the
1712 License, or (at your option) any later version.
1714 This library is distributed in the hope that it will be useful,
1715 but WITHOUT ANY WARRANTY; without even the implied warranty of
1716 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1717 General Public License for more details.
1719 You should have received a copy of the GNU General Public
1720 License along with this library; see the file COPYING. If
1721 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1722 Fifth Floor, Boston, MA 02110-1301, USA. */
1724 #ifndef _MALLOC_INTERNAL
1725 #define _MALLOC_INTERNAL
1729 #if __DJGPP__ - 0 == 1
1731 /* There is some problem with memalign in DJGPP v1 and we are supposed
1732 to omit it. Noone told me why, they just told me to do it. */
1736 __ptr_t (*__memalign_hook
) PP ((__malloc_size_t __size
,
1737 __malloc_size_t __alignment
));
1740 memalign (alignment
, size
)
1741 __malloc_size_t alignment
;
1742 __malloc_size_t size
;
1745 unsigned long int adj
, lastadj
;
1746 __ptr_t (*hook
) (__malloc_size_t
, __malloc_size_t
) = __memalign_hook
;
1749 return (*hook
) (alignment
, size
);
1751 /* Allocate a block with enough extra space to pad the block with up to
1752 (ALIGNMENT - 1) bytes if necessary. */
1753 result
= malloc (size
+ alignment
- 1);
1757 /* Figure out how much we will need to pad this particular block
1758 to achieve the required alignment. */
1759 adj
= (unsigned long int) ((char *) result
- (char *) NULL
) % alignment
;
1763 /* Reallocate the block with only as much excess as it needs. */
1765 result
= malloc (adj
+ size
);
1766 if (result
== NULL
) /* Impossible unless interrupted. */
1770 adj
= (unsigned long int) ((char *) result
- (char *) NULL
) % alignment
;
1771 /* It's conceivable we might have been so unlucky as to get a
1772 different block with weaker alignment. If so, this block is too
1773 short to contain SIZE after alignment correction. So we must
1774 try again and get another block, slightly larger. */
1775 } while (adj
> lastadj
);
1779 /* Record this block in the list of aligned blocks, so that `free'
1780 can identify the pointer it is passed, which will be in the middle
1781 of an allocated block. */
1783 struct alignlist
*l
;
1784 LOCK_ALIGNED_BLOCKS ();
1785 for (l
= _aligned_blocks
; l
!= NULL
; l
= l
->next
)
1786 if (l
->aligned
== NULL
)
1787 /* This slot is free. Use it. */
1791 l
= (struct alignlist
*) malloc (sizeof (struct alignlist
));
1794 l
->next
= _aligned_blocks
;
1795 _aligned_blocks
= l
;
1801 result
= l
->aligned
= (char *) result
+ alignment
- adj
;
1803 UNLOCK_ALIGNED_BLOCKS ();
1814 #endif /* Not DJGPP v1 */
1815 /* Allocate memory on a page boundary.
1816 Copyright (C) 1991, 92, 93, 94, 96 Free Software Foundation, Inc.
1818 This library is free software; you can redistribute it and/or
1819 modify it under the terms of the GNU General Public License as
1820 published by the Free Software Foundation; either version 2 of the
1821 License, or (at your option) any later version.
1823 This library is distributed in the hope that it will be useful,
1824 but WITHOUT ANY WARRANTY; without even the implied warranty of
1825 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1826 General Public License for more details.
1828 You should have received a copy of the GNU General Public
1829 License along with this library; see the file COPYING. If
1830 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1831 Fifth Floor, Boston, MA 02110-1301, USA.
1833 The author may be reached (Email) at the address mike@ai.mit.edu,
1834 or (US mail) as Mike Haertel c/o Free Software Foundation. */
1836 #if defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC)
1838 /* Emacs defines GMALLOC_INHIBIT_VALLOC to avoid this definition
1839 on MSDOS, where it conflicts with a system header file. */
1841 #define ELIDE_VALLOC
1845 #ifndef ELIDE_VALLOC
1847 #if defined (__GNU_LIBRARY__) || defined (_LIBC)
1849 #include <sys/cdefs.h>
1850 #if defined (__GLIBC__) && __GLIBC__ >= 2
1851 /* __getpagesize is already declared in <unistd.h> with return type int */
1853 extern size_t __getpagesize
PP ((void));
1856 #include "getpagesize.h"
1857 #define __getpagesize() getpagesize()
1860 #ifndef _MALLOC_INTERNAL
1861 #define _MALLOC_INTERNAL
1865 static __malloc_size_t pagesize
;
1869 __malloc_size_t size
;
1872 pagesize
= __getpagesize ();
1874 return memalign (pagesize
, size
);
1877 #endif /* Not ELIDE_VALLOC. */
1881 /* Standard debugging hooks for `malloc'.
1882 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
1883 Written May 1989 by Mike Haertel.
1885 This library is free software; you can redistribute it and/or
1886 modify it under the terms of the GNU General Public License as
1887 published by the Free Software Foundation; either version 2 of the
1888 License, or (at your option) any later version.
1890 This library is distributed in the hope that it will be useful,
1891 but WITHOUT ANY WARRANTY; without even the implied warranty of
1892 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1893 General Public License for more details.
1895 You should have received a copy of the GNU General Public
1896 License along with this library; see the file COPYING. If
1897 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
1898 Fifth Floor, Boston, MA 02110-1301, USA.
1900 The author may be reached (Email) at the address mike@ai.mit.edu,
1901 or (US mail) as Mike Haertel c/o Free Software Foundation. */
1906 #ifndef _MALLOC_INTERNAL
1907 #define _MALLOC_INTERNAL
1913 /* Old hook values. */
1914 static void (*old_free_hook
) __P ((__ptr_t ptr
));
1915 static __ptr_t (*old_malloc_hook
) __P ((__malloc_size_t size
));
1916 static __ptr_t (*old_realloc_hook
) __P ((__ptr_t ptr
, __malloc_size_t size
));
1918 /* Function to call when something awful happens. */
1919 static void (*abortfunc
) __P ((enum mcheck_status
));
1921 /* Arbitrary magical numbers. */
1922 #define MAGICWORD 0xfedabeeb
1923 #define MAGICFREE 0xd8675309
1924 #define MAGICBYTE ((char) 0xd7)
1925 #define MALLOCFLOOD ((char) 0x93)
1926 #define FREEFLOOD ((char) 0x95)
1930 __malloc_size_t size
; /* Exact size requested by user. */
1931 unsigned long int magic
; /* Magic number to check header integrity. */
1934 #if defined(_LIBC) || defined(STDC_HEADERS) || defined(USG)
1935 #define flood memset
1937 static void flood
__P ((__ptr_t
, int, __malloc_size_t
));
1939 flood (ptr
, val
, size
)
1942 __malloc_size_t size
;
1950 static enum mcheck_status checkhdr
__P ((const struct hdr
*));
1951 static enum mcheck_status
1953 const struct hdr
*hdr
;
1955 enum mcheck_status status
;
1959 status
= MCHECK_HEAD
;
1962 status
= MCHECK_FREE
;
1965 if (((char *) &hdr
[1])[hdr
->size
] != MAGICBYTE
)
1966 status
= MCHECK_TAIL
;
1971 if (status
!= MCHECK_OK
)
1972 (*abortfunc
) (status
);
1976 static void freehook
__P ((__ptr_t
));
1985 hdr
= ((struct hdr
*) ptr
) - 1;
1987 hdr
->magic
= MAGICFREE
;
1988 flood (ptr
, FREEFLOOD
, hdr
->size
);
1993 __free_hook
= old_free_hook
;
1995 __free_hook
= freehook
;
1998 static __ptr_t mallochook
__P ((__malloc_size_t
));
2001 __malloc_size_t size
;
2005 __malloc_hook
= old_malloc_hook
;
2006 hdr
= (struct hdr
*) malloc (sizeof (struct hdr
) + size
+ 1);
2007 __malloc_hook
= mallochook
;
2012 hdr
->magic
= MAGICWORD
;
2013 ((char *) &hdr
[1])[size
] = MAGICBYTE
;
2014 flood ((__ptr_t
) (hdr
+ 1), MALLOCFLOOD
, size
);
2015 return (__ptr_t
) (hdr
+ 1);
2018 static __ptr_t reallochook
__P ((__ptr_t
, __malloc_size_t
));
2020 reallochook (ptr
, size
)
2022 __malloc_size_t size
;
2024 struct hdr
*hdr
= NULL
;
2025 __malloc_size_t osize
= 0;
2029 hdr
= ((struct hdr
*) ptr
) - 1;
2034 flood ((char *) ptr
+ size
, FREEFLOOD
, osize
- size
);
2037 __free_hook
= old_free_hook
;
2038 __malloc_hook
= old_malloc_hook
;
2039 __realloc_hook
= old_realloc_hook
;
2040 hdr
= (struct hdr
*) realloc ((__ptr_t
) hdr
, sizeof (struct hdr
) + size
+ 1);
2041 __free_hook
= freehook
;
2042 __malloc_hook
= mallochook
;
2043 __realloc_hook
= reallochook
;
2048 hdr
->magic
= MAGICWORD
;
2049 ((char *) &hdr
[1])[size
] = MAGICBYTE
;
2051 flood ((char *) (hdr
+ 1) + osize
, MALLOCFLOOD
, size
- osize
);
2052 return (__ptr_t
) (hdr
+ 1);
2057 enum mcheck_status status
;
2063 msg
= "memory is consistent, library is buggy";
2066 msg
= "memory clobbered before allocated block";
2069 msg
= "memory clobbered past end of allocated block";
2072 msg
= "block freed twice";
2075 msg
= "bogus mcheck_status, library is buggy";
2078 #ifdef __GNU_LIBRARY__
2081 fprintf (stderr
, "mcheck: %s\n", msg
);
2087 static int mcheck_used
= 0;
2091 void (*func
) __P ((enum mcheck_status
));
2093 abortfunc
= (func
!= NULL
) ? func
: &mabort
;
2095 /* These hooks may not be safely inserted if malloc is already in use. */
2096 if (!__malloc_initialized
&& !mcheck_used
)
2098 old_free_hook
= __free_hook
;
2099 __free_hook
= freehook
;
2100 old_malloc_hook
= __malloc_hook
;
2101 __malloc_hook
= mallochook
;
2102 old_realloc_hook
= __realloc_hook
;
2103 __realloc_hook
= reallochook
;
2107 return mcheck_used
? 0 : -1;
2111 mprobe (__ptr_t ptr
)
2113 return mcheck_used
? checkhdr (ptr
) : MCHECK_DISABLED
;
2116 #endif /* GC_MCHECK */
2118 /* arch-tag: 93dce5c0-f49a-41b5-86b1-f91c4169c02e
2119 (do not change this comment) */