| blob | 56968cbd1d0ee3c7742194b1d1d1c47abb949fd6 |
1 #include <newlib.h>
2 #ifdef MALLOC_PROVIDED
4 #elif defined(_NANO_MALLOC)
6 #else
7 /* ---------- To make a malloc.h, start cutting here ------------ */
9 /*
10 A version of malloc/free/realloc written by Doug Lea and released to the
11 public domain. Send questions/comments/complaints/performance data
12 to dl@cs.oswego.edu
14 * VERSION 2.6.5 Wed Jun 17 15:55:16 1998 Doug Lea (dl at gee)
16 Note: There may be an updated version of this malloc obtainable at
17 ftp://g.oswego.edu/pub/misc/malloc.c
18 Check before installing!
20 Note: This version differs from 2.6.4 only by correcting a
21 statement ordering error that could cause failures only
22 when calls to this malloc are interposed with calls to
23 other memory allocators.
25 * Why use this malloc?
27 This is not the fastest, most space-conserving, most portable, or
28 most tunable malloc ever written. However it is among the fastest
29 while also being among the most space-conserving, portable and tunable.
30 Consistent balance across these factors results in a good general-purpose
31 allocator. For a high-level description, see
32 http://g.oswego.edu/dl/html/malloc.html
34 * Synopsis of public routines
36 (Much fuller descriptions are contained in the program documentation below.)
38 malloc(size_t n);
39 Return a pointer to a newly allocated chunk of at least n bytes, or null
40 if no space is available.
41 free(Void_t* p);
42 Release the chunk of memory pointed to by p, or no effect if p is null.
43 realloc(Void_t* p, size_t n);
44 Return a pointer to a chunk of size n that contains the same data
45 as does chunk p up to the minimum of (n, p's size) bytes, or null
46 if no space is available. The returned pointer may or may not be
47 the same as p. If p is null, equivalent to malloc. Unless the
48 #define REALLOC_ZERO_BYTES_FREES below is set, realloc with a
49 size argument of zero (re)allocates a minimum-sized chunk.
50 memalign(size_t alignment, size_t n);
51 Return a pointer to a newly allocated chunk of n bytes, aligned
52 in accord with the alignment argument, which must be a power of
53 two.
54 valloc(size_t n);
55 Equivalent to memalign(pagesize, n), where pagesize is the page
56 size of the system (or as near to this as can be figured out from
57 all the includes/defines below.)
58 pvalloc(size_t n);
59 Equivalent to valloc(minimum-page-that-holds(n)), that is,
60 round up n to nearest pagesize.
61 calloc(size_t unit, size_t quantity);
62 Returns a pointer to quantity * unit bytes, with all locations
63 set to zero.
64 cfree(Void_t* p);
65 Equivalent to free(p).
66 malloc_trim(size_t pad);
67 Release all but pad bytes of freed top-most memory back
68 to the system. Return 1 if successful, else 0.
69 malloc_usable_size(Void_t* p);
70 Report the number usable allocated bytes associated with allocated
71 chunk p. This may or may not report more bytes than were requested,
72 due to alignment and minimum size constraints.
73 malloc_stats();
74 Prints brief summary statistics on stderr.
75 mallinfo()
76 Returns (by copy) a struct containing various summary statistics.
77 mallopt(int parameter_number, int parameter_value)
78 Changes one of the tunable parameters described below. Returns
79 1 if successful in changing the parameter, else 0.
81 * Vital statistics:
83 Alignment: 8-byte
84 8 byte alignment is currently hardwired into the design. This
85 seems to suffice for all current machines and C compilers.
87 Assumed pointer representation: 4 or 8 bytes
88 Code for 8-byte pointers is untested by me but has worked
89 reliably by Wolfram Gloger, who contributed most of the
90 changes supporting this.
92 Assumed size_t representation: 4 or 8 bytes
93 Note that size_t is allowed to be 4 bytes even if pointers are 8.
95 Minimum overhead per allocated chunk: 4 or 8 bytes
96 Each malloced chunk has a hidden overhead of 4 bytes holding size
97 and status information.
99 Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
100 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
102 When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
103 ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
104 needed; 4 (8) for a trailing size field
105 and 8 (16) bytes for free list pointers. Thus, the minimum
106 allocatable size is 16/24/32 bytes.
108 Even a request for zero bytes (i.e., malloc(0)) returns a
109 pointer to something of the minimum allocatable size.
111 Maximum allocated size: 4-byte size_t: 2^31 - 8 bytes
112 8-byte size_t: 2^63 - 16 bytes
114 It is assumed that (possibly signed) size_t bit values suffice to
115 represent chunk sizes. `Possibly signed' is due to the fact
116 that `size_t' may be defined on a system as either a signed or
117 an unsigned type. To be conservative, values that would appear
118 as negative numbers are avoided.
119 Requests for sizes with a negative sign bit will return a
120 minimum-sized chunk.
122 Maximum overhead wastage per allocated chunk: normally 15 bytes
124 Alignnment demands, plus the minimum allocatable size restriction
125 make the normal worst-case wastage 15 bytes (i.e., up to 15
126 more bytes will be allocated than were requested in malloc), with
127 two exceptions:
128 1. Because requests for zero bytes allocate non-zero space,
129 the worst case wastage for a request of zero bytes is 24 bytes.
130 2. For requests >= mmap_threshold that are serviced via
131 mmap(), the worst case wastage is 8 bytes plus the remainder
132 from a system page (the minimal mmap unit); typically 4096 bytes.
134 * Limitations
136 Here are some features that are NOT currently supported
138 * No user-definable hooks for callbacks and the like.
139 * No automated mechanism for fully checking that all accesses
140 to malloced memory stay within their bounds.
141 * No support for compaction.
143 * Synopsis of compile-time options:
145 People have reported using previous versions of this malloc on all
146 versions of Unix, sometimes by tweaking some of the defines
147 below. It has been tested most extensively on Solaris and
148 Linux. It is also reported to work on WIN32 platforms.
149 People have also reported adapting this malloc for use in
150 stand-alone embedded systems.
152 The implementation is in straight, hand-tuned ANSI C. Among other
153 consequences, it uses a lot of macros. Because of this, to be at
154 all usable, this code should be compiled using an optimizing compiler
155 (for example gcc -O2) that can simplify expressions and control
156 paths.
158 __STD_C (default: derived from C compiler defines)
159 Nonzero if using ANSI-standard C compiler, a C++ compiler, or
160 a C compiler sufficiently close to ANSI to get away with it.
161 DEBUG (default: NOT defined)
162 Define to enable debugging. Adds fairly extensive assertion-based
163 checking to help track down memory errors, but noticeably slows down
164 execution.
165 SEPARATE_OBJECTS (default: NOT defined)
166 Define this to compile into separate .o files. You must then
167 compile malloc.c several times, defining a DEFINE_* macro each
168 time. The list of DEFINE_* macros appears below.
169 MALLOC_LOCK (default: NOT defined)
170 MALLOC_UNLOCK (default: NOT defined)
171 Define these to C expressions which are run to lock and unlock
172 the malloc data structures. Calls may be nested; that is,
173 MALLOC_LOCK may be called more than once before the corresponding
174 MALLOC_UNLOCK calls. MALLOC_LOCK must avoid waiting for a lock
175 that it already holds.
176 MALLOC_ALIGNMENT (default: NOT defined)
177 Define this to 16 if you need 16 byte alignment instead of 8 byte alignment
178 which is the normal default.
179 REALLOC_ZERO_BYTES_FREES (default: NOT defined)
180 Define this if you think that realloc(p, 0) should be equivalent
181 to free(p). Otherwise, since malloc returns a unique pointer for
182 malloc(0), so does realloc(p, 0).
183 HAVE_MEMCPY (default: defined)
184 Define if you are not otherwise using ANSI STD C, but still
185 have memcpy and memset in your C library and want to use them.
186 Otherwise, simple internal versions are supplied.
187 USE_MEMCPY (default: 1 if HAVE_MEMCPY is defined, 0 otherwise)
188 Define as 1 if you want the C library versions of memset and
189 memcpy called in realloc and calloc (otherwise macro versions are used).
190 At least on some platforms, the simple macro versions usually
191 outperform libc versions.
192 HAVE_MMAP (default: defined as 1)
193 Define to non-zero to optionally make malloc() use mmap() to
194 allocate very large blocks.
195 HAVE_MREMAP (default: defined as 0 unless Linux libc set)
196 Define to non-zero to optionally make realloc() use mremap() to
197 reallocate very large blocks.
198 malloc_getpagesize (default: derived from system #includes)
199 Either a constant or routine call returning the system page size.
200 HAVE_USR_INCLUDE_MALLOC_H (default: NOT defined)
201 Optionally define if you are on a system with a /usr/include/malloc.h
202 that declares struct mallinfo. It is not at all necessary to
203 define this even if you do, but will ensure consistency.
204 INTERNAL_SIZE_T (default: size_t)
205 Define to a 32-bit type (probably `unsigned int') if you are on a
206 64-bit machine, yet do not want or need to allow malloc requests of
207 greater than 2^31 to be handled. This saves space, especially for
208 very small chunks.
209 INTERNAL_LINUX_C_LIB (default: NOT defined)
210 Defined only when compiled as part of Linux libc.
211 Also note that there is some odd internal name-mangling via defines
212 (for example, internally, `malloc' is named `mALLOc') needed
213 when compiling in this case. These look funny but don't otherwise
214 affect anything.
215 _LIBC (default: NOT defined)
216 Defined only when compiled as part of the Cygnus newlib
217 distribution.
218 WIN32 (default: undefined)
219 Define this on MS win (95, nt) platforms to compile in sbrk emulation.
220 LACKS_UNISTD_H (default: undefined)
221 Define this if your system does not have a <unistd.h>.
222 MORECORE (default: sbrk)
223 The name of the routine to call to obtain more memory from the system.
224 MORECORE_FAILURE (default: -1)
225 The value returned upon failure of MORECORE.
226 MORECORE_CLEARS (default 1)
227 True (1) if the routine mapped to MORECORE zeroes out memory (which
228 holds for sbrk).
229 DEFAULT_TRIM_THRESHOLD
230 DEFAULT_TOP_PAD
231 DEFAULT_MMAP_THRESHOLD
232 DEFAULT_MMAP_MAX
233 Default values of tunable parameters (described in detail below)
234 controlling interaction with host system routines (sbrk, mmap, etc).
235 These values may also be changed dynamically via mallopt(). The
236 preset defaults are those that give best performance for typical
237 programs/systems.
240 */
242 \f
245 /* Preliminaries */
247 #ifndef __STD_C
248 #ifdef __STDC__
249 #define __STD_C 1
250 #else
251 #if __cplusplus
252 #define __STD_C 1
253 #else
254 #define __STD_C 0
259 #ifndef Void_t
260 #if __STD_C
261 #define Void_t void
262 #else
263 #define Void_t char
264 #endif
267 #if __STD_C
269 #else
270 #include <sys/types.h>
271 #endif
273 #ifdef __cplusplus
275 #endif
281 #ifdef WIN32
282 #define WIN32_LEAN_AND_MEAN
283 #include <windows.h>
284 #endif
286 /*
287 Compile-time options
288 */
291 /*
293 Special defines for Cygnus newlib distribution.
295 */
297 #ifdef _LIBC
299 #include <sys/config.h>
301 /*
302 In newlib, all the publically visible routines take a reentrancy
303 pointer. We don't currently do anything much with it, but we do
304 pass it to the lock routine.
305 */
307 #include <reent.h>
309 #define POINTER_UINT unsigned _POINTER_INT
310 #define SEPARATE_OBJECTS
311 #define HAVE_MMAP 0
312 #define MORECORE(size) _sbrk_r(reent_ptr, (size))
313 #define MORECORE_CLEARS 0
314 #define MALLOC_LOCK __malloc_lock(reent_ptr)
315 #define MALLOC_UNLOCK __malloc_unlock(reent_ptr)
317 #ifdef __CYGWIN__
318 # undef _WIN32
319 # undef WIN32
320 #endif
322 #ifndef _WIN32
323 #ifndef HAVE_SYSCONF_PAGESIZE
324 #ifdef SMALL_MEMORY
325 #define malloc_getpagesize (128)
326 #else
327 #define malloc_getpagesize (4096)
328 #endif
329 #endif
330 #endif
332 #if __STD_C
335 #else
338 #endif
340 #if __STD_C
341 #define RARG struct _reent *reent_ptr,
342 #define RONEARG struct _reent *reent_ptr
343 #else
344 #define RARG reent_ptr
345 #define RONEARG reent_ptr
346 #define RDECL struct _reent *reent_ptr;
347 #endif
349 #define RERRNO _REENT_ERRNO(reent_ptr)
350 #define RCALL reent_ptr,
351 #define RONECALL reent_ptr
355 #define POINTER_UINT unsigned long
356 #define RARG
357 #define RONEARG
358 #define RDECL
359 #define RERRNO errno
360 #define RCALL
361 #define RONECALL
365 /*
366 Debugging:
368 Because freed chunks may be overwritten with link fields, this
369 malloc will often die when freed memory is overwritten by user
370 programs. This can be very effective (albeit in an annoying way)
371 in helping track down dangling pointers.
373 If you compile with -DDEBUG, a number of assertion checks are
374 enabled that will catch more memory errors. You probably won't be
375 able to make much sense of the actual assertion errors, but they
376 should help you locate incorrectly overwritten memory. The
377 checking is fairly extensive, and will slow down execution
378 noticeably. Calling malloc_stats or mallinfo with DEBUG set will
379 attempt to check every non-mmapped allocated and free chunk in the
380 course of computing the summmaries. (By nature, mmapped regions
381 cannot be checked very much automatically.)
383 Setting DEBUG may also be helpful if you are trying to modify
384 this code. The assertions in the check routines spell out in more
385 detail the assumptions and invariants underlying the algorithms.
387 */
389 #if DEBUG
390 #include <assert.h>
391 #else
392 #define assert(x) ((void)0)
393 #endif
396 /*
397 SEPARATE_OBJECTS should be defined if you want each function to go
398 into a separate .o file. You must then compile malloc.c once per
399 function, defining the appropriate DEFINE_ macro. See below for the
400 list of macros.
401 */
403 #ifndef SEPARATE_OBJECTS
404 #define DEFINE_MALLOC
405 #define DEFINE_FREE
406 #define DEFINE_REALLOC
407 #define DEFINE_CALLOC
408 #define DEFINE_CFREE
409 #define DEFINE_MEMALIGN
410 #define DEFINE_VALLOC
411 #define DEFINE_PVALLOC
412 #define DEFINE_MALLINFO
413 #define DEFINE_MALLOC_STATS
414 #define DEFINE_MALLOC_USABLE_SIZE
415 #define DEFINE_MALLOPT
417 #define STATIC static
418 #else
419 #define STATIC
420 #endif
422 /*
423 Define MALLOC_LOCK and MALLOC_UNLOCK to C expressions to run to
424 lock and unlock the malloc data structures. MALLOC_LOCK may be
425 called recursively.
426 */
428 #ifndef MALLOC_LOCK
429 #define MALLOC_LOCK
430 #endif
432 #ifndef MALLOC_UNLOCK
433 #define MALLOC_UNLOCK
434 #endif
436 /*
437 INTERNAL_SIZE_T is the word-size used for internal bookkeeping
438 of chunk sizes. On a 64-bit machine, you can reduce malloc
439 overhead by defining INTERNAL_SIZE_T to be a 32 bit `unsigned int'
440 at the expense of not being able to handle requests greater than
441 2^31. This limitation is hardly ever a concern; you are encouraged
442 to set this. However, the default version is the same as size_t.
443 */
445 #ifndef INTERNAL_SIZE_T
446 #define INTERNAL_SIZE_T size_t
447 #endif
449 /*
450 Following is needed on implementations whereby long > size_t.
451 The problem is caused because the code performs subtractions of
452 size_t values and stores the result in long values. In the case
453 where long > size_t and the first value is actually less than
454 the second value, the resultant value is positive. For example,
455 (long)(x - y) where x = 0 and y is 1 ends up being 0x00000000FFFFFFFF
456 which is 2*31 - 1 instead of 0xFFFFFFFFFFFFFFFF. This is due to the
457 fact that assignment from unsigned to signed won't sign extend.
458 */
460 #define long_sub_size_t(x, y) \
461 (sizeof (long) > sizeof (INTERNAL_SIZE_T) && x < y \
462 ? -(long) (y - x) \
463 : (long) (x - y))
465 /*
466 REALLOC_ZERO_BYTES_FREES should be set if a call to
467 realloc with zero bytes should be the same as a call to free.
468 Some people think it should. Otherwise, since this malloc
469 returns a unique pointer for malloc(0), so does realloc(p, 0).
470 */
473 /* #define REALLOC_ZERO_BYTES_FREES */
476 /*
477 WIN32 causes an emulation of sbrk to be compiled in
478 mmap-based options are not currently supported in WIN32.
479 */
481 /* #define WIN32 */
482 #ifdef WIN32
483 #define MORECORE wsbrk
484 #define HAVE_MMAP 0
485 #endif
488 /*
489 HAVE_MEMCPY should be defined if you are not otherwise using
490 ANSI STD C, but still have memcpy and memset in your C library
491 and want to use them in calloc and realloc. Otherwise simple
492 macro versions are defined here.
494 USE_MEMCPY should be defined as 1 if you actually want to
495 have memset and memcpy called. People report that the macro
496 versions are often enough faster than libc versions on many
497 systems that it is better to use them.
499 */
501 #define HAVE_MEMCPY
503 /* Although the original macro is called USE_MEMCPY, newlib actually
504 uses memmove to handle cases whereby a platform's memcpy implementation
505 copies backwards and thus destructive overlap may occur in realloc
506 whereby we are reclaiming free memory prior to the old allocation. */
507 #ifndef USE_MEMCPY
508 #ifdef HAVE_MEMCPY
509 #define USE_MEMCPY 1
510 #else
511 #define USE_MEMCPY 0
512 #endif
513 #endif
515 #if (__STD_C || defined(HAVE_MEMCPY))
517 #if __STD_C
521 #else
525 #endif
526 #endif
528 #if USE_MEMCPY
530 /* The following macros are only invoked with (2n+1)-multiples of
531 INTERNAL_SIZE_T units, with a positive integer n. This is exploited
532 for fast inline execution when n is small. */
534 #define MALLOC_ZERO(charp, nbytes) \
535 do { \
536 INTERNAL_SIZE_T mzsz = (nbytes); \
537 if(mzsz <= 9*sizeof(mzsz)) { \
538 INTERNAL_SIZE_T* mz = (INTERNAL_SIZE_T*) (charp); \
539 if(mzsz >= 5*sizeof(mzsz)) { *mz++ = 0; \
540 *mz++ = 0; \
541 if(mzsz >= 7*sizeof(mzsz)) { *mz++ = 0; \
542 *mz++ = 0; \
543 if(mzsz >= 9*sizeof(mzsz)) { *mz++ = 0; \
544 *mz++ = 0; }}} \
545 *mz++ = 0; \
546 *mz++ = 0; \
547 *mz = 0; \
548 } else memset((charp), 0, mzsz); \
549 } while(0)
551 #define MALLOC_COPY(dest,src,nbytes) \
552 do { \
553 INTERNAL_SIZE_T mcsz = (nbytes); \
554 if(mcsz <= 9*sizeof(mcsz)) { \
555 INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) (src); \
556 INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) (dest); \
557 if(mcsz >= 5*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
558 *mcdst++ = *mcsrc++; \
559 if(mcsz >= 7*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
560 *mcdst++ = *mcsrc++; \
561 if(mcsz >= 9*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
562 *mcdst++ = *mcsrc++; }}} \
563 *mcdst++ = *mcsrc++; \
564 *mcdst++ = *mcsrc++; \
565 *mcdst = *mcsrc ; \
566 } else memmove(dest, src, mcsz); \
567 } while(0)
571 /* Use Duff's device for good zeroing/copying performance. */
573 #define MALLOC_ZERO(charp, nbytes) \
574 do { \
575 INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
576 long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \
577 if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
578 switch (mctmp) { \
579 case 0: for(;;) { *mzp++ = 0; \
580 case 7: *mzp++ = 0; \
581 case 6: *mzp++ = 0; \
582 case 5: *mzp++ = 0; \
583 case 4: *mzp++ = 0; \
584 case 3: *mzp++ = 0; \
585 case 2: *mzp++ = 0; \
586 case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
587 } \
588 } while(0)
590 #define MALLOC_COPY(dest,src,nbytes) \
591 do { \
592 INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
593 INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
594 long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \
595 if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
596 switch (mctmp) { \
597 case 0: for(;;) { *mcdst++ = *mcsrc++; \
598 case 7: *mcdst++ = *mcsrc++; \
599 case 6: *mcdst++ = *mcsrc++; \
600 case 5: *mcdst++ = *mcsrc++; \
601 case 4: *mcdst++ = *mcsrc++; \
602 case 3: *mcdst++ = *mcsrc++; \
603 case 2: *mcdst++ = *mcsrc++; \
604 case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
605 } \
606 } while(0)
608 #endif
611 /*
612 Define HAVE_MMAP to optionally make malloc() use mmap() to
613 allocate very large blocks. These will be returned to the
614 operating system immediately after a free().
615 */
617 #ifndef HAVE_MMAP
618 #define HAVE_MMAP 1
619 #endif
621 /*
622 Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
623 large blocks. This is currently only possible on Linux with
624 kernel versions newer than 1.3.77.
625 */
627 #ifndef HAVE_MREMAP
628 #ifdef INTERNAL_LINUX_C_LIB
629 #define HAVE_MREMAP 1
630 #else
631 #define HAVE_MREMAP 0
632 #endif
633 #endif
635 #if HAVE_MMAP
637 #include <unistd.h>
638 #include <fcntl.h>
639 #include <sys/mman.h>
641 #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
642 #define MAP_ANONYMOUS MAP_ANON
643 #endif
647 /*
648 Access to system page size. To the extent possible, this malloc
649 manages memory from the system in page-size units.
651 The following mechanics for getpagesize were adapted from
652 bsd/gnu getpagesize.h
653 */
655 #ifndef LACKS_UNISTD_H
656 # include <unistd.h>
657 #endif
659 #ifndef malloc_getpagesize
661 # ifndef _SC_PAGE_SIZE
662 # define _SC_PAGE_SIZE _SC_PAGESIZE
663 # endif
664 # endif
665 # ifdef _SC_PAGE_SIZE
666 # define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
667 # else
668 # if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
670 # define malloc_getpagesize getpagesize()
671 # else
672 # include <sys/param.h>
673 # ifdef EXEC_PAGESIZE
674 # define malloc_getpagesize EXEC_PAGESIZE
675 # else
676 # ifdef NBPG
677 # ifndef CLSIZE
678 # define malloc_getpagesize NBPG
679 # else
680 # define malloc_getpagesize (NBPG * CLSIZE)
681 # endif
682 # else
683 # ifdef NBPC
684 # define malloc_getpagesize NBPC
685 # else
686 # ifdef PAGESIZE
687 # define malloc_getpagesize PAGESIZE
688 # else
690 # endif
691 # endif
692 # endif
693 # endif
694 # endif
695 # endif
696 #endif
700 /*
702 This version of malloc supports the standard SVID/XPG mallinfo
703 routine that returns a struct containing the same kind of
704 information you can get from malloc_stats. It should work on
705 any SVID/XPG compliant system that has a /usr/include/malloc.h
706 defining struct mallinfo. (If you'd like to install such a thing
707 yourself, cut out the preliminary declarations as described above
708 and below and save them in a malloc.h file. But there's no
709 compelling reason to bother to do this.)
711 The main declaration needed is the mallinfo struct that is returned
712 (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
713 bunch of fields, most of which are not even meaningful in this
714 version of malloc. Some of these fields are are instead filled by
715 mallinfo() with other numbers that might possibly be of interest.
717 HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
718 /usr/include/malloc.h file that includes a declaration of struct
719 mallinfo. If so, it is included; else an SVID2/XPG2 compliant
720 version is declared below. These must be precisely the same for
721 mallinfo() to work.
723 */
725 /* #define HAVE_USR_INCLUDE_MALLOC_H */
727 #if HAVE_USR_INCLUDE_MALLOC_H
729 #else
731 /* SVID2/XPG mallinfo structure */
744 };
746 /* SVID2/XPG mallopt options */
753 #endif
755 /* mallopt options that actually do something */
757 #define M_TRIM_THRESHOLD -1
758 #define M_TOP_PAD -2
759 #define M_MMAP_THRESHOLD -3
760 #define M_MMAP_MAX -4
764 #ifndef DEFAULT_TRIM_THRESHOLD
765 #define DEFAULT_TRIM_THRESHOLD (128L * 1024L)
766 #endif
768 /*
769 M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
770 to keep before releasing via malloc_trim in free().
772 Automatic trimming is mainly useful in long-lived programs.
773 Because trimming via sbrk can be slow on some systems, and can
774 sometimes be wasteful (in cases where programs immediately
775 afterward allocate more large chunks) the value should be high
776 enough so that your overall system performance would improve by
777 releasing.
779 The trim threshold and the mmap control parameters (see below)
780 can be traded off with one another. Trimming and mmapping are
781 two different ways of releasing unused memory back to the
782 system. Between these two, it is often possible to keep
783 system-level demands of a long-lived program down to a bare
784 minimum. For example, in one test suite of sessions measuring
785 the XF86 X server on Linux, using a trim threshold of 128K and a
786 mmap threshold of 192K led to near-minimal long term resource
787 consumption.
789 If you are using this malloc in a long-lived program, it should
790 pay to experiment with these values. As a rough guide, you
791 might set to a value close to the average size of a process
792 (program) running on your system. Releasing this much memory
793 would allow such a process to run in memory. Generally, it's
794 worth it to tune for trimming rather tham memory mapping when a
795 program undergoes phases where several large chunks are
796 allocated and released in ways that can reuse each other's
797 storage, perhaps mixed with phases where there are no such
798 chunks at all. And in well-behaved long-lived programs,
799 controlling release of large blocks via trimming versus mapping
800 is usually faster.
802 However, in most programs, these parameters serve mainly as
803 protection against the system-level effects of carrying around
804 massive amounts of unneeded memory. Since frequent calls to
805 sbrk, mmap, and munmap otherwise degrade performance, the default
806 parameters are set to relatively high values that serve only as
807 safeguards.
809 The default trim value is high enough to cause trimming only in
810 fairly extreme (by current memory consumption standards) cases.
811 It must be greater than page size to have any useful effect. To
812 disable trimming completely, you can set to (unsigned long)(-1);
815 */
818 #ifndef DEFAULT_TOP_PAD
819 #define DEFAULT_TOP_PAD (0)
820 #endif
822 /*
823 M_TOP_PAD is the amount of extra `padding' space to allocate or
824 retain whenever sbrk is called. It is used in two ways internally:
826 * When sbrk is called to extend the top of the arena to satisfy
827 a new malloc request, this much padding is added to the sbrk
828 request.
830 * When malloc_trim is called automatically from free(),
831 it is used as the `pad' argument.
833 In both cases, the actual amount of padding is rounded
834 so that the end of the arena is always a system page boundary.
836 The main reason for using padding is to avoid calling sbrk so
837 often. Having even a small pad greatly reduces the likelihood
838 that nearly every malloc request during program start-up (or
839 after trimming) will invoke sbrk, which needlessly wastes
840 time.
842 Automatic rounding-up to page-size units is normally sufficient
843 to avoid measurable overhead, so the default is 0. However, in
844 systems where sbrk is relatively slow, it can pay to increase
845 this value, at the expense of carrying around more memory than
846 the program needs.
848 */
851 #ifndef DEFAULT_MMAP_THRESHOLD
852 #define DEFAULT_MMAP_THRESHOLD (128 * 1024)
853 #endif
855 /*
857 M_MMAP_THRESHOLD is the request size threshold for using mmap()
858 to service a request. Requests of at least this size that cannot
859 be allocated using already-existing space will be serviced via mmap.
860 (If enough normal freed space already exists it is used instead.)
862 Using mmap segregates relatively large chunks of memory so that
863 they can be individually obtained and released from the host
864 system. A request serviced through mmap is never reused by any
865 other request (at least not directly; the system may just so
866 happen to remap successive requests to the same locations).
868 Segregating space in this way has the benefit that mmapped space
869 can ALWAYS be individually released back to the system, which
870 helps keep the system level memory demands of a long-lived
871 program low. Mapped memory can never become `locked' between
872 other chunks, as can happen with normally allocated chunks, which
873 menas that even trimming via malloc_trim would not release them.
875 However, it has the disadvantages that:
877 1. The space cannot be reclaimed, consolidated, and then
878 used to service later requests, as happens with normal chunks.
879 2. It can lead to more wastage because of mmap page alignment
880 requirements
881 3. It causes malloc performance to be more dependent on host
882 system memory management support routines which may vary in
883 implementation quality and may impose arbitrary
884 limitations. Generally, servicing a request via normal
885 malloc steps is faster than going through a system's mmap.
887 All together, these considerations should lead you to use mmap
888 only for relatively large requests.
891 */
895 #ifndef DEFAULT_MMAP_MAX
896 #if HAVE_MMAP
897 #define DEFAULT_MMAP_MAX (64)
898 #else
899 #define DEFAULT_MMAP_MAX (0)
900 #endif
901 #endif
903 /*
904 M_MMAP_MAX is the maximum number of requests to simultaneously
905 service using mmap. This parameter exists because:
907 1. Some systems have a limited number of internal tables for
908 use by mmap.
909 2. In most systems, overreliance on mmap can degrade overall
910 performance.
911 3. If a program allocates many large regions, it is probably
912 better off using normal sbrk-based allocation routines that
913 can reclaim and reallocate normal heap memory. Using a
914 small value allows transition into this mode after the
915 first few allocations.
917 Setting to 0 disables all use of mmap. If HAVE_MMAP is not set,
918 the default value is 0, and attempts to set it to non-zero values
919 in mallopt will fail.
920 */
925 /*
927 Special defines for linux libc
929 Except when compiled using these special defines for Linux libc
930 using weak aliases, this malloc is NOT designed to work in
931 multithreaded applications. No semaphores or other concurrency
932 control are provided to ensure that multiple malloc or free calls
933 don't run at the same time, which could be disasterous. A single
934 semaphore could be used across malloc, realloc, and free (which is
935 essentially the effect of the linux weak alias approach). It would
936 be hard to obtain finer granularity.
938 */
941 #ifdef INTERNAL_LINUX_C_LIB
943 #if __STD_C
948 #else
953 #endif
955 #define MORECORE (*__morecore)
956 #define MORECORE_FAILURE 0
957 #define MORECORE_CLEARS 1
961 #ifndef _LIBC
962 #if __STD_C
964 #else
966 #endif
967 #endif
969 #ifndef MORECORE
970 #define MORECORE sbrk
971 #endif
973 #ifndef MORECORE_FAILURE
974 #define MORECORE_FAILURE -1
975 #endif
977 #ifndef MORECORE_CLEARS
978 #define MORECORE_CLEARS 1
979 #endif
983 #if defined(INTERNAL_LINUX_C_LIB) && defined(__ELF__)
985 #define cALLOc __libc_calloc
986 #define fREe __libc_free
987 #define mALLOc __libc_malloc
988 #define mEMALIGn __libc_memalign
989 #define rEALLOc __libc_realloc
990 #define vALLOc __libc_valloc
991 #define pvALLOc __libc_pvalloc
992 #define mALLINFo __libc_mallinfo
993 #define mALLOPt __libc_mallopt
995 #pragma weak calloc = __libc_calloc
996 #pragma weak free = __libc_free
997 #pragma weak cfree = __libc_free
998 #pragma weak malloc = __libc_malloc
999 #pragma weak memalign = __libc_memalign
1000 #pragma weak realloc = __libc_realloc
1001 #pragma weak valloc = __libc_valloc
1002 #pragma weak pvalloc = __libc_pvalloc
1003 #pragma weak mallinfo = __libc_mallinfo
1004 #pragma weak mallopt = __libc_mallopt
1006 #else
1008 #ifdef _LIBC
1010 #define cALLOc _calloc_r
1011 #define fREe _free_r
1012 #define mALLOc _malloc_r
1013 #define mEMALIGn _memalign_r
1014 #define rEALLOc _realloc_r
1015 #define vALLOc _valloc_r
1016 #define pvALLOc _pvalloc_r
1017 #define mALLINFo _mallinfo_r
1018 #define mALLOPt _mallopt_r
1020 #define malloc_stats _malloc_stats_r
1021 #define malloc_trim _malloc_trim_r
1022 #define malloc_usable_size _malloc_usable_size_r
1024 #define malloc_update_mallinfo __malloc_update_mallinfo
1026 #define malloc_av_ __malloc_av_
1027 #define malloc_current_mallinfo __malloc_current_mallinfo
1028 #define malloc_max_sbrked_mem __malloc_max_sbrked_mem
1029 #define malloc_max_total_mem __malloc_max_total_mem
1030 #define malloc_sbrk_base __malloc_sbrk_base
1031 #define malloc_top_pad __malloc_top_pad
1032 #define malloc_trim_threshold __malloc_trim_threshold
1036 #define cALLOc calloc
1037 #define fREe free
1038 #define mALLOc malloc
1039 #define mEMALIGn memalign
1040 #define rEALLOc realloc
1041 #define vALLOc valloc
1042 #define pvALLOc pvalloc
1043 #define mALLINFo mallinfo
1044 #define mALLOPt mallopt
1047 #endif
1049 /* Public routines */
1051 #if __STD_C
1066 #else
1080 #endif
1083 #ifdef __cplusplus
1085 #endif
1087 /* ---------- To make a malloc.h, end cutting here ------------ */
1090 /*
1091 Emulation of sbrk for WIN32
1092 All code within the ifdef WIN32 is untested by me.
1093 */
1096 #ifdef WIN32
1098 #define AlignPage(add) (((add) + (malloc_getpagesize-1)) & \
1099 ~(malloc_getpagesize-1))
1101 /* resrve 64MB to insure large contiguous space */
1102 #define RESERVED_SIZE (1024*1024*64)
1103 #define NEXT_SIZE (2048*1024)
1104 #define TOP_MEMORY ((unsigned long)2*1024*1024*1024)
1109 struct GmListElement
1110 {
1113 };
1120 static
1122 {
1127 {
1131 }
1133 }
1136 {
1137 BOOL rval;
1140 {
1143 MEM_DECOMMIT);
1145 }
1147 {
1153 }
1154 }
1156 static
1158 {
1159 MEMORY_BASIC_INFORMATION info;
1161 {
1167 else
1169 }
1172 }
1176 {
1179 {
1181 {
1187 gAllocatedSize))
1188 {
1191 do
1192 {
1201 // repeat in case of race condition
1202 // The region that we found has been snagged
1203 // by another thread
1204 }
1213 }
1215 {
1223 }
1227 }
1229 {
1231 /* Trim by releasing the virtual memory */
1233 {
1235 MEM_DECOMMIT);
1238 }
1239 else
1240 {
1242 MEM_DECOMMIT);
1245 }
1246 }
1247 else
1248 {
1250 }
1251 }
1253 #endif
1255 \f
1257 /*
1258 Type declarations
1259 */
1262 struct malloc_chunk
1263 {
1268 };
1272 /*
1274 malloc_chunk details:
1276 (The following includes lightly edited explanations by Colin Plumb.)
1278 Chunks of memory are maintained using a `boundary tag' method as
1279 described in e.g., Knuth or Standish. (See the paper by Paul
1280 Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
1281 survey of such techniques.) Sizes of free chunks are stored both
1282 in the front of each chunk and at the end. This makes
1283 consolidating fragmented chunks into bigger chunks very fast. The
1284 size fields also hold bits representing whether chunks are free or
1285 in use.
1287 An allocated chunk looks like this:
1290 chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1291 | Size of previous chunk, if allocated | |
1292 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1293 | Size of chunk, in bytes |P|
1294 mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1295 | User data starts here... .
1296 . .
1297 . (malloc_usable_space() bytes) .
1298 . |
1299 nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1300 | Size of chunk |
1301 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1304 Where "chunk" is the front of the chunk for the purpose of most of
1305 the malloc code, but "mem" is the pointer that is returned to the
1306 user. "Nextchunk" is the beginning of the next contiguous chunk.
1308 Chunks always begin on even word boundries, so the mem portion
1309 (which is returned to the user) is also on an even word boundary, and
1310 thus double-word aligned.
1312 Free chunks are stored in circular doubly-linked lists, and look like this:
1314 chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1315 | Size of previous chunk |
1316 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1317 `head:' | Size of chunk, in bytes |P|
1318 mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1319 | Forward pointer to next chunk in list |
1320 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1321 | Back pointer to previous chunk in list |
1322 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1323 | Unused space (may be 0 bytes long) .
1324 . .
1325 . |
1326 nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1327 `foot:' | Size of chunk, in bytes |
1328 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1330 The P (PREV_INUSE) bit, stored in the unused low-order bit of the
1331 chunk size (which is always a multiple of two words), is an in-use
1332 bit for the *previous* chunk. If that bit is *clear*, then the
1333 word before the current chunk size contains the previous chunk
1334 size, and can be used to find the front of the previous chunk.
1335 (The very first chunk allocated always has this bit set,
1336 preventing access to non-existent (or non-owned) memory.)
1338 Note that the `foot' of the current chunk is actually represented
1339 as the prev_size of the NEXT chunk. (This makes it easier to
1340 deal with alignments etc).
1342 The two exceptions to all this are
1344 1. The special chunk `top', which doesn't bother using the
1345 trailing size field since there is no
1346 next contiguous chunk that would have to index off it. (After
1347 initialization, `top' is forced to always exist. If it would
1348 become less than MINSIZE bytes long, it is replenished via
1349 malloc_extend_top.)
1351 2. Chunks allocated via mmap, which have the second-lowest-order
1352 bit (IS_MMAPPED) set in their size fields. Because they are
1353 never merged or traversed from any other chunk, they have no
1354 foot size or inuse information.
1356 Available chunks are kept in any of several places (all declared below):
1358 * `av': An array of chunks serving as bin headers for consolidated
1359 chunks. Each bin is doubly linked. The bins are approximately
1360 proportionally (log) spaced. There are a lot of these bins
1361 (128). This may look excessive, but works very well in
1362 practice. All procedures maintain the invariant that no
1363 consolidated chunk physically borders another one. Chunks in
1364 bins are kept in size order, with ties going to the
1365 approximately least recently used chunk.
1367 The chunks in each bin are maintained in decreasing sorted order by
1368 size. This is irrelevant for the small bins, which all contain
1369 the same-sized chunks, but facilitates best-fit allocation for
1370 larger chunks. (These lists are just sequential. Keeping them in
1371 order almost never requires enough traversal to warrant using
1372 fancier ordered data structures.) Chunks of the same size are
1373 linked with the most recently freed at the front, and allocations
1374 are taken from the back. This results in LRU or FIFO allocation
1375 order, which tends to give each chunk an equal opportunity to be
1376 consolidated with adjacent freed chunks, resulting in larger free
1377 chunks and less fragmentation.
1379 * `top': The top-most available chunk (i.e., the one bordering the
1380 end of available memory) is treated specially. It is never
1381 included in any bin, is used only if no other chunk is
1382 available, and is released back to the system if it is very
1383 large (see M_TRIM_THRESHOLD).
1385 * `last_remainder': A bin holding only the remainder of the
1386 most recently split (non-top) chunk. This bin is checked
1387 before other non-fitting chunks, so as to provide better
1388 locality for runs of sequentially allocated chunks.
1390 * Implicitly, through the host system's memory mapping tables.
1391 If supported, requests greater than a threshold are usually
1392 serviced via calls to mmap, and then later released via munmap.
1394 */
1398 \f
1401 /* sizes, alignments */
1403 #define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
1404 #ifndef MALLOC_ALIGNMENT
1405 #define MALLOC_ALIGN 8
1406 #define MALLOC_ALIGNMENT (SIZE_SZ < 4 ? 8 : (SIZE_SZ + SIZE_SZ))
1407 #else
1408 #define MALLOC_ALIGN MALLOC_ALIGNMENT
1409 #endif
1410 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
1411 #define MINSIZE (sizeof(struct malloc_chunk))
1413 /* conversion from malloc headers to user pointers, and back */
1415 #define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
1416 #define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
1418 /* pad request bytes into a usable size */
1420 #define request2size(req) \
1421 (((unsigned long)((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) < \
1422 (unsigned long)(MINSIZE + MALLOC_ALIGN_MASK)) ? ((MINSIZE + MALLOC_ALIGN_MASK) & ~(MALLOC_ALIGN_MASK)) : \
1423 (((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) & ~(MALLOC_ALIGN_MASK)))
1425 /* Check if m has acceptable alignment */
1427 #define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
1430 \f
1432 /*
1433 Physical chunk operations
1434 */
1437 /* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
1439 #define PREV_INUSE 0x1
1441 /* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
1443 #define IS_MMAPPED 0x2
1445 /* Bits to mask off when extracting size */
1447 #define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
1450 /* Ptr to next physical malloc_chunk. */
1452 #define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
1454 /* Ptr to previous physical malloc_chunk */
1456 #define prev_chunk(p)\
1457 ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
1460 /* Treat space at ptr + offset as a chunk */
1462 #define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
1465 \f
1467 /*
1468 Dealing with use bits
1469 */
1471 /* extract p's inuse bit */
1473 #define inuse(p)\
1474 ((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
1476 /* extract inuse bit of previous chunk */
1478 #define prev_inuse(p) ((p)->size & PREV_INUSE)
1480 /* check for mmap()'ed chunk */
1482 #define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
1484 /* set/clear chunk as in use without otherwise disturbing */
1486 #define set_inuse(p)\
1487 ((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
1489 #define clear_inuse(p)\
1490 ((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
1492 /* check/set/clear inuse bits in known places */
1494 #define inuse_bit_at_offset(p, s)\
1495 (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
1497 #define set_inuse_bit_at_offset(p, s)\
1498 (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
1500 #define clear_inuse_bit_at_offset(p, s)\
1501 (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
1504 \f
1506 /*
1507 Dealing with size fields
1508 */
1510 /* Get size, ignoring use bits */
1512 #define chunksize(p) ((p)->size & ~(SIZE_BITS))
1514 /* Set size at head, without disturbing its use bit */
1516 #define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
1518 /* Set size/use ignoring previous bits in header */
1520 #define set_head(p, s) ((p)->size = (s))
1522 /* Set size at footer (only when chunk is not in use) */
1524 #define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
1527 \f
1530 /*
1531 Bins
1533 The bins, `av_' are an array of pairs of pointers serving as the
1534 heads of (initially empty) doubly-linked lists of chunks, laid out
1535 in a way so that each pair can be treated as if it were in a
1536 malloc_chunk. (This way, the fd/bk offsets for linking bin heads
1537 and chunks are the same).
1539 Bins for sizes < 512 bytes contain chunks of all the same size, spaced
1540 8 bytes apart. Larger bins are approximately logarithmically
1541 spaced. (See the table below.) The `av_' array is never mentioned
1542 directly in the code, but instead via bin access macros.
1544 Bin layout:
1546 64 bins of size 8
1547 32 bins of size 64
1548 16 bins of size 512
1549 8 bins of size 4096
1550 4 bins of size 32768
1551 2 bins of size 262144
1552 1 bin of size what's left
1554 There is actually a little bit of slop in the numbers in bin_index
1555 for the sake of speed. This makes no difference elsewhere.
1557 The special chunks `top' and `last_remainder' get their own bins,
1558 (this is implemented via yet more trickery with the av_ array),
1559 although `top' is never properly linked to its bin since it is
1560 always handled specially.
1562 */
1564 #ifdef SEPARATE_OBJECTS
1565 #define av_ malloc_av_
1566 #endif
1572 /* access macros */
1574 #define bin_at(i) ((mbinptr)((char*)&(av_[2*(i) + 2]) - 2*SIZE_SZ))
1575 #define next_bin(b) ((mbinptr)((char*)(b) + 2 * sizeof(mbinptr)))
1576 #define prev_bin(b) ((mbinptr)((char*)(b) - 2 * sizeof(mbinptr)))
1578 /*
1579 The first 2 bins are never indexed. The corresponding av_ cells are instead
1580 used for bookkeeping. This is not to save space, but to simplify
1581 indexing, maintain locality, and avoid some initialization tests.
1582 */
1588 /*
1589 Because top initially points to its own bin with initial
1590 zero size, thus forcing extension on the first malloc request,
1591 we avoid having any special code in malloc to check whether
1592 it even exists yet. But we still need to in malloc_extend_top.
1593 */
1595 #define initial_top ((mchunkptr)(bin_at(0)))
1597 /* Helper macro to initialize bins */
1599 #define IAV(i) bin_at(i), bin_at(i)
1601 #ifdef DEFINE_MALLOC
1620 };
1621 #else
1623 #endif
1625 \f
1627 /* field-extraction macros */
1629 #define first(b) ((b)->fd)
1630 #define last(b) ((b)->bk)
1632 /*
1633 Indexing into bins
1634 */
1636 #define bin_index(sz) \
1637 (((((unsigned long)(sz)) >> 9) == 0) ? (((unsigned long)(sz)) >> 3): \
1638 ((((unsigned long)(sz)) >> 9) <= 4) ? 56 + (((unsigned long)(sz)) >> 6): \
1639 ((((unsigned long)(sz)) >> 9) <= 20) ? 91 + (((unsigned long)(sz)) >> 9): \
1640 ((((unsigned long)(sz)) >> 9) <= 84) ? 110 + (((unsigned long)(sz)) >> 12): \
1641 ((((unsigned long)(sz)) >> 9) <= 340) ? 119 + (((unsigned long)(sz)) >> 15): \
1642 ((((unsigned long)(sz)) >> 9) <= 1364) ? 124 + (((unsigned long)(sz)) >> 18): \
1643 126)
1644 /*
1645 bins for chunks < 512 are all spaced SMALLBIN_WIDTH bytes apart, and hold
1646 identically sized chunks. This is exploited in malloc.
1647 */
1649 #define MAX_SMALLBIN_SIZE 512
1650 #define SMALLBIN_WIDTH 8
1651 #define SMALLBIN_WIDTH_BITS 3
1652 #define MAX_SMALLBIN (MAX_SMALLBIN_SIZE / SMALLBIN_WIDTH) - 1
1654 #define smallbin_index(sz) (((unsigned long)(sz)) >> SMALLBIN_WIDTH_BITS)
1656 /*
1657 Requests are `small' if both the corresponding and the next bin are small
1658 */
1660 #define is_small_request(nb) (nb < MAX_SMALLBIN_SIZE - SMALLBIN_WIDTH)
1662 \f
1664 /*
1665 To help compensate for the large number of bins, a one-level index
1666 structure is used for bin-by-bin searching. `binblocks' is a
1667 one-word bitvector recording whether groups of BINBLOCKWIDTH bins
1668 have any (possibly) non-empty bins, so they can be skipped over
1669 all at once during during traversals. The bits are NOT always
1670 cleared as soon as all bins in a block are empty, but instead only
1671 when all are noticed to be empty during traversal in malloc.
1672 */
1678 /* bin<->block macros */
1680 #define idx2binblock(ix) ((unsigned long)1 << (ix / BINBLOCKWIDTH))
1681 #define mark_binblock(ii) (binblocks |= idx2binblock(ii))
1682 #define clear_binblock(ii) (binblocks &= ~(idx2binblock(ii)))
1685 \f
1688 /* Other static bookkeeping data */
1690 #ifdef SEPARATE_OBJECTS
1691 #define trim_threshold malloc_trim_threshold
1692 #define top_pad malloc_top_pad
1693 #define n_mmaps_max malloc_n_mmaps_max
1694 #define mmap_threshold malloc_mmap_threshold
1695 #define sbrk_base malloc_sbrk_base
1696 #define max_sbrked_mem malloc_max_sbrked_mem
1697 #define max_total_mem malloc_max_total_mem
1698 #define current_mallinfo malloc_current_mallinfo
1699 #define n_mmaps malloc_n_mmaps
1700 #define max_n_mmaps malloc_max_n_mmaps
1701 #define mmapped_mem malloc_mmapped_mem
1702 #define max_mmapped_mem malloc_max_mmapped_mem
1703 #endif
1705 /* variables holding tunable values */
1707 #ifdef DEFINE_MALLOC
1711 #if HAVE_MMAP
1714 #endif
1716 /* The first value returned from sbrk */
1719 /* The maximum memory obtained from system via sbrk */
1722 /* The maximum via either sbrk or mmap */
1725 /* internal working copy of mallinfo */
1728 #if HAVE_MMAP
1730 /* Tracking mmaps */
1737 #endif
1743 #if HAVE_MMAP
1746 #endif
1751 #if HAVE_MMAP
1756 #endif
1760 /* The total memory obtained from system via sbrk */
1761 #define sbrked_mem (current_mallinfo.arena)
1763 \f
1765 /*
1766 Debugging support
1767 */
1769 #if DEBUG
1772 /*
1773 These routines make a number of assertions about the states
1774 of data structures that should be true at all times. If any
1775 are not true, it's very likely that a user program has somehow
1776 trashed memory. (It's also possible that there is a coding error
1777 in malloc. In which case, please report it!)
1778 */
1780 #if __STD_C
1782 #else
1784 #endif
1785 {
1788 /* No checkable chunk is mmapped */
1791 /* Check for legal address ... */
1795 else
1798 }
1801 #if __STD_C
1803 #else
1805 #endif
1806 {
1812 /* Check whether it claims to be free ... */
1815 /* Unless a special marker, must have OK fields */
1817 {
1820 /* ... matching footer field */
1822 /* ... and is fully consolidated */
1826 /* ... and has minimally sane links */
1829 }
1832 }
1834 #if __STD_C
1836 #else
1838 #endif
1839 {
1843 /* Check whether it claims to be in use ... */
1846 /* ... and is surrounded by OK chunks.
1847 Since more things can be checked with free chunks than inuse ones,
1848 if an inuse chunk borders them and debug is on, it's worth doing them.
1849 */
1851 {
1855 }
1857 {
1860 }
1864 }
1866 #if __STD_C
1868 #else
1870 #endif
1871 {
1877 /* Legal size ... */
1883 /* ... and alignment */
1887 /* ... and was allocated at front of an available chunk */
1890 }
1893 #define check_free_chunk(P) do_check_free_chunk(P)
1894 #define check_inuse_chunk(P) do_check_inuse_chunk(P)
1895 #define check_chunk(P) do_check_chunk(P)
1896 #define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
1897 #else
1898 #define check_free_chunk(P)
1899 #define check_inuse_chunk(P)
1900 #define check_chunk(P)
1901 #define check_malloced_chunk(P,N)
1902 #endif
1904 \f
1906 /*
1907 Macro-based internal utilities
1908 */
1911 /*
1912 Linking chunks in bin lists.
1913 Call these only with variables, not arbitrary expressions, as arguments.
1914 */
1916 /*
1917 Place chunk p of size s in its bin, in size order,
1918 putting it ahead of others of same size.
1919 */
1922 #define frontlink(P, S, IDX, BK, FD) \
1923 { \
1924 if (S < MAX_SMALLBIN_SIZE) \
1925 { \
1926 IDX = smallbin_index(S); \
1927 mark_binblock(IDX); \
1928 BK = bin_at(IDX); \
1929 FD = BK->fd; \
1930 P->bk = BK; \
1931 P->fd = FD; \
1932 FD->bk = BK->fd = P; \
1933 } \
1934 else \
1935 { \
1936 IDX = bin_index(S); \
1937 BK = bin_at(IDX); \
1938 FD = BK->fd; \
1939 if (FD == BK) mark_binblock(IDX); \
1940 else \
1941 { \
1942 while (FD != BK && S < chunksize(FD)) FD = FD->fd; \
1943 BK = FD->bk; \
1944 } \
1945 P->bk = BK; \
1946 P->fd = FD; \
1947 FD->bk = BK->fd = P; \
1948 } \
1949 }
1952 /* take a chunk off a list */
1954 #define unlink(P, BK, FD) \
1955 { \
1956 BK = P->bk; \
1957 FD = P->fd; \
1958 FD->bk = BK; \
1959 BK->fd = FD; \
1960 } \
1962 /* Place p as the last remainder */
1964 #define link_last_remainder(P) \
1965 { \
1966 last_remainder->fd = last_remainder->bk = P; \
1967 P->fd = P->bk = last_remainder; \
1968 }
1970 /* Clear the last_remainder bin */
1972 #define clear_last_remainder \
1973 (last_remainder->fd = last_remainder->bk = last_remainder)
1977 \f
1980 /* Routines dealing with mmap(). */
1982 #if HAVE_MMAP
1984 #ifdef DEFINE_MALLOC
1986 #if __STD_C
1988 #else
1990 #endif
1991 {
1993 mchunkptr p;
1995 #ifndef MAP_ANONYMOUS
1997 #endif
2001 /* For mmapped chunks, the overhead is one SIZE_SZ unit larger, because
2002 * there is no following chunk whose prev_size field could be used.
2003 */
2006 #ifdef MAP_ANONYMOUS
2011 {
2014 }
2016 #endif
2020 n_mmaps++;
2023 /* We demand that eight bytes into a page must be 8-byte aligned. */
2026 /* The offset to the start of the mmapped region is stored
2027 * in the prev_size field of the chunk; normally it is zero,
2028 * but that can be changed in memalign().
2029 */
2039 }
2043 #ifdef SEPARATE_OBJECTS
2044 #define munmap_chunk malloc_munmap_chunk
2045 #endif
2047 #ifdef DEFINE_FREE
2049 #if __STD_C
2051 #else
2053 #endif
2054 {
2063 n_mmaps--;
2068 /* munmap returns non-zero on failure */
2070 }
2074 #if __STD_C
2076 #else
2078 #endif
2082 #if HAVE_MREMAP
2084 #ifdef DEFINE_REALLOC
2086 #if __STD_C
2088 #else
2090 #endif
2091 {
2102 /* Note the extra SIZE_SZ overhead as in mmap_chunk(). */
2123 }
2132 \f
2134 #ifdef DEFINE_MALLOC
2136 /*
2137 Extend the top-most chunk by obtaining memory from system.
2138 Main interface to sbrk (but see also malloc_trim).
2139 */
2141 #if __STD_C
2143 #else
2145 #endif
2146 {
2158 /* Pad request with top_pad plus minimal overhead */
2163 /* If not the first time through, round to preserve page boundary */
2164 /* Otherwise, we need to correct to a page size below anyway. */
2165 /* (We also correct below if an intervening foreign sbrk call.) */
2172 /* Fail if sbrk failed or if a foreign sbrk call killed our space */
2180 previous correction failed */
2182 {
2185 }
2186 else
2187 {
2193 /* Guarantee alignment of first new chunk made from this space */
2196 {
2199 }
2200 else
2203 /* Guarantee the next brk will be at a page boundary */
2206 /* To guarantee page boundary, correction should be less than pagesz */
2209 /* Allocate correction */
2212 {
2218 }
2227 {
2229 /* There must have been an intervening foreign sbrk call. */
2230 /* A double fencepost is necessary to prevent consolidation */
2232 /* If not enough space to do this, then user did something very wrong */
2234 {
2237 }
2239 /* Also keep size a multiple of MALLOC_ALIGNMENT */
2246 /* If possible, release the rest. */
2249 }
2250 }
2254 #if HAVE_MMAP
2257 #else
2260 #endif
2262 /* We always land on a page boundary */
2265 }
2268 \f
2270 /* Main public routines */
2272 #ifdef DEFINE_MALLOC
2274 /*
2275 Malloc Algorthim:
2277 The requested size is first converted into a usable form, `nb'.
2278 This currently means to add 4 bytes overhead plus possibly more to
2279 obtain 8-byte alignment and/or to obtain a size of at least
2280 MINSIZE (currently 16 bytes), the smallest allocatable size.
2281 (All fits are considered `exact' if they are within MINSIZE bytes.)
2283 From there, the first successful of the following steps is taken:
2285 1. The bin corresponding to the request size is scanned, and if
2286 a chunk of exactly the right size is found, it is taken.
2288 2. The most recently remaindered chunk is used if it is big
2289 enough. This is a form of (roving) first fit, used only in
2290 the absence of exact fits. Runs of consecutive requests use
2291 the remainder of the chunk used for the previous such request
2292 whenever possible. This limited use of a first-fit style
2293 allocation strategy tends to give contiguous chunks
2294 coextensive lifetimes, which improves locality and can reduce
2295 fragmentation in the long run.
2297 3. Other bins are scanned in increasing size order, using a
2298 chunk big enough to fulfill the request, and splitting off
2299 any remainder. This search is strictly by best-fit; i.e.,
2300 the smallest (with ties going to approximately the least
2301 recently used) chunk that fits is selected.
2303 4. If large enough, the chunk bordering the end of memory
2304 (`top') is split off. (This use of `top' is in accord with
2305 the best-fit search rule. In effect, `top' is treated as
2306 larger (and thus less well fitting) than any other available
2307 chunk since it can be extended to be as large as necessary
2308 (up to system limitations).
2310 5. If the request size meets the mmap threshold and the
2311 system supports mmap, and there are few enough currently
2312 allocated mmapped regions, and a call to mmap succeeds,
2313 the request is allocated via direct memory mapping.
2315 6. Otherwise, the top of memory is extended by
2316 obtaining more space from the system (normally using sbrk,
2317 but definable to anything else via the MORECORE macro).
2318 Memory is gathered from the system (in system page-sized
2319 units) in a way that allows chunks obtained across different
2320 sbrk calls to be consolidated, but does not require
2321 contiguous memory. Thus, it should be safe to intersperse
2322 mallocs with other sbrk calls.
2325 All allocations are made from the the `lowest' part of any found
2326 chunk. (The implementation invariant is that prev_inuse is
2327 always true of any allocated chunk; i.e., that each allocated
2328 chunk borders either a previously allocated and still in-use chunk,
2329 or the base of its memory arena.)
2331 */
2333 #if __STD_C
2335 #else
2337 #endif
2338 {
2339 #ifdef MALLOC_PROVIDED
2343 #else
2360 /* Check for overflow and just fail, if so. */
2362 {
2365 }
2367 MALLOC_LOCK;
2369 /* Check for exact match in a bin */
2372 {
2375 /* No traversal or size check necessary for small bins. */
2380 #if MALLOC_ALIGN != 16
2381 /* Also scan the next one, since it would have a remainder < MINSIZE */
2383 {
2386 }
2387 #endif
2389 {
2394 MALLOC_UNLOCK;
2396 }
2400 }
2401 else
2402 {
2407 {
2412 {
2415 }
2418 {
2422 MALLOC_UNLOCK;
2424 }
2425 }
2429 }
2431 /* Try to use the last split-off remainder */
2434 {
2439 {
2446 MALLOC_UNLOCK;
2448 }
2450 clear_last_remainder;
2453 {
2456 MALLOC_UNLOCK;
2458 }
2460 /* Else place in bin */
2463 }
2465 /*
2466 If there are any possibly nonempty big-enough blocks,
2467 search for best fitting chunk by scanning bins in blockwidth units.
2468 */
2471 {
2473 /* Get to the first marked block */
2476 {
2477 /* force to an even block boundary */
2481 {
2484 }
2485 }
2487 /* For each possibly nonempty block ... */
2489 {
2493 /* For each bin in this block ... */
2494 do
2495 {
2496 /* Find and use first big enough chunk ... */
2499 {
2504 {
2512 MALLOC_UNLOCK;
2514 }
2517 {
2521 MALLOC_UNLOCK;
2523 }
2525 }
2529 #if MALLOC_ALIGN == 16
2531 {
2534 }
2535 #endif
2538 /* Clear out the block bit. */
2541 {
2543 {
2546 }
2551 /* Get to the next possibly nonempty block */
2554 {
2556 {
2559 }
2560 }
2561 else
2563 }
2564 }
2567 /* Try to use top chunk */
2569 /* Require that there be a remainder, ensuring top always exists */
2572 {
2574 #if HAVE_MMAP
2575 /* If big and would otherwise need to extend, try to use mmap instead */
2578 {
2579 MALLOC_UNLOCK;
2581 }
2582 #endif
2584 /* Try to extend */
2588 {
2589 MALLOC_UNLOCK;
2591 }
2592 }
2599 MALLOC_UNLOCK;
2603 }
2606 \f
2607 #ifdef DEFINE_FREE
2609 /*
2611 free() algorithm :
2613 cases:
2615 1. free(0) has no effect.
2617 2. If the chunk was allocated via mmap, it is release via munmap().
2619 3. If a returned chunk borders the current high end of memory,
2620 it is consolidated into the top, and if the total unused
2621 topmost memory exceeds the trim threshold, malloc_trim is
2622 called.
2624 4. Other chunks are consolidated as they arrive, and
2625 placed in corresponding bins. (This includes the case of
2626 consolidating with the current `last_remainder').
2628 */
2631 #if __STD_C
2633 #else
2635 #endif
2636 {
2637 #ifdef MALLOC_PROVIDED
2641 #else
2657 MALLOC_LOCK;
2662 #if HAVE_MMAP
2664 {
2666 MALLOC_UNLOCK;
2668 }
2669 #endif
2678 {
2682 {
2687 }
2693 MALLOC_UNLOCK;
2695 }
2702 {
2709 else
2711 }
2714 {
2718 {
2721 }
2722 else
2724 }
2732 MALLOC_UNLOCK;
2735 }
2738 \f
2739 #ifdef DEFINE_REALLOC
2741 /*
2743 Realloc algorithm:
2745 Chunks that were obtained via mmap cannot be extended or shrunk
2746 unless HAVE_MREMAP is defined, in which case mremap is used.
2747 Otherwise, if their reallocation is for additional space, they are
2748 copied. If for less, they are just left alone.
2750 Otherwise, if the reallocation is for additional space, and the
2751 chunk can be extended, it is, else a malloc-copy-free sequence is
2752 taken. There are several different ways that a chunk could be
2753 extended. All are tried:
2755 * Extending forward into following adjacent free chunk.
2756 * Shifting backwards, joining preceding adjacent space
2757 * Both shifting backwards and extending forward.
2758 * Extending into newly sbrked space
2760 Unless the #define REALLOC_ZERO_BYTES_FREES is set, realloc with a
2761 size argument of zero (re)allocates a minimum-sized chunk.
2763 If the reallocation is for less space, and the new request is for
2764 a `small' (<512 bytes) size, then the newly unused space is lopped
2765 off and freed.
2767 The old unix realloc convention of allowing the last-free'd chunk
2768 to be used as an argument to realloc is no longer supported.
2769 I don't know of any programs still relying on this feature,
2770 and allowing it would also allow too many other incorrect
2771 usages of realloc to be sensible.
2774 */
2777 #if __STD_C
2779 #else
2781 #endif
2782 {
2783 #ifdef MALLOC_PROVIDED
2787 #else
2810 #ifdef REALLOC_ZERO_BYTES_FREES
2812 #endif
2815 /* realloc of null is supposed to be same as malloc */
2818 MALLOC_LOCK;
2826 /* Check for overflow and just fail, if so. */
2828 {
2831 }
2833 #if HAVE_MMAP
2835 {
2836 #if HAVE_MREMAP
2839 {
2840 MALLOC_UNLOCK;
2842 }
2843 #endif
2844 /* Note the extra SIZE_SZ overhead. */
2846 {
2847 MALLOC_UNLOCK;
2849 }
2850 /* Must alloc, copy, free. */
2853 {
2854 MALLOC_UNLOCK;
2856 }
2859 MALLOC_UNLOCK;
2861 }
2862 #endif
2867 {
2869 /* Try expanding forward */
2873 {
2876 /* Forward into top only if a remainder */
2878 {
2880 {
2885 MALLOC_UNLOCK;
2887 }
2888 }
2890 /* Forward into next chunk */
2892 {
2896 }
2897 }
2898 else
2899 {
2902 }
2904 /* Try shifting backwards. */
2907 {
2911 /* try forward + backward first to save a later consolidation */
2914 {
2915 /* into top */
2917 {
2919 {
2928 MALLOC_UNLOCK;
2930 }
2931 }
2933 /* into next chunk */
2935 {
2943 }
2944 }
2946 /* backward only */
2948 {
2955 }
2956 }
2958 /* Must allocate */
2963 {
2964 MALLOC_UNLOCK;
2966 }
2968 /* Avoid copy if newp is next chunk after oldp. */
2969 /* (This can only happen when new chunk is sbrk'ed.) */
2972 {
2976 }
2978 /* Otherwise copy, free, and exit */
2981 MALLOC_UNLOCK;
2983 }
2991 {
2997 }
2998 else
2999 {
3002 }
3005 MALLOC_UNLOCK;
3009 }
3012 \f
3013 #ifdef DEFINE_MEMALIGN
3015 /*
3017 memalign algorithm:
3019 memalign requests more than enough space from malloc, finds a spot
3020 within that chunk that meets the alignment request, and then
3021 possibly frees the leading and trailing space.
3023 The alignment argument must be a power of two. This property is not
3024 checked by memalign, so misuse may result in random runtime errors.
3026 8-byte alignment is guaranteed by normal malloc calls, so don't
3027 bother calling memalign with an argument of 8 or less.
3029 Overreliance on memalign is a sure way to fragment space.
3031 */
3034 #if __STD_C
3036 #else
3038 #endif
3039 {
3050 /* If need less alignment than we give anyway, just relay to malloc */
3054 /* Otherwise, ensure that it is at least a minimum chunk size */
3058 /* Call malloc with worst case padding to hit alignment. */
3062 /* Check for overflow. */
3064 {
3067 }
3073 MALLOC_LOCK;
3078 {
3079 #if HAVE_MMAP
3081 {
3082 MALLOC_UNLOCK;
3084 }
3085 #endif
3086 }
3088 {
3089 /*
3090 Find an aligned spot inside chunk.
3091 Since we need to give back leading space in a chunk of at
3092 least MINSIZE, if the first calculation places us at
3093 a spot with less than MINSIZE leader, we can move to the
3094 next aligned spot -- we've allocated enough total room so that
3095 this is always possible.
3096 */
3105 #if HAVE_MMAP
3107 {
3110 MALLOC_UNLOCK;
3112 }
3113 #endif
3115 /* give back leader, use the rest */
3124 }
3126 /* Also give back spare room at the end */
3131 {
3136 }
3139 MALLOC_UNLOCK;
3142 }
3145 \f
3146 #ifdef DEFINE_VALLOC
3148 /*
3149 valloc just invokes memalign with alignment argument equal
3150 to the page size of the system (or as near to this as can
3151 be figured out from all the includes/defines above.)
3152 */
3154 #if __STD_C
3156 #else
3158 #endif
3159 {
3161 }
3165 #ifdef DEFINE_PVALLOC
3167 /*
3168 pvalloc just invokes valloc for the nearest pagesize
3169 that will accommodate request
3170 */
3173 #if __STD_C
3175 #else
3177 #endif
3178 {
3181 {
3184 }
3186 }
3190 #ifdef DEFINE_CALLOC
3192 /*
3194 calloc calls malloc, then zeroes out the allocated chunk.
3196 */
3198 #if __STD_C
3200 #else
3202 #endif
3203 {
3204 mchunkptr p;
3205 INTERNAL_SIZE_T csz;
3207 INTERNAL_SIZE_T sz;
3209 #if MORECORE_CLEARS
3210 mchunkptr oldtop;
3211 INTERNAL_SIZE_T oldtopsize;
3212 #endif
3216 {
3219 }
3221 /* check if expand_top called, in which case don't need to clear */
3222 #if MORECORE_CLEARS
3223 MALLOC_LOCK;
3226 #endif
3231 {
3232 #if MORECORE_CLEARS
3233 MALLOC_UNLOCK;
3234 #endif
3236 }
3237 else
3238 {
3241 /* Two optional cases in which clearing not necessary */
3244 #if HAVE_MMAP
3246 {
3247 #if MORECORE_CLEARS
3248 MALLOC_UNLOCK;
3249 #endif
3251 }
3252 #endif
3256 #if MORECORE_CLEARS
3258 {
3259 /* clear only the bytes from non-freshly-sbrked memory */
3261 }
3262 MALLOC_UNLOCK;
3263 #endif
3267 }
3268 }
3272 #if defined(DEFINE_CFREE) && !defined(__CYGWIN__)
3274 /*
3276 cfree just calls free. It is needed/defined on some systems
3277 that pair it with calloc, presumably for odd historical reasons.
3279 */
3281 #if !defined(INTERNAL_LINUX_C_LIB) || !defined(__ELF__)
3282 #if !defined(_LIBC) || !defined(_REENT_ONLY)
3283 #if __STD_C
3285 #else
3287 #endif
3288 {
3289 #ifdef _LIBC
3291 #else
3293 #endif
3294 }
3295 #endif
3296 #endif
3299 \f
3300 #ifdef DEFINE_FREE
3302 /*
3304 Malloc_trim gives memory back to the system (via negative
3305 arguments to sbrk) if there is unused memory at the `high' end of
3306 the malloc pool. You can call this after freeing large blocks of
3307 memory to potentially reduce the system-level memory requirements
3308 of a program. However, it cannot guarantee to reduce memory. Under
3309 some allocation patterns, some large free blocks of memory will be
3310 locked between two used chunks, so they cannot be given back to
3311 the system.
3313 The `pad' argument to malloc_trim represents the amount of free
3314 trailing space to leave untrimmed. If this argument is zero,
3315 only the minimum amount of memory to maintain internal data
3316 structures will be left (one page or less). Non-zero arguments
3317 can be supplied to maintain enough trailing space to service
3318 future expected allocations without having to re-obtain memory
3319 from the system.
3321 Malloc_trim returns 1 if it actually released any memory, else 0.
3323 */
3325 #if __STD_C
3327 #else
3329 #endif
3330 {
3338 MALLOC_LOCK;
3344 {
3345 MALLOC_UNLOCK;
3347 }
3349 else
3350 {
3351 /* Test to make sure no one else called sbrk */
3354 {
3355 MALLOC_UNLOCK;
3357 }
3359 else
3360 {
3364 {
3365 /* Try to figure out what we have */
3369 {
3372 }
3374 MALLOC_UNLOCK;
3376 }
3378 else
3379 {
3380 /* Success. Adjust top accordingly. */
3384 MALLOC_UNLOCK;
3386 }
3387 }
3388 }
3389 }
3392 \f
3393 #ifdef DEFINE_MALLOC_USABLE_SIZE
3395 /*
3396 malloc_usable_size:
3398 This routine tells you how many bytes you can actually use in an
3399 allocated chunk, which may be more than you requested (although
3400 often not). You can use this many bytes without worrying about
3401 overwriting other allocated objects. Not a particularly great
3402 programming practice, but still sometimes useful.
3404 */
3406 #if __STD_C
3408 #else
3410 #endif
3411 {
3412 mchunkptr p;
3415 else
3416 {
3419 {
3421 #if DEBUG
3422 MALLOC_LOCK;
3424 MALLOC_UNLOCK;
3425 #endif
3427 }
3429 }
3430 }
3433 \f
3434 #ifdef DEFINE_MALLINFO
3436 /* Utility to update current_mallinfo for malloc_stats and mallinfo() */
3439 {
3441 mbinptr b;
3442 mchunkptr p;
3443 #if DEBUG
3444 mchunkptr q;
3445 #endif
3451 {
3454 {
3455 #if DEBUG
3461 #endif
3463 navail++;
3464 }
3465 }
3470 #if HAVE_MMAP
3473 #endif
3476 }
3480 #if __STD_C
3482 #else
3484 #endif
3487 \f
3488 #ifdef DEFINE_MALLOC_STATS
3490 /*
3492 malloc_stats:
3494 Prints on stderr the amount of space obtain from the system (both
3495 via sbrk and mmap), the maximum amount (which may be more than
3496 current if malloc_trim and/or munmap got called), the maximum
3497 number of simultaneous mmap regions used, and the current number
3498 of bytes allocated via malloc (or realloc, etc) but not yet
3499 freed. (Note that this is the number of bytes allocated, not the
3500 number requested. It will be larger than the number requested
3501 because of alignment and bookkeeping overhead.)
3503 */
3505 #if __STD_C
3507 #else
3509 #endif
3510 {
3514 #if HAVE_MMAP
3516 #endif
3519 MALLOC_LOCK;
3524 #if HAVE_MMAP
3527 #endif
3528 MALLOC_UNLOCK;
3530 #ifdef _LIBC
3533 #define fprintf fiprintf
3534 #else
3536 #endif
3540 #if HAVE_MMAP
3545 #else
3550 #endif
3551 #if HAVE_MMAP
3554 #endif
3555 }
3559 #ifdef DEFINE_MALLINFO
3561 /*
3562 mallinfo returns a copy of updated current mallinfo.
3563 */
3565 #if __STD_C
3567 #else
3569 #endif
3570 {
3573 MALLOC_LOCK;
3576 MALLOC_UNLOCK;
3578 }
3581 \f
3582 #ifdef DEFINE_MALLOPT
3584 /*
3585 mallopt:
3587 mallopt is the general SVID/XPG interface to tunable parameters.
3588 The format is to provide a (parameter-number, parameter-value) pair.
3589 mallopt then sets the corresponding parameter to the argument
3590 value if it can (i.e., so long as the value is meaningful),
3591 and returns 1 if successful else 0.
3593 See descriptions of tunable parameters above.
3595 */
3597 #if __STD_C
3599 #else
3601 #endif
3602 {
3603 MALLOC_LOCK;
3605 {
3611 #if HAVE_MMAP
3613 #endif
3614 MALLOC_UNLOCK;
3617 #if HAVE_MMAP
3619 #else
3621 #endif
3624 MALLOC_UNLOCK;
3626 }
3627 }
3631 /*
3633 History:
3635 V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
3636 * Fixed ordering problem with boundary-stamping
3638 V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
3639 * Added pvalloc, as recommended by H.J. Liu
3640 * Added 64bit pointer support mainly from Wolfram Gloger
3641 * Added anonymously donated WIN32 sbrk emulation
3642 * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
3643 * malloc_extend_top: fix mask error that caused wastage after
3644 foreign sbrks
3645 * Add linux mremap support code from HJ Liu
3647 V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
3648 * Integrated most documentation with the code.
3649 * Add support for mmap, with help from
3650 Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
3651 * Use last_remainder in more cases.
3652 * Pack bins using idea from colin@nyx10.cs.du.edu
3653 * Use ordered bins instead of best-fit threshhold
3654 * Eliminate block-local decls to simplify tracing and debugging.
3655 * Support another case of realloc via move into top
3656 * Fix error occuring when initial sbrk_base not word-aligned.
3657 * Rely on page size for units instead of SBRK_UNIT to
3658 avoid surprises about sbrk alignment conventions.
3659 * Add mallinfo, mallopt. Thanks to Raymond Nijssen
3660 (raymond@es.ele.tue.nl) for the suggestion.
3661 * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
3662 * More precautions for cases where other routines call sbrk,
3663 courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
3664 * Added macros etc., allowing use in linux libc from
3665 H.J. Lu (hjl@gnu.ai.mit.edu)
3666 * Inverted this history list
3668 V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
3669 * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
3670 * Removed all preallocation code since under current scheme
3671 the work required to undo bad preallocations exceeds
3672 the work saved in good cases for most test programs.
3673 * No longer use return list or unconsolidated bins since
3674 no scheme using them consistently outperforms those that don't
3675 given above changes.
3676 * Use best fit for very large chunks to prevent some worst-cases.
3677 * Added some support for debugging
3679 V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
3680 * Removed footers when chunks are in use. Thanks to
3681 Paul Wilson (wilson@cs.texas.edu) for the suggestion.
3683 V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
3684 * Added malloc_trim, with help from Wolfram Gloger
3685 (wmglo@Dent.MED.Uni-Muenchen.DE).
3687 V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
3689 V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
3690 * realloc: try to expand in both directions
3691 * malloc: swap order of clean-bin strategy;
3692 * realloc: only conditionally expand backwards
3693 * Try not to scavenge used bins
3694 * Use bin counts as a guide to preallocation
3695 * Occasionally bin return list chunks in first scan
3696 * Add a few optimizations from colin@nyx10.cs.du.edu
3698 V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
3699 * faster bin computation & slightly different binning
3700 * merged all consolidations to one part of malloc proper
3701 (eliminating old malloc_find_space & malloc_clean_bin)
3702 * Scan 2 returns chunks (not just 1)
3703 * Propagate failure in realloc if malloc returns 0
3704 * Add stuff to allow compilation on non-ANSI compilers
3705 from kpv@research.att.com
3707 V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
3708 * removed potential for odd address access in prev_chunk
3709 * removed dependency on getpagesize.h
3710 * misc cosmetics and a bit more internal documentation
3711 * anticosmetics: mangled names in macros to evade debugger strangeness
3712 * tested on sparc, hp-700, dec-mips, rs6000
3713 with gcc & native cc (hp, dec only) allowing
3714 Detlefs & Zorn comparison study (in SIGPLAN Notices.)
3716 Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
3717 * Based loosely on libg++-1.2X malloc. (It retains some of the overall
3718 structure of old version, but most details differ.)
3720 */
3721 #endif