Mercurial > emacs
annotate src/gmalloc.c @ 99492:ee792794d888
(isearch-search-fun): Compare the length of the
current search string with the length of the string from the
previous search state to detect the situation when the user
adds or removes characters in the search string.
Use word-search-forward-lax and word-search-backward-lax in this
case, and otherwise word-search-forward and word-search-backward.
author | Juri Linkov <juri@jurta.org> |
---|---|
date | Tue, 11 Nov 2008 19:43:09 +0000 |
parents | 876b289a899e |
children | 84b961690802 |
rev | line source |
---|---|
17130 | 1 /* This file is no longer automatically generated from libc. */ |
2 | |
3 #define _MALLOC_INTERNAL | |
4 | |
5 /* The malloc headers and source files from the C library follow here. */ | |
6 | |
7 /* Declarations for `malloc' and friends. | |
64770
a0d1312ede66
Update years in copyright notice; nfc.
Thien-Thi Nguyen <ttn@gnuvola.org>
parents:
64092
diff
changeset
|
8 Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004, |
75348 | 9 2005, 2006, 2007 Free Software Foundation, Inc. |
17130 | 10 Written May 1989 by Mike Haertel. |
11 | |
12 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
13 modify it under the terms of the GNU General Public License as |
17130 | 14 published by the Free Software Foundation; either version 2 of the |
15 License, or (at your option) any later version. | |
16 | |
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 | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
20 General Public License for more details. |
17130 | 21 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
22 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
23 License along with this library; see the file COPYING. If |
64092 | 24 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
25 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 26 |
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. */ | |
29 | |
30 #ifndef _MALLOC_H | |
31 | |
32 #define _MALLOC_H 1 | |
33 | |
34 #ifdef _MALLOC_INTERNAL | |
35 | |
36 #ifdef HAVE_CONFIG_H | |
37 #include <config.h> | |
38 #endif | |
39 | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
40 #ifdef HAVE_GTK_AND_PTHREAD |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
41 #define USE_PTHREAD |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
42 #endif |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
43 |
40670
8cb4d744ae0d
Test BROKEN_PROTOTYPES.
Richard M. Stallman <rms@gnu.org>
parents:
37372
diff
changeset
|
44 #if ((defined __cplusplus || (defined (__STDC__) && __STDC__) \ |
8cb4d744ae0d
Test BROKEN_PROTOTYPES.
Richard M. Stallman <rms@gnu.org>
parents:
37372
diff
changeset
|
45 || defined STDC_HEADERS || defined PROTOTYPES) \ |
8cb4d744ae0d
Test BROKEN_PROTOTYPES.
Richard M. Stallman <rms@gnu.org>
parents:
37372
diff
changeset
|
46 && ! defined (BROKEN_PROTOTYPES)) |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
47 #undef PP |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
48 #define PP(args) args |
17130 | 49 #undef __ptr_t |
50 #define __ptr_t void * | |
51 #else /* Not C++ or ANSI C. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
52 #undef PP |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
53 #define PP(args) () |
17130 | 54 #undef __ptr_t |
55 #define __ptr_t char * | |
56 #endif /* C++ or ANSI C. */ | |
57 | |
58 #if defined(_LIBC) || defined(STDC_HEADERS) || defined(USG) | |
59 #include <string.h> | |
60 #else | |
61 #ifndef memset | |
62 #define memset(s, zero, n) bzero ((s), (n)) | |
63 #endif | |
64 #ifndef memcpy | |
65 #define memcpy(d, s, n) bcopy ((s), (d), (n)) | |
66 #endif | |
67 #endif | |
68 | |
26526
b7438760079b
* callproc.c (strerror): Remove decl.
Paul Eggert <eggert@twinsun.com>
parents:
26088
diff
changeset
|
69 #ifdef HAVE_LIMITS_H |
17130 | 70 #include <limits.h> |
26526
b7438760079b
* callproc.c (strerror): Remove decl.
Paul Eggert <eggert@twinsun.com>
parents:
26088
diff
changeset
|
71 #endif |
17130 | 72 #ifndef CHAR_BIT |
73 #define CHAR_BIT 8 | |
74 #endif | |
75 | |
76 #ifdef HAVE_UNISTD_H | |
77 #include <unistd.h> | |
78 #endif | |
79 | |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
80 #ifdef USE_PTHREAD |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
81 #include <pthread.h> |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
82 #endif |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
83 |
17130 | 84 #endif /* _MALLOC_INTERNAL. */ |
85 | |
86 | |
87 #ifdef __cplusplus | |
88 extern "C" | |
89 { | |
90 #endif | |
91 | |
26526
b7438760079b
* callproc.c (strerror): Remove decl.
Paul Eggert <eggert@twinsun.com>
parents:
26088
diff
changeset
|
92 #ifdef STDC_HEADERS |
17130 | 93 #include <stddef.h> |
94 #define __malloc_size_t size_t | |
95 #define __malloc_ptrdiff_t ptrdiff_t | |
96 #else | |
37372
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
97 #ifdef __GNUC__ |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
98 #include <stddef.h> |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
99 #ifdef __SIZE_TYPE__ |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
100 #define __malloc_size_t __SIZE_TYPE__ |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
101 #endif |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
102 #endif |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
103 #ifndef __malloc_size_t |
17130 | 104 #define __malloc_size_t unsigned int |
37372
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
105 #endif |
17130 | 106 #define __malloc_ptrdiff_t int |
107 #endif | |
108 | |
109 #ifndef NULL | |
110 #define NULL 0 | |
111 #endif | |
112 | |
113 | |
114 /* Allocate SIZE bytes of memory. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
115 extern __ptr_t malloc PP ((__malloc_size_t __size)); |
17130 | 116 /* Re-allocate the previously allocated block |
117 in __ptr_t, making the new block SIZE bytes long. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
118 extern __ptr_t realloc PP ((__ptr_t __ptr, __malloc_size_t __size)); |
17130 | 119 /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
120 extern __ptr_t calloc PP ((__malloc_size_t __nmemb, __malloc_size_t __size)); |
17130 | 121 /* Free a block allocated by `malloc', `realloc' or `calloc'. */ |
91702
b7a5a89054dc
* configure.in (LIBX11_MACHINE, HAVE_XFREE386): Remove code
Dan Nicolaescu <dann@ics.uci.edu>
parents:
82335
diff
changeset
|
122 extern void free PP ((__ptr_t __ptr)); |
17130 | 123 |
124 /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ | |
125 #if ! (defined (_MALLOC_INTERNAL) && __DJGPP__ - 0 == 1) /* Avoid conflict. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
126 extern __ptr_t memalign PP ((__malloc_size_t __alignment, |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
127 __malloc_size_t __size)); |
82335
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
128 extern int posix_memalign PP ((__ptr_t *, __malloc_size_t, |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
129 __malloc_size_t size)); |
17130 | 130 #endif |
131 | |
132 /* Allocate SIZE bytes on a page boundary. */ | |
133 #if ! (defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC)) | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
134 extern __ptr_t valloc PP ((__malloc_size_t __size)); |
17130 | 135 #endif |
136 | |
82308
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
137 #ifdef USE_PTHREAD |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
138 /* Set up mutexes and make malloc etc. thread-safe. */ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
139 extern void malloc_enable_thread PP ((void)); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
140 #endif |
17130 | 141 |
142 #ifdef _MALLOC_INTERNAL | |
143 | |
144 /* The allocator divides the heap into blocks of fixed size; large | |
145 requests receive one or more whole blocks, and small requests | |
146 receive a fragment of a block. Fragment sizes are powers of two, | |
147 and all fragments of a block are the same size. When all the | |
148 fragments in a block have been freed, the block itself is freed. */ | |
149 #define INT_BIT (CHAR_BIT * sizeof(int)) | |
150 #define BLOCKLOG (INT_BIT > 16 ? 12 : 9) | |
151 #define BLOCKSIZE (1 << BLOCKLOG) | |
152 #define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) | |
153 | |
154 /* Determine the amount of memory spanned by the initial heap table | |
155 (not an absolute limit). */ | |
156 #define HEAP (INT_BIT > 16 ? 4194304 : 65536) | |
157 | |
158 /* Number of contiguous free blocks allowed to build up at the end of | |
159 memory before they will be returned to the system. */ | |
160 #define FINAL_FREE_BLOCKS 8 | |
161 | |
162 /* Data structure giving per-block information. */ | |
163 typedef union | |
164 { | |
165 /* Heap information for a busy block. */ | |
166 struct | |
167 { | |
168 /* Zero for a large (multiblock) object, or positive giving the | |
169 logarithm to the base two of the fragment size. */ | |
170 int type; | |
171 union | |
172 { | |
173 struct | |
174 { | |
175 __malloc_size_t nfree; /* Free frags in a fragmented block. */ | |
176 __malloc_size_t first; /* First free fragment of the block. */ | |
177 } frag; | |
178 /* For a large object, in its first block, this has the number | |
179 of blocks in the object. In the other blocks, this has a | |
180 negative number which says how far back the first block is. */ | |
181 __malloc_ptrdiff_t size; | |
182 } info; | |
183 } busy; | |
184 /* Heap information for a free block | |
185 (that may be the first of a free cluster). */ | |
186 struct | |
187 { | |
188 __malloc_size_t size; /* Size (in blocks) of a free cluster. */ | |
189 __malloc_size_t next; /* Index of next free cluster. */ | |
190 __malloc_size_t prev; /* Index of previous free cluster. */ | |
191 } free; | |
192 } malloc_info; | |
193 | |
194 /* Pointer to first block of the heap. */ | |
195 extern char *_heapbase; | |
196 | |
197 /* Table indexed by block number giving per-block information. */ | |
198 extern malloc_info *_heapinfo; | |
199 | |
200 /* Address to block number and vice versa. */ | |
201 #define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) | |
202 #define ADDRESS(B) ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase)) | |
203 | |
204 /* Current search index for the heap table. */ | |
205 extern __malloc_size_t _heapindex; | |
206 | |
207 /* Limit of valid info table indices. */ | |
208 extern __malloc_size_t _heaplimit; | |
209 | |
210 /* Doubly linked lists of free fragments. */ | |
211 struct list | |
212 { | |
213 struct list *next; | |
214 struct list *prev; | |
215 }; | |
216 | |
217 /* Free list headers for each fragment size. */ | |
218 extern struct list _fraghead[]; | |
219 | |
220 /* List of blocks allocated with `memalign' (or `valloc'). */ | |
221 struct alignlist | |
222 { | |
223 struct alignlist *next; | |
224 __ptr_t aligned; /* The address that memaligned returned. */ | |
225 __ptr_t exact; /* The address that malloc returned. */ | |
226 }; | |
227 extern struct alignlist *_aligned_blocks; | |
228 | |
229 /* Instrumentation. */ | |
230 extern __malloc_size_t _chunks_used; | |
231 extern __malloc_size_t _bytes_used; | |
232 extern __malloc_size_t _chunks_free; | |
233 extern __malloc_size_t _bytes_free; | |
234 | |
235 /* Internal versions of `malloc', `realloc', and `free' | |
236 used when these functions need to call each other. | |
237 They are the same but don't call the hooks. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
238 extern __ptr_t _malloc_internal PP ((__malloc_size_t __size)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
239 extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
240 extern void _free_internal PP ((__ptr_t __ptr)); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
241 extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size)); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
242 extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size)); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
243 extern void _free_internal_nolock PP ((__ptr_t __ptr)); |
17130 | 244 |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
245 #ifdef USE_PTHREAD |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
246 extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex; |
82308
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
247 extern int _malloc_thread_enabled_p; |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
248 #define LOCK() \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
249 do { \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
250 if (_malloc_thread_enabled_p) \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
251 pthread_mutex_lock (&_malloc_mutex); \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
252 } while (0) |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
253 #define UNLOCK() \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
254 do { \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
255 if (_malloc_thread_enabled_p) \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
256 pthread_mutex_unlock (&_malloc_mutex); \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
257 } while (0) |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
258 #define LOCK_ALIGNED_BLOCKS() \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
259 do { \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
260 if (_malloc_thread_enabled_p) \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
261 pthread_mutex_lock (&_aligned_blocks_mutex); \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
262 } while (0) |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
263 #define UNLOCK_ALIGNED_BLOCKS() \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
264 do { \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
265 if (_malloc_thread_enabled_p) \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
266 pthread_mutex_unlock (&_aligned_blocks_mutex); \ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
267 } while (0) |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
268 #else |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
269 #define LOCK() |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
270 #define UNLOCK() |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
271 #define LOCK_ALIGNED_BLOCKS() |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
272 #define UNLOCK_ALIGNED_BLOCKS() |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
273 #endif |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
274 |
17130 | 275 #endif /* _MALLOC_INTERNAL. */ |
276 | |
277 /* Given an address in the middle of a malloc'd object, | |
278 return the address of the beginning of the object. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
279 extern __ptr_t malloc_find_object_address PP ((__ptr_t __ptr)); |
17130 | 280 |
281 /* Underlying allocation function; successive calls should | |
282 return contiguous pieces of memory. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
283 extern __ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)); |
17130 | 284 |
285 /* Default value of `__morecore'. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
286 extern __ptr_t __default_morecore PP ((__malloc_ptrdiff_t __size)); |
17130 | 287 |
288 /* If not NULL, this function is called after each time | |
289 `__morecore' is called to increase the data size. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
290 extern void (*__after_morecore_hook) PP ((void)); |
17130 | 291 |
292 /* Number of extra blocks to get each time we ask for more core. | |
293 This reduces the frequency of calling `(*__morecore)'. */ | |
294 extern __malloc_size_t __malloc_extra_blocks; | |
295 | |
296 /* Nonzero if `malloc' has been called and done its initialization. */ | |
297 extern int __malloc_initialized; | |
298 /* Function called to initialize malloc data structures. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
299 extern int __malloc_initialize PP ((void)); |
17130 | 300 |
301 /* Hooks for debugging versions. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
302 extern void (*__malloc_initialize_hook) PP ((void)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
303 extern void (*__free_hook) PP ((__ptr_t __ptr)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
304 extern __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
305 extern __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
306 extern __ptr_t (*__memalign_hook) PP ((__malloc_size_t __size, |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
307 __malloc_size_t __alignment)); |
17130 | 308 |
309 /* Return values for `mprobe': these are the kinds of inconsistencies that | |
310 `mcheck' enables detection of. */ | |
311 enum mcheck_status | |
312 { | |
313 MCHECK_DISABLED = -1, /* Consistency checking is not turned on. */ | |
314 MCHECK_OK, /* Block is fine. */ | |
315 MCHECK_FREE, /* Block freed twice. */ | |
316 MCHECK_HEAD, /* Memory before the block was clobbered. */ | |
317 MCHECK_TAIL /* Memory after the block was clobbered. */ | |
318 }; | |
319 | |
320 /* Activate a standard collection of debugging hooks. This must be called | |
321 before `malloc' is ever called. ABORTFUNC is called with an error code | |
322 (see enum above) when an inconsistency is detected. If ABORTFUNC is | |
323 null, the standard function prints on stderr and then calls `abort'. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
324 extern int mcheck PP ((void (*__abortfunc) PP ((enum mcheck_status)))); |
17130 | 325 |
326 /* Check for aberrations in a particular malloc'd block. You must have | |
327 called `mcheck' already. These are the same checks that `mcheck' does | |
328 when you free or reallocate a block. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
329 extern enum mcheck_status mprobe PP ((__ptr_t __ptr)); |
17130 | 330 |
331 /* Activate a standard collection of tracing hooks. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
332 extern void mtrace PP ((void)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
333 extern void muntrace PP ((void)); |
17130 | 334 |
335 /* Statistics available to the user. */ | |
336 struct mstats | |
337 { | |
338 __malloc_size_t bytes_total; /* Total size of the heap. */ | |
339 __malloc_size_t chunks_used; /* Chunks allocated by the user. */ | |
340 __malloc_size_t bytes_used; /* Byte total of user-allocated chunks. */ | |
341 __malloc_size_t chunks_free; /* Chunks in the free list. */ | |
342 __malloc_size_t bytes_free; /* Byte total of chunks in the free list. */ | |
343 }; | |
344 | |
345 /* Pick up the current statistics. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
346 extern struct mstats mstats PP ((void)); |
17130 | 347 |
348 /* Call WARNFUN with a warning message when memory usage is high. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
349 extern void memory_warnings PP ((__ptr_t __start, |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
350 void (*__warnfun) PP ((const char *)))); |
17130 | 351 |
352 | |
353 /* Relocating allocator. */ | |
354 | |
355 /* Allocate SIZE bytes, and store the address in *HANDLEPTR. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
356 extern __ptr_t r_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size)); |
17130 | 357 |
358 /* Free the storage allocated in HANDLEPTR. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
359 extern void r_alloc_free PP ((__ptr_t *__handleptr)); |
17130 | 360 |
361 /* Adjust the block at HANDLEPTR to be SIZE bytes long. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
362 extern __ptr_t r_re_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size)); |
17130 | 363 |
364 | |
365 #ifdef __cplusplus | |
366 } | |
367 #endif | |
368 | |
369 #endif /* malloc.h */ | |
370 /* Memory allocator `malloc'. | |
371 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
372 Written May 1989 by Mike Haertel. | |
373 | |
374 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
375 modify it under the terms of the GNU General Public License as |
17130 | 376 published by the Free Software Foundation; either version 2 of the |
377 License, or (at your option) any later version. | |
378 | |
379 This library is distributed in the hope that it will be useful, | |
380 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
381 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
382 General Public License for more details. |
17130 | 383 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
384 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
385 License along with this library; see the file COPYING. If |
64092 | 386 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
387 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 388 |
389 The author may be reached (Email) at the address mike@ai.mit.edu, | |
390 or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
391 | |
392 #ifndef _MALLOC_INTERNAL | |
393 #define _MALLOC_INTERNAL | |
394 #include <malloc.h> | |
395 #endif | |
396 #include <errno.h> | |
397 | |
398 /* How to really get more memory. */ | |
54824
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
399 #if defined(CYGWIN) |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
400 extern __ptr_t bss_sbrk PP ((ptrdiff_t __size)); |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
401 extern int bss_sbrk_did_unexec; |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
402 #endif |
81500
55e8330e329d
(__morecore): Fix the declaration to comply with the definition.
Sam Steingold <sds@gnu.org>
parents:
76776
diff
changeset
|
403 __ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore; |
17130 | 404 |
405 /* Debugging hook for `malloc'. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
406 __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size)); |
17130 | 407 |
408 /* Pointer to the base of the first block. */ | |
409 char *_heapbase; | |
410 | |
411 /* Block information table. Allocated with align/__free (not malloc/free). */ | |
412 malloc_info *_heapinfo; | |
413 | |
414 /* Number of info entries. */ | |
415 static __malloc_size_t heapsize; | |
416 | |
417 /* Search index in the info table. */ | |
418 __malloc_size_t _heapindex; | |
419 | |
420 /* Limit of valid info table indices. */ | |
421 __malloc_size_t _heaplimit; | |
422 | |
423 /* Free lists for each fragment size. */ | |
424 struct list _fraghead[BLOCKLOG]; | |
425 | |
426 /* Instrumentation. */ | |
427 __malloc_size_t _chunks_used; | |
428 __malloc_size_t _bytes_used; | |
429 __malloc_size_t _chunks_free; | |
430 __malloc_size_t _bytes_free; | |
431 | |
432 /* Are you experienced? */ | |
433 int __malloc_initialized; | |
434 | |
435 __malloc_size_t __malloc_extra_blocks; | |
436 | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
437 void (*__malloc_initialize_hook) PP ((void)); |
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
438 void (*__after_morecore_hook) PP ((void)); |
17130 | 439 |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
440 #if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
441 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
442 /* Some code for hunting a bug writing into _heapinfo. |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
443 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
444 Call this macro with argument PROT non-zero to protect internal |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
445 malloc state against writing to it, call it with a zero argument to |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
446 make it readable and writable. |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
447 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
448 Note that this only works if BLOCKSIZE == page size, which is |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
449 the case on the i386. */ |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
450 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
451 #include <sys/types.h> |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
452 #include <sys/mman.h> |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
453 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
454 static int state_protected_p; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
455 static __malloc_size_t last_state_size; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
456 static malloc_info *last_heapinfo; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
457 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
458 void |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
459 protect_malloc_state (protect_p) |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
460 int protect_p; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
461 { |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
462 /* If _heapinfo has been relocated, make sure its old location |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
463 isn't left read-only; it will be reused by malloc. */ |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
464 if (_heapinfo != last_heapinfo |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
465 && last_heapinfo |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
466 && state_protected_p) |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
467 mprotect (last_heapinfo, last_state_size, PROT_READ | PROT_WRITE); |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
468 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
469 last_state_size = _heaplimit * sizeof *_heapinfo; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
470 last_heapinfo = _heapinfo; |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
471 |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
472 if (protect_p != state_protected_p) |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
473 { |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
474 state_protected_p = protect_p; |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
475 if (mprotect (_heapinfo, last_state_size, |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
476 protect_p ? PROT_READ : PROT_READ | PROT_WRITE) != 0) |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
477 abort (); |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
478 } |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
479 } |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
480 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
481 #define PROTECT_MALLOC_STATE(PROT) protect_malloc_state(PROT) |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
482 |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
483 #else |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
484 #define PROTECT_MALLOC_STATE(PROT) /* empty */ |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
485 #endif |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
486 |
17130 | 487 |
488 /* Aligned allocation. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
489 static __ptr_t align PP ((__malloc_size_t)); |
17130 | 490 static __ptr_t |
491 align (size) | |
492 __malloc_size_t size; | |
493 { | |
494 __ptr_t result; | |
495 unsigned long int adj; | |
496 | |
37268
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
497 /* align accepts an unsigned argument, but __morecore accepts a |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
498 signed one. This could lead to trouble if SIZE overflows a |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
499 signed int type accepted by __morecore. We just punt in that |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
500 case, since they are requesting a ludicrous amount anyway. */ |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
501 if ((__malloc_ptrdiff_t)size < 0) |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
502 result = 0; |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
503 else |
0f5de719ab07
(align): If the argument SIZE would overflow
Eli Zaretskii <eliz@gnu.org>
parents:
32973
diff
changeset
|
504 result = (*__morecore) (size); |
17130 | 505 adj = (unsigned long int) ((unsigned long int) ((char *) result - |
506 (char *) NULL)) % BLOCKSIZE; | |
507 if (adj != 0) | |
508 { | |
509 __ptr_t new; | |
510 adj = BLOCKSIZE - adj; | |
511 new = (*__morecore) (adj); | |
512 result = (char *) result + adj; | |
513 } | |
514 | |
515 if (__after_morecore_hook) | |
516 (*__after_morecore_hook) (); | |
517 | |
518 return result; | |
519 } | |
520 | |
521 /* Get SIZE bytes, if we can get them starting at END. | |
522 Return the address of the space we got. | |
523 If we cannot get space at END, fail and return 0. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
524 static __ptr_t get_contiguous_space PP ((__malloc_ptrdiff_t, __ptr_t)); |
17130 | 525 static __ptr_t |
526 get_contiguous_space (size, position) | |
527 __malloc_ptrdiff_t size; | |
528 __ptr_t position; | |
529 { | |
530 __ptr_t before; | |
531 __ptr_t after; | |
532 | |
533 before = (*__morecore) (0); | |
534 /* If we can tell in advance that the break is at the wrong place, | |
535 fail now. */ | |
536 if (before != position) | |
537 return 0; | |
538 | |
539 /* Allocate SIZE bytes and get the address of them. */ | |
540 after = (*__morecore) (size); | |
541 if (!after) | |
542 return 0; | |
543 | |
544 /* It was not contiguous--reject it. */ | |
545 if (after != position) | |
546 { | |
547 (*__morecore) (- size); | |
548 return 0; | |
549 } | |
550 | |
551 return after; | |
552 } | |
553 | |
554 | |
555 /* This is called when `_heapinfo' and `heapsize' have just | |
556 been set to describe a new info table. Set up the table | |
557 to describe itself and account for it in the statistics. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
558 static void register_heapinfo PP ((void)); |
17130 | 559 #ifdef __GNUC__ |
560 __inline__ | |
561 #endif | |
562 static void | |
563 register_heapinfo () | |
564 { | |
565 __malloc_size_t block, blocks; | |
566 | |
567 block = BLOCK (_heapinfo); | |
568 blocks = BLOCKIFY (heapsize * sizeof (malloc_info)); | |
569 | |
570 /* Account for the _heapinfo block itself in the statistics. */ | |
571 _bytes_used += blocks * BLOCKSIZE; | |
572 ++_chunks_used; | |
573 | |
574 /* Describe the heapinfo block itself in the heapinfo. */ | |
575 _heapinfo[block].busy.type = 0; | |
576 _heapinfo[block].busy.info.size = blocks; | |
577 /* Leave back-pointers for malloc_find_address. */ | |
578 while (--blocks > 0) | |
579 _heapinfo[block + blocks].busy.info.size = -blocks; | |
580 } | |
581 | |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
582 #ifdef USE_PTHREAD |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
583 pthread_mutex_t _malloc_mutex = PTHREAD_MUTEX_INITIALIZER; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
584 pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER; |
82308
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
585 int _malloc_thread_enabled_p; |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
586 |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
587 static void |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
588 malloc_atfork_handler_prepare () |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
589 { |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
590 LOCK (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
591 LOCK_ALIGNED_BLOCKS (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
592 } |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
593 |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
594 static void |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
595 malloc_atfork_handler_parent () |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
596 { |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
597 UNLOCK_ALIGNED_BLOCKS (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
598 UNLOCK (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
599 } |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
600 |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
601 static void |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
602 malloc_atfork_handler_child () |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
603 { |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
604 UNLOCK_ALIGNED_BLOCKS (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
605 UNLOCK (); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
606 } |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
607 |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
608 /* Set up mutexes and make malloc etc. thread-safe. */ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
609 void |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
610 malloc_enable_thread () |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
611 { |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
612 if (_malloc_thread_enabled_p) |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
613 return; |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
614 |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
615 /* Some pthread implementations call malloc for statically |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
616 initialized mutexes when they are used first. To avoid such a |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
617 situation, we initialize mutexes here while their use is |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
618 disabled in malloc etc. */ |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
619 pthread_mutex_init (&_malloc_mutex, NULL); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
620 pthread_mutex_init (&_aligned_blocks_mutex, NULL); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
621 pthread_atfork (malloc_atfork_handler_prepare, |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
622 malloc_atfork_handler_parent, |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
623 malloc_atfork_handler_child); |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
624 _malloc_thread_enabled_p = 1; |
7856255721ef
(_malloc_thread_enabled_p) [USE_PTHREAD]: New variable.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82198
diff
changeset
|
625 } |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
626 #endif |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
627 |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
628 static void |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
629 malloc_initialize_1 () |
17130 | 630 { |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
631 #ifdef GC_MCHECK |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
632 mcheck (NULL); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
633 #endif |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
634 |
17130 | 635 if (__malloc_initialize_hook) |
636 (*__malloc_initialize_hook) (); | |
637 | |
638 heapsize = HEAP / BLOCKSIZE; | |
639 _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info)); | |
640 if (_heapinfo == NULL) | |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
641 return; |
17130 | 642 memset (_heapinfo, 0, heapsize * sizeof (malloc_info)); |
643 _heapinfo[0].free.size = 0; | |
644 _heapinfo[0].free.next = _heapinfo[0].free.prev = 0; | |
645 _heapindex = 0; | |
646 _heapbase = (char *) _heapinfo; | |
647 _heaplimit = BLOCK (_heapbase + heapsize * sizeof (malloc_info)); | |
648 | |
649 register_heapinfo (); | |
650 | |
651 __malloc_initialized = 1; | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
652 PROTECT_MALLOC_STATE (1); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
653 return; |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
654 } |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
655 |
82198
8cc259bc54fd
(__malloc_initialize): Remove pthread_once. Not needed.
Jan Djärv <jan.h.d@swipnet.se>
parents:
81615
diff
changeset
|
656 /* Set everything up and remember that we have. |
8cc259bc54fd
(__malloc_initialize): Remove pthread_once. Not needed.
Jan Djärv <jan.h.d@swipnet.se>
parents:
81615
diff
changeset
|
657 main will call malloc which calls this function. That is before any threads |
8cc259bc54fd
(__malloc_initialize): Remove pthread_once. Not needed.
Jan Djärv <jan.h.d@swipnet.se>
parents:
81615
diff
changeset
|
658 or signal handlers has been set up, so we don't need thread protection. */ |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
659 int |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
660 __malloc_initialize () |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
661 { |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
662 if (__malloc_initialized) |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
663 return 0; |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
664 |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
665 malloc_initialize_1 (); |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
666 |
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
667 return __malloc_initialized; |
17130 | 668 } |
669 | |
670 static int morecore_recursing; | |
671 | |
672 /* Get neatly aligned memory, initializing or | |
673 growing the heap info table as necessary. */ | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
674 static __ptr_t morecore_nolock PP ((__malloc_size_t)); |
17130 | 675 static __ptr_t |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
676 morecore_nolock (size) |
17130 | 677 __malloc_size_t size; |
678 { | |
679 __ptr_t result; | |
680 malloc_info *newinfo, *oldinfo; | |
681 __malloc_size_t newsize; | |
682 | |
683 if (morecore_recursing) | |
684 /* Avoid recursion. The caller will know how to handle a null return. */ | |
685 return NULL; | |
686 | |
687 result = align (size); | |
688 if (result == NULL) | |
689 return NULL; | |
690 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
691 PROTECT_MALLOC_STATE (0); |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
692 |
17130 | 693 /* Check if we need to grow the info table. */ |
694 if ((__malloc_size_t) BLOCK ((char *) result + size) > heapsize) | |
695 { | |
696 /* Calculate the new _heapinfo table size. We do not account for the | |
697 added blocks in the table itself, as we hope to place them in | |
698 existing free space, which is already covered by part of the | |
699 existing table. */ | |
700 newsize = heapsize; | |
701 do | |
702 newsize *= 2; | |
703 while ((__malloc_size_t) BLOCK ((char *) result + size) > newsize); | |
704 | |
705 /* We must not reuse existing core for the new info table when called | |
706 from realloc in the case of growing a large block, because the | |
707 block being grown is momentarily marked as free. In this case | |
708 _heaplimit is zero so we know not to reuse space for internal | |
709 allocation. */ | |
710 if (_heaplimit != 0) | |
711 { | |
712 /* First try to allocate the new info table in core we already | |
713 have, in the usual way using realloc. If realloc cannot | |
714 extend it in place or relocate it to existing sufficient core, | |
715 we will get called again, and the code above will notice the | |
716 `morecore_recursing' flag and return null. */ | |
717 int save = errno; /* Don't want to clobber errno with ENOMEM. */ | |
718 morecore_recursing = 1; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
719 newinfo = (malloc_info *) _realloc_internal_nolock |
17130 | 720 (_heapinfo, newsize * sizeof (malloc_info)); |
721 morecore_recursing = 0; | |
722 if (newinfo == NULL) | |
723 errno = save; | |
724 else | |
725 { | |
726 /* We found some space in core, and realloc has put the old | |
727 table's blocks on the free list. Now zero the new part | |
728 of the table and install the new table location. */ | |
729 memset (&newinfo[heapsize], 0, | |
730 (newsize - heapsize) * sizeof (malloc_info)); | |
731 _heapinfo = newinfo; | |
732 heapsize = newsize; | |
733 goto got_heap; | |
734 } | |
735 } | |
736 | |
737 /* Allocate new space for the malloc info table. */ | |
738 while (1) | |
739 { | |
740 newinfo = (malloc_info *) align (newsize * sizeof (malloc_info)); | |
741 | |
742 /* Did it fail? */ | |
743 if (newinfo == NULL) | |
744 { | |
745 (*__morecore) (-size); | |
746 return NULL; | |
747 } | |
748 | |
749 /* Is it big enough to record status for its own space? | |
750 If so, we win. */ | |
751 if ((__malloc_size_t) BLOCK ((char *) newinfo | |
752 + newsize * sizeof (malloc_info)) | |
753 < newsize) | |
754 break; | |
755 | |
756 /* Must try again. First give back most of what we just got. */ | |
757 (*__morecore) (- newsize * sizeof (malloc_info)); | |
758 newsize *= 2; | |
759 } | |
760 | |
761 /* Copy the old table to the beginning of the new, | |
762 and zero the rest of the new table. */ | |
763 memcpy (newinfo, _heapinfo, heapsize * sizeof (malloc_info)); | |
764 memset (&newinfo[heapsize], 0, | |
765 (newsize - heapsize) * sizeof (malloc_info)); | |
766 oldinfo = _heapinfo; | |
767 _heapinfo = newinfo; | |
768 heapsize = newsize; | |
769 | |
770 register_heapinfo (); | |
771 | |
772 /* Reset _heaplimit so _free_internal never decides | |
773 it can relocate or resize the info table. */ | |
774 _heaplimit = 0; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
775 _free_internal_nolock (oldinfo); |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
776 PROTECT_MALLOC_STATE (0); |
17130 | 777 |
778 /* The new heap limit includes the new table just allocated. */ | |
779 _heaplimit = BLOCK ((char *) newinfo + heapsize * sizeof (malloc_info)); | |
780 return result; | |
781 } | |
782 | |
783 got_heap: | |
784 _heaplimit = BLOCK ((char *) result + size); | |
785 return result; | |
786 } | |
787 | |
788 /* Allocate memory from the heap. */ | |
789 __ptr_t | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
790 _malloc_internal_nolock (size) |
17130 | 791 __malloc_size_t size; |
792 { | |
793 __ptr_t result; | |
794 __malloc_size_t block, blocks, lastblocks, start; | |
795 register __malloc_size_t i; | |
796 struct list *next; | |
797 | |
798 /* ANSI C allows `malloc (0)' to either return NULL, or to return a | |
799 valid address you can realloc and free (though not dereference). | |
800 | |
801 It turns out that some extant code (sunrpc, at least Ultrix's version) | |
802 expects `malloc (0)' to return non-NULL and breaks otherwise. | |
803 Be compatible. */ | |
804 | |
805 #if 0 | |
806 if (size == 0) | |
807 return NULL; | |
808 #endif | |
809 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
810 PROTECT_MALLOC_STATE (0); |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
811 |
17130 | 812 if (size < sizeof (struct list)) |
813 size = sizeof (struct list); | |
814 | |
815 /* Determine the allocation policy based on the request size. */ | |
816 if (size <= BLOCKSIZE / 2) | |
817 { | |
818 /* Small allocation to receive a fragment of a block. | |
819 Determine the logarithm to base two of the fragment size. */ | |
820 register __malloc_size_t log = 1; | |
821 --size; | |
822 while ((size /= 2) != 0) | |
823 ++log; | |
824 | |
825 /* Look in the fragment lists for a | |
826 free fragment of the desired size. */ | |
827 next = _fraghead[log].next; | |
828 if (next != NULL) | |
829 { | |
830 /* There are free fragments of this size. | |
831 Pop a fragment out of the fragment list and return it. | |
832 Update the block's nfree and first counters. */ | |
833 result = (__ptr_t) next; | |
834 next->prev->next = next->next; | |
835 if (next->next != NULL) | |
836 next->next->prev = next->prev; | |
837 block = BLOCK (result); | |
838 if (--_heapinfo[block].busy.info.frag.nfree != 0) | |
839 _heapinfo[block].busy.info.frag.first = (unsigned long int) | |
840 ((unsigned long int) ((char *) next->next - (char *) NULL) | |
841 % BLOCKSIZE) >> log; | |
842 | |
843 /* Update the statistics. */ | |
844 ++_chunks_used; | |
845 _bytes_used += 1 << log; | |
846 --_chunks_free; | |
847 _bytes_free -= 1 << log; | |
848 } | |
849 else | |
850 { | |
851 /* No free fragments of the desired size, so get a new block | |
852 and break it into fragments, returning the first. */ | |
32693
8223a86fa594
(_malloc_internal) [GC_MALLOC_CHECK]: Use
Gerd Moellmann <gerd@gnu.org>
parents:
29837
diff
changeset
|
853 #ifdef GC_MALLOC_CHECK |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
854 result = _malloc_internal_nolock (BLOCKSIZE); |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
855 PROTECT_MALLOC_STATE (0); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
856 #elif defined (USE_PTHREAD) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
857 result = _malloc_internal_nolock (BLOCKSIZE); |
32693
8223a86fa594
(_malloc_internal) [GC_MALLOC_CHECK]: Use
Gerd Moellmann <gerd@gnu.org>
parents:
29837
diff
changeset
|
858 #else |
17130 | 859 result = malloc (BLOCKSIZE); |
32693
8223a86fa594
(_malloc_internal) [GC_MALLOC_CHECK]: Use
Gerd Moellmann <gerd@gnu.org>
parents:
29837
diff
changeset
|
860 #endif |
17130 | 861 if (result == NULL) |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
862 { |
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
863 PROTECT_MALLOC_STATE (1); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
864 goto out; |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
865 } |
17130 | 866 |
867 /* Link all fragments but the first into the free list. */ | |
868 next = (struct list *) ((char *) result + (1 << log)); | |
869 next->next = NULL; | |
870 next->prev = &_fraghead[log]; | |
871 _fraghead[log].next = next; | |
872 | |
873 for (i = 2; i < (__malloc_size_t) (BLOCKSIZE >> log); ++i) | |
874 { | |
875 next = (struct list *) ((char *) result + (i << log)); | |
876 next->next = _fraghead[log].next; | |
877 next->prev = &_fraghead[log]; | |
878 next->prev->next = next; | |
879 next->next->prev = next; | |
880 } | |
881 | |
882 /* Initialize the nfree and first counters for this block. */ | |
883 block = BLOCK (result); | |
884 _heapinfo[block].busy.type = log; | |
885 _heapinfo[block].busy.info.frag.nfree = i - 1; | |
886 _heapinfo[block].busy.info.frag.first = i - 1; | |
887 | |
888 _chunks_free += (BLOCKSIZE >> log) - 1; | |
889 _bytes_free += BLOCKSIZE - (1 << log); | |
890 _bytes_used -= BLOCKSIZE - (1 << log); | |
891 } | |
892 } | |
893 else | |
894 { | |
895 /* Large allocation to receive one or more blocks. | |
896 Search the free list in a circle starting at the last place visited. | |
897 If we loop completely around without finding a large enough | |
898 space we will have to get more memory from the system. */ | |
899 blocks = BLOCKIFY (size); | |
900 start = block = _heapindex; | |
901 while (_heapinfo[block].free.size < blocks) | |
902 { | |
903 block = _heapinfo[block].free.next; | |
904 if (block == start) | |
905 { | |
906 /* Need to get more from the system. Get a little extra. */ | |
907 __malloc_size_t wantblocks = blocks + __malloc_extra_blocks; | |
908 block = _heapinfo[0].free.prev; | |
909 lastblocks = _heapinfo[block].free.size; | |
910 /* Check to see if the new core will be contiguous with the | |
911 final free block; if so we don't need to get as much. */ | |
912 if (_heaplimit != 0 && block + lastblocks == _heaplimit && | |
913 /* We can't do this if we will have to make the heap info | |
95236 | 914 table bigger to accommodate the new space. */ |
17130 | 915 block + wantblocks <= heapsize && |
916 get_contiguous_space ((wantblocks - lastblocks) * BLOCKSIZE, | |
917 ADDRESS (block + lastblocks))) | |
918 { | |
919 /* We got it contiguously. Which block we are extending | |
920 (the `final free block' referred to above) might have | |
921 changed, if it got combined with a freed info table. */ | |
922 block = _heapinfo[0].free.prev; | |
923 _heapinfo[block].free.size += (wantblocks - lastblocks); | |
924 _bytes_free += (wantblocks - lastblocks) * BLOCKSIZE; | |
925 _heaplimit += wantblocks - lastblocks; | |
926 continue; | |
927 } | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
928 result = morecore_nolock (wantblocks * BLOCKSIZE); |
17130 | 929 if (result == NULL) |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
930 goto out; |
17130 | 931 block = BLOCK (result); |
932 /* Put the new block at the end of the free list. */ | |
933 _heapinfo[block].free.size = wantblocks; | |
934 _heapinfo[block].free.prev = _heapinfo[0].free.prev; | |
935 _heapinfo[block].free.next = 0; | |
936 _heapinfo[0].free.prev = block; | |
937 _heapinfo[_heapinfo[block].free.prev].free.next = block; | |
938 ++_chunks_free; | |
939 /* Now loop to use some of that block for this allocation. */ | |
940 } | |
941 } | |
942 | |
943 /* At this point we have found a suitable free list entry. | |
944 Figure out how to remove what we need from the list. */ | |
945 result = ADDRESS (block); | |
946 if (_heapinfo[block].free.size > blocks) | |
947 { | |
948 /* The block we found has a bit left over, | |
949 so relink the tail end back into the free list. */ | |
950 _heapinfo[block + blocks].free.size | |
951 = _heapinfo[block].free.size - blocks; | |
952 _heapinfo[block + blocks].free.next | |
953 = _heapinfo[block].free.next; | |
954 _heapinfo[block + blocks].free.prev | |
955 = _heapinfo[block].free.prev; | |
956 _heapinfo[_heapinfo[block].free.prev].free.next | |
957 = _heapinfo[_heapinfo[block].free.next].free.prev | |
958 = _heapindex = block + blocks; | |
959 } | |
960 else | |
961 { | |
962 /* The block exactly matches our requirements, | |
963 so just remove it from the list. */ | |
964 _heapinfo[_heapinfo[block].free.next].free.prev | |
965 = _heapinfo[block].free.prev; | |
966 _heapinfo[_heapinfo[block].free.prev].free.next | |
967 = _heapindex = _heapinfo[block].free.next; | |
968 --_chunks_free; | |
969 } | |
970 | |
971 _heapinfo[block].busy.type = 0; | |
972 _heapinfo[block].busy.info.size = blocks; | |
973 ++_chunks_used; | |
974 _bytes_used += blocks * BLOCKSIZE; | |
975 _bytes_free -= blocks * BLOCKSIZE; | |
976 | |
977 /* Mark all the blocks of the object just allocated except for the | |
978 first with a negative number so you can find the first block by | |
979 adding that adjustment. */ | |
980 while (--blocks > 0) | |
981 _heapinfo[block + blocks].busy.info.size = -blocks; | |
982 } | |
983 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
984 PROTECT_MALLOC_STATE (1); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
985 out: |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
986 return result; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
987 } |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
988 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
989 __ptr_t |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
990 _malloc_internal (size) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
991 __malloc_size_t size; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
992 { |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
993 __ptr_t result; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
994 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
995 LOCK (); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
996 result = _malloc_internal_nolock (size); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
997 UNLOCK (); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
998 |
17130 | 999 return result; |
1000 } | |
1001 | |
1002 __ptr_t | |
1003 malloc (size) | |
1004 __malloc_size_t size; | |
1005 { | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1006 __ptr_t (*hook) (__malloc_size_t); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1007 |
17130 | 1008 if (!__malloc_initialized && !__malloc_initialize ()) |
1009 return NULL; | |
1010 | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1011 /* Copy the value of __malloc_hook to an automatic variable in case |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1012 __malloc_hook is modified in another thread between its |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1013 NULL-check and the use. |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1014 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1015 Note: Strictly speaking, this is not a right solution. We should |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1016 use mutexes to access non-read-only variables that are shared |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1017 among multiple threads. We just leave it for compatibility with |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1018 glibc malloc (i.e., assignments to __malloc_hook) for now. */ |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1019 hook = __malloc_hook; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1020 return (hook != NULL ? *hook : _malloc_internal) (size); |
17130 | 1021 } |
1022 | |
1023 #ifndef _LIBC | |
1024 | |
1025 /* On some ANSI C systems, some libc functions call _malloc, _free | |
1026 and _realloc. Make them use the GNU functions. */ | |
1027 | |
1028 __ptr_t | |
1029 _malloc (size) | |
1030 __malloc_size_t size; | |
1031 { | |
1032 return malloc (size); | |
1033 } | |
1034 | |
1035 void | |
1036 _free (ptr) | |
1037 __ptr_t ptr; | |
1038 { | |
1039 free (ptr); | |
1040 } | |
1041 | |
1042 __ptr_t | |
1043 _realloc (ptr, size) | |
1044 __ptr_t ptr; | |
1045 __malloc_size_t size; | |
1046 { | |
1047 return realloc (ptr, size); | |
1048 } | |
1049 | |
1050 #endif | |
1051 /* Free a block of memory allocated by `malloc'. | |
1052 Copyright 1990, 1991, 1992, 1994, 1995 Free Software Foundation, Inc. | |
1053 Written May 1989 by Mike Haertel. | |
1054 | |
1055 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1056 modify it under the terms of the GNU General Public License as |
17130 | 1057 published by the Free Software Foundation; either version 2 of the |
1058 License, or (at your option) any later version. | |
1059 | |
1060 This library is distributed in the hope that it will be useful, | |
1061 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1062 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1063 General Public License for more details. |
17130 | 1064 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1065 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1066 License along with this library; see the file COPYING. If |
64092 | 1067 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1068 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 1069 |
1070 The author may be reached (Email) at the address mike@ai.mit.edu, | |
1071 or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1072 | |
1073 #ifndef _MALLOC_INTERNAL | |
1074 #define _MALLOC_INTERNAL | |
1075 #include <malloc.h> | |
1076 #endif | |
1077 | |
1078 | |
1079 /* Cope with systems lacking `memmove'. */ | |
1080 #ifndef memmove | |
91702
b7a5a89054dc
* configure.in (LIBX11_MACHINE, HAVE_XFREE386): Remove code
Dan Nicolaescu <dann@ics.uci.edu>
parents:
82335
diff
changeset
|
1081 #if (!defined(_LIBC) && !defined(STDC_HEADERS) && !defined(USG)) |
17130 | 1082 #ifdef emacs |
1083 #undef __malloc_safe_bcopy | |
1084 #define __malloc_safe_bcopy safe_bcopy | |
1085 #endif | |
1086 /* This function is defined in realloc.c. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1087 extern void __malloc_safe_bcopy PP ((__ptr_t, __ptr_t, __malloc_size_t)); |
17130 | 1088 #define memmove(to, from, size) __malloc_safe_bcopy ((from), (to), (size)) |
1089 #endif | |
1090 #endif | |
1091 | |
1092 | |
1093 /* Debugging hook for free. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1094 void (*__free_hook) PP ((__ptr_t __ptr)); |
17130 | 1095 |
1096 /* List of blocks allocated by memalign. */ | |
1097 struct alignlist *_aligned_blocks = NULL; | |
1098 | |
1099 /* Return memory to the heap. | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1100 Like `_free_internal' but don't lock mutex. */ |
17130 | 1101 void |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1102 _free_internal_nolock (ptr) |
17130 | 1103 __ptr_t ptr; |
1104 { | |
1105 int type; | |
1106 __malloc_size_t block, blocks; | |
1107 register __malloc_size_t i; | |
1108 struct list *prev, *next; | |
1109 __ptr_t curbrk; | |
1110 const __malloc_size_t lesscore_threshold | |
1111 /* Threshold of free space at which we will return some to the system. */ | |
1112 = FINAL_FREE_BLOCKS + 2 * __malloc_extra_blocks; | |
1113 | |
1114 register struct alignlist *l; | |
1115 | |
1116 if (ptr == NULL) | |
1117 return; | |
1118 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1119 PROTECT_MALLOC_STATE (0); |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
1120 |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1121 LOCK_ALIGNED_BLOCKS (); |
17130 | 1122 for (l = _aligned_blocks; l != NULL; l = l->next) |
1123 if (l->aligned == ptr) | |
1124 { | |
1125 l->aligned = NULL; /* Mark the slot in the list as free. */ | |
1126 ptr = l->exact; | |
1127 break; | |
1128 } | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1129 UNLOCK_ALIGNED_BLOCKS (); |
17130 | 1130 |
1131 block = BLOCK (ptr); | |
1132 | |
1133 type = _heapinfo[block].busy.type; | |
1134 switch (type) | |
1135 { | |
1136 case 0: | |
1137 /* Get as many statistics as early as we can. */ | |
1138 --_chunks_used; | |
1139 _bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE; | |
1140 _bytes_free += _heapinfo[block].busy.info.size * BLOCKSIZE; | |
1141 | |
1142 /* Find the free cluster previous to this one in the free list. | |
1143 Start searching at the last block referenced; this may benefit | |
1144 programs with locality of allocation. */ | |
1145 i = _heapindex; | |
1146 if (i > block) | |
1147 while (i > block) | |
1148 i = _heapinfo[i].free.prev; | |
1149 else | |
1150 { | |
1151 do | |
1152 i = _heapinfo[i].free.next; | |
1153 while (i > 0 && i < block); | |
1154 i = _heapinfo[i].free.prev; | |
1155 } | |
1156 | |
1157 /* Determine how to link this block into the free list. */ | |
1158 if (block == i + _heapinfo[i].free.size) | |
1159 { | |
1160 /* Coalesce this block with its predecessor. */ | |
1161 _heapinfo[i].free.size += _heapinfo[block].busy.info.size; | |
1162 block = i; | |
1163 } | |
1164 else | |
1165 { | |
1166 /* Really link this block back into the free list. */ | |
1167 _heapinfo[block].free.size = _heapinfo[block].busy.info.size; | |
1168 _heapinfo[block].free.next = _heapinfo[i].free.next; | |
1169 _heapinfo[block].free.prev = i; | |
1170 _heapinfo[i].free.next = block; | |
1171 _heapinfo[_heapinfo[block].free.next].free.prev = block; | |
1172 ++_chunks_free; | |
1173 } | |
1174 | |
1175 /* Now that the block is linked in, see if we can coalesce it | |
1176 with its successor (by deleting its successor from the list | |
1177 and adding in its size). */ | |
1178 if (block + _heapinfo[block].free.size == _heapinfo[block].free.next) | |
1179 { | |
1180 _heapinfo[block].free.size | |
1181 += _heapinfo[_heapinfo[block].free.next].free.size; | |
1182 _heapinfo[block].free.next | |
1183 = _heapinfo[_heapinfo[block].free.next].free.next; | |
1184 _heapinfo[_heapinfo[block].free.next].free.prev = block; | |
1185 --_chunks_free; | |
1186 } | |
1187 | |
1188 /* How many trailing free blocks are there now? */ | |
1189 blocks = _heapinfo[block].free.size; | |
1190 | |
1191 /* Where is the current end of accessible core? */ | |
1192 curbrk = (*__morecore) (0); | |
1193 | |
1194 if (_heaplimit != 0 && curbrk == ADDRESS (_heaplimit)) | |
1195 { | |
1196 /* The end of the malloc heap is at the end of accessible core. | |
1197 It's possible that moving _heapinfo will allow us to | |
1198 return some space to the system. */ | |
1199 | |
1200 __malloc_size_t info_block = BLOCK (_heapinfo); | |
1201 __malloc_size_t info_blocks = _heapinfo[info_block].busy.info.size; | |
1202 __malloc_size_t prev_block = _heapinfo[block].free.prev; | |
1203 __malloc_size_t prev_blocks = _heapinfo[prev_block].free.size; | |
1204 __malloc_size_t next_block = _heapinfo[block].free.next; | |
1205 __malloc_size_t next_blocks = _heapinfo[next_block].free.size; | |
1206 | |
1207 if (/* Win if this block being freed is last in core, the info table | |
1208 is just before it, the previous free block is just before the | |
1209 info table, and the two free blocks together form a useful | |
1210 amount to return to the system. */ | |
1211 (block + blocks == _heaplimit && | |
1212 info_block + info_blocks == block && | |
1213 prev_block != 0 && prev_block + prev_blocks == info_block && | |
1214 blocks + prev_blocks >= lesscore_threshold) || | |
1215 /* Nope, not the case. We can also win if this block being | |
1216 freed is just before the info table, and the table extends | |
1217 to the end of core or is followed only by a free block, | |
1218 and the total free space is worth returning to the system. */ | |
1219 (block + blocks == info_block && | |
1220 ((info_block + info_blocks == _heaplimit && | |
1221 blocks >= lesscore_threshold) || | |
1222 (info_block + info_blocks == next_block && | |
1223 next_block + next_blocks == _heaplimit && | |
1224 blocks + next_blocks >= lesscore_threshold))) | |
1225 ) | |
1226 { | |
1227 malloc_info *newinfo; | |
1228 __malloc_size_t oldlimit = _heaplimit; | |
1229 | |
1230 /* Free the old info table, clearing _heaplimit to avoid | |
1231 recursion into this code. We don't want to return the | |
1232 table's blocks to the system before we have copied them to | |
1233 the new location. */ | |
1234 _heaplimit = 0; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1235 _free_internal_nolock (_heapinfo); |
17130 | 1236 _heaplimit = oldlimit; |
1237 | |
1238 /* Tell malloc to search from the beginning of the heap for | |
1239 free blocks, so it doesn't reuse the ones just freed. */ | |
1240 _heapindex = 0; | |
1241 | |
1242 /* Allocate new space for the info table and move its data. */ | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1243 newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1244 * BLOCKSIZE); |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1245 PROTECT_MALLOC_STATE (0); |
17130 | 1246 memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE); |
1247 _heapinfo = newinfo; | |
1248 | |
1249 /* We should now have coalesced the free block with the | |
1250 blocks freed from the old info table. Examine the entire | |
1251 trailing free block to decide below whether to return some | |
1252 to the system. */ | |
1253 block = _heapinfo[0].free.prev; | |
1254 blocks = _heapinfo[block].free.size; | |
1255 } | |
1256 | |
1257 /* Now see if we can return stuff to the system. */ | |
1258 if (block + blocks == _heaplimit && blocks >= lesscore_threshold) | |
1259 { | |
1260 register __malloc_size_t bytes = blocks * BLOCKSIZE; | |
1261 _heaplimit -= blocks; | |
1262 (*__morecore) (-bytes); | |
1263 _heapinfo[_heapinfo[block].free.prev].free.next | |
1264 = _heapinfo[block].free.next; | |
1265 _heapinfo[_heapinfo[block].free.next].free.prev | |
1266 = _heapinfo[block].free.prev; | |
1267 block = _heapinfo[block].free.prev; | |
1268 --_chunks_free; | |
1269 _bytes_free -= bytes; | |
1270 } | |
1271 } | |
1272 | |
1273 /* Set the next search to begin at this block. */ | |
1274 _heapindex = block; | |
1275 break; | |
1276 | |
1277 default: | |
1278 /* Do some of the statistics. */ | |
1279 --_chunks_used; | |
1280 _bytes_used -= 1 << type; | |
1281 ++_chunks_free; | |
1282 _bytes_free += 1 << type; | |
1283 | |
1284 /* Get the address of the first free fragment in this block. */ | |
1285 prev = (struct list *) ((char *) ADDRESS (block) + | |
1286 (_heapinfo[block].busy.info.frag.first << type)); | |
1287 | |
1288 if (_heapinfo[block].busy.info.frag.nfree == (BLOCKSIZE >> type) - 1) | |
1289 { | |
1290 /* If all fragments of this block are free, remove them | |
1291 from the fragment list and free the whole block. */ | |
1292 next = prev; | |
1293 for (i = 1; i < (__malloc_size_t) (BLOCKSIZE >> type); ++i) | |
1294 next = next->next; | |
1295 prev->prev->next = next; | |
1296 if (next != NULL) | |
1297 next->prev = prev->prev; | |
1298 _heapinfo[block].busy.type = 0; | |
1299 _heapinfo[block].busy.info.size = 1; | |
1300 | |
1301 /* Keep the statistics accurate. */ | |
1302 ++_chunks_used; | |
1303 _bytes_used += BLOCKSIZE; | |
1304 _chunks_free -= BLOCKSIZE >> type; | |
1305 _bytes_free -= BLOCKSIZE; | |
1306 | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1307 #if defined (GC_MALLOC_CHECK) || defined (USE_PTHREAD) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1308 _free_internal_nolock (ADDRESS (block)); |
32693
8223a86fa594
(_malloc_internal) [GC_MALLOC_CHECK]: Use
Gerd Moellmann <gerd@gnu.org>
parents:
29837
diff
changeset
|
1309 #else |
17130 | 1310 free (ADDRESS (block)); |
32693
8223a86fa594
(_malloc_internal) [GC_MALLOC_CHECK]: Use
Gerd Moellmann <gerd@gnu.org>
parents:
29837
diff
changeset
|
1311 #endif |
17130 | 1312 } |
1313 else if (_heapinfo[block].busy.info.frag.nfree != 0) | |
1314 { | |
1315 /* If some fragments of this block are free, link this | |
1316 fragment into the fragment list after the first free | |
1317 fragment of this block. */ | |
1318 next = (struct list *) ptr; | |
1319 next->next = prev->next; | |
1320 next->prev = prev; | |
1321 prev->next = next; | |
1322 if (next->next != NULL) | |
1323 next->next->prev = next; | |
1324 ++_heapinfo[block].busy.info.frag.nfree; | |
1325 } | |
1326 else | |
1327 { | |
1328 /* No fragments of this block are free, so link this | |
1329 fragment into the fragment list and announce that | |
1330 it is the first free fragment of this block. */ | |
1331 prev = (struct list *) ptr; | |
1332 _heapinfo[block].busy.info.frag.nfree = 1; | |
1333 _heapinfo[block].busy.info.frag.first = (unsigned long int) | |
1334 ((unsigned long int) ((char *) ptr - (char *) NULL) | |
1335 % BLOCKSIZE >> type); | |
1336 prev->next = _fraghead[type].next; | |
1337 prev->prev = &_fraghead[type]; | |
1338 prev->prev->next = prev; | |
1339 if (prev->next != NULL) | |
1340 prev->next->prev = prev; | |
1341 } | |
1342 break; | |
1343 } | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
1344 |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1345 PROTECT_MALLOC_STATE (1); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1346 } |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1347 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1348 /* Return memory to the heap. |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1349 Like `free' but don't call a __free_hook if there is one. */ |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1350 void |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1351 _free_internal (ptr) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1352 __ptr_t ptr; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1353 { |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1354 LOCK (); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1355 _free_internal_nolock (ptr); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1356 UNLOCK (); |
17130 | 1357 } |
1358 | |
1359 /* Return memory to the heap. */ | |
26526
b7438760079b
* callproc.c (strerror): Remove decl.
Paul Eggert <eggert@twinsun.com>
parents:
26088
diff
changeset
|
1360 |
91702
b7a5a89054dc
* configure.in (LIBX11_MACHINE, HAVE_XFREE386): Remove code
Dan Nicolaescu <dann@ics.uci.edu>
parents:
82335
diff
changeset
|
1361 void |
17130 | 1362 free (ptr) |
1363 __ptr_t ptr; | |
1364 { | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1365 void (*hook) (__ptr_t) = __free_hook; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1366 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1367 if (hook != NULL) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1368 (*hook) (ptr); |
17130 | 1369 else |
1370 _free_internal (ptr); | |
1371 } | |
1372 | |
1373 /* Define the `cfree' alias for `free'. */ | |
1374 #ifdef weak_alias | |
1375 weak_alias (free, cfree) | |
1376 #else | |
1377 void | |
1378 cfree (ptr) | |
1379 __ptr_t ptr; | |
1380 { | |
1381 free (ptr); | |
1382 } | |
1383 #endif | |
1384 /* Change the size of a block allocated by `malloc'. | |
1385 Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
1386 Written May 1989 by Mike Haertel. | |
1387 | |
1388 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1389 modify it under the terms of the GNU General Public License as |
17130 | 1390 published by the Free Software Foundation; either version 2 of the |
1391 License, or (at your option) any later version. | |
1392 | |
1393 This library is distributed in the hope that it will be useful, | |
1394 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1395 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1396 General Public License for more details. |
17130 | 1397 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1398 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1399 License along with this library; see the file COPYING. If |
64092 | 1400 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1401 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 1402 |
1403 The author may be reached (Email) at the address mike@ai.mit.edu, | |
1404 or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1405 | |
1406 #ifndef _MALLOC_INTERNAL | |
1407 #define _MALLOC_INTERNAL | |
1408 #include <malloc.h> | |
1409 #endif | |
1410 | |
1411 | |
1412 | |
1413 /* Cope with systems lacking `memmove'. */ | |
91702
b7a5a89054dc
* configure.in (LIBX11_MACHINE, HAVE_XFREE386): Remove code
Dan Nicolaescu <dann@ics.uci.edu>
parents:
82335
diff
changeset
|
1414 #if (!defined(_LIBC) && !defined(STDC_HEADERS) && !defined(USG)) |
17130 | 1415 |
1416 #ifdef emacs | |
1417 #undef __malloc_safe_bcopy | |
1418 #define __malloc_safe_bcopy safe_bcopy | |
1419 #else | |
1420 | |
1421 /* Snarfed directly from Emacs src/dispnew.c: | |
1422 XXX Should use system bcopy if it handles overlap. */ | |
1423 | |
1424 /* Like bcopy except never gets confused by overlap. */ | |
1425 | |
1426 void | |
1427 __malloc_safe_bcopy (afrom, ato, size) | |
1428 __ptr_t afrom; | |
1429 __ptr_t ato; | |
1430 __malloc_size_t size; | |
1431 { | |
1432 char *from = afrom, *to = ato; | |
1433 | |
1434 if (size <= 0 || from == to) | |
1435 return; | |
1436 | |
1437 /* If the source and destination don't overlap, then bcopy can | |
1438 handle it. If they do overlap, but the destination is lower in | |
1439 memory than the source, we'll assume bcopy can handle that. */ | |
1440 if (to < from || from + size <= to) | |
1441 bcopy (from, to, size); | |
1442 | |
1443 /* Otherwise, we'll copy from the end. */ | |
1444 else | |
1445 { | |
1446 register char *endf = from + size; | |
1447 register char *endt = to + size; | |
1448 | |
1449 /* If TO - FROM is large, then we should break the copy into | |
1450 nonoverlapping chunks of TO - FROM bytes each. However, if | |
1451 TO - FROM is small, then the bcopy function call overhead | |
1452 makes this not worth it. The crossover point could be about | |
1453 anywhere. Since I don't think the obvious copy loop is too | |
1454 bad, I'm trying to err in its favor. */ | |
1455 if (to - from < 64) | |
1456 { | |
1457 do | |
1458 *--endt = *--endf; | |
1459 while (endf != from); | |
1460 } | |
1461 else | |
1462 { | |
1463 for (;;) | |
1464 { | |
1465 endt -= (to - from); | |
1466 endf -= (to - from); | |
1467 | |
1468 if (endt < to) | |
1469 break; | |
1470 | |
1471 bcopy (endf, endt, to - from); | |
1472 } | |
1473 | |
1474 /* If SIZE wasn't a multiple of TO - FROM, there will be a | |
1475 little left over. The amount left over is | |
1476 (endt + (to - from)) - to, which is endt - from. */ | |
1477 bcopy (from, to, endt - from); | |
1478 } | |
1479 } | |
1480 } | |
1481 #endif /* emacs */ | |
1482 | |
1483 #ifndef memmove | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1484 extern void __malloc_safe_bcopy PP ((__ptr_t, __ptr_t, __malloc_size_t)); |
17130 | 1485 #define memmove(to, from, size) __malloc_safe_bcopy ((from), (to), (size)) |
1486 #endif | |
1487 | |
1488 #endif | |
1489 | |
1490 | |
1491 #define min(A, B) ((A) < (B) ? (A) : (B)) | |
1492 | |
1493 /* Debugging hook for realloc. */ | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1494 __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size)); |
17130 | 1495 |
1496 /* Resize the given region to the new size, returning a pointer | |
1497 to the (possibly moved) region. This is optimized for speed; | |
1498 some benchmarks seem to indicate that greater compactness is | |
1499 achieved by unconditionally allocating and copying to a | |
1500 new region. This module has incestuous knowledge of the | |
1501 internals of both free and malloc. */ | |
1502 __ptr_t | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1503 _realloc_internal_nolock (ptr, size) |
17130 | 1504 __ptr_t ptr; |
1505 __malloc_size_t size; | |
1506 { | |
1507 __ptr_t result; | |
1508 int type; | |
1509 __malloc_size_t block, blocks, oldlimit; | |
1510 | |
1511 if (size == 0) | |
1512 { | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1513 _free_internal_nolock (ptr); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1514 return _malloc_internal_nolock (0); |
17130 | 1515 } |
1516 else if (ptr == NULL) | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1517 return _malloc_internal_nolock (size); |
17130 | 1518 |
1519 block = BLOCK (ptr); | |
1520 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1521 PROTECT_MALLOC_STATE (0); |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
1522 |
17130 | 1523 type = _heapinfo[block].busy.type; |
1524 switch (type) | |
1525 { | |
1526 case 0: | |
1527 /* Maybe reallocate a large block to a small fragment. */ | |
1528 if (size <= BLOCKSIZE / 2) | |
1529 { | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1530 result = _malloc_internal_nolock (size); |
17130 | 1531 if (result != NULL) |
1532 { | |
1533 memcpy (result, ptr, size); | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1534 _free_internal_nolock (ptr); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1535 goto out; |
17130 | 1536 } |
1537 } | |
1538 | |
1539 /* The new size is a large allocation as well; | |
1540 see if we can hold it in place. */ | |
1541 blocks = BLOCKIFY (size); | |
1542 if (blocks < _heapinfo[block].busy.info.size) | |
1543 { | |
1544 /* The new size is smaller; return | |
1545 excess memory to the free list. */ | |
1546 _heapinfo[block + blocks].busy.type = 0; | |
1547 _heapinfo[block + blocks].busy.info.size | |
1548 = _heapinfo[block].busy.info.size - blocks; | |
1549 _heapinfo[block].busy.info.size = blocks; | |
1550 /* We have just created a new chunk by splitting a chunk in two. | |
1551 Now we will free this chunk; increment the statistics counter | |
1552 so it doesn't become wrong when _free_internal decrements it. */ | |
1553 ++_chunks_used; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1554 _free_internal_nolock (ADDRESS (block + blocks)); |
17130 | 1555 result = ptr; |
1556 } | |
1557 else if (blocks == _heapinfo[block].busy.info.size) | |
1558 /* No size change necessary. */ | |
1559 result = ptr; | |
1560 else | |
1561 { | |
1562 /* Won't fit, so allocate a new region that will. | |
1563 Free the old region first in case there is sufficient | |
1564 adjacent free space to grow without moving. */ | |
1565 blocks = _heapinfo[block].busy.info.size; | |
1566 /* Prevent free from actually returning memory to the system. */ | |
1567 oldlimit = _heaplimit; | |
1568 _heaplimit = 0; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1569 _free_internal_nolock (ptr); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1570 result = _malloc_internal_nolock (size); |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1571 PROTECT_MALLOC_STATE (0); |
17130 | 1572 if (_heaplimit == 0) |
1573 _heaplimit = oldlimit; | |
1574 if (result == NULL) | |
1575 { | |
1576 /* Now we're really in trouble. We have to unfree | |
1577 the thing we just freed. Unfortunately it might | |
1578 have been coalesced with its neighbors. */ | |
1579 if (_heapindex == block) | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1580 (void) _malloc_internal_nolock (blocks * BLOCKSIZE); |
17130 | 1581 else |
1582 { | |
1583 __ptr_t previous | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1584 = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1585 (void) _malloc_internal_nolock (blocks * BLOCKSIZE); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1586 _free_internal_nolock (previous); |
17130 | 1587 } |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1588 goto out; |
17130 | 1589 } |
1590 if (ptr != result) | |
1591 memmove (result, ptr, blocks * BLOCKSIZE); | |
1592 } | |
1593 break; | |
1594 | |
1595 default: | |
1596 /* Old size is a fragment; type is logarithm | |
1597 to base two of the fragment size. */ | |
1598 if (size > (__malloc_size_t) (1 << (type - 1)) && | |
1599 size <= (__malloc_size_t) (1 << type)) | |
1600 /* The new size is the same kind of fragment. */ | |
1601 result = ptr; | |
1602 else | |
1603 { | |
1604 /* The new size is different; allocate a new space, | |
1605 and copy the lesser of the new size and the old. */ | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1606 result = _malloc_internal_nolock (size); |
17130 | 1607 if (result == NULL) |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1608 goto out; |
17130 | 1609 memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type)); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1610 _free_internal_nolock (ptr); |
17130 | 1611 } |
1612 break; | |
1613 } | |
1614 | |
32821
08e5ab6d998f
(state_protected_p, last_state_size, last_heapinfo)
Gerd Moellmann <gerd@gnu.org>
parents:
32693
diff
changeset
|
1615 PROTECT_MALLOC_STATE (1); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1616 out: |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1617 return result; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1618 } |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1619 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1620 __ptr_t |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1621 _realloc_internal (ptr, size) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1622 __ptr_t ptr; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1623 __malloc_size_t size; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1624 { |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1625 __ptr_t result; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1626 |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1627 LOCK(); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1628 result = _realloc_internal_nolock (ptr, size); |
76776
2bb28b957639
[HAVE_GTK_AND_PTHREAD]: Define USE_PTHREAD.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
75348
diff
changeset
|
1629 UNLOCK (); |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1630 |
17130 | 1631 return result; |
1632 } | |
1633 | |
1634 __ptr_t | |
1635 realloc (ptr, size) | |
1636 __ptr_t ptr; | |
1637 __malloc_size_t size; | |
1638 { | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1639 __ptr_t (*hook) (__ptr_t, __malloc_size_t); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1640 |
17130 | 1641 if (!__malloc_initialized && !__malloc_initialize ()) |
1642 return NULL; | |
1643 | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1644 hook = __realloc_hook; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1645 return (hook != NULL ? *hook : _realloc_internal) (ptr, size); |
17130 | 1646 } |
1647 /* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc. | |
1648 | |
1649 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1650 modify it under the terms of the GNU General Public License as |
17130 | 1651 published by the Free Software Foundation; either version 2 of the |
1652 License, or (at your option) any later version. | |
1653 | |
1654 This library is distributed in the hope that it will be useful, | |
1655 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1656 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1657 General Public License for more details. |
17130 | 1658 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1659 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1660 License along with this library; see the file COPYING. If |
64092 | 1661 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1662 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 1663 |
1664 The author may be reached (Email) at the address mike@ai.mit.edu, | |
1665 or (US mail) as Mike Haertel c/o Free Software Foundation. */ | |
1666 | |
1667 #ifndef _MALLOC_INTERNAL | |
1668 #define _MALLOC_INTERNAL | |
1669 #include <malloc.h> | |
1670 #endif | |
1671 | |
1672 /* Allocate an array of NMEMB elements each SIZE bytes long. | |
1673 The entire array is initialized to zeros. */ | |
1674 __ptr_t | |
1675 calloc (nmemb, size) | |
1676 register __malloc_size_t nmemb; | |
1677 register __malloc_size_t size; | |
1678 { | |
1679 register __ptr_t result = malloc (nmemb * size); | |
1680 | |
1681 if (result != NULL) | |
1682 (void) memset (result, 0, nmemb * size); | |
1683 | |
1684 return result; | |
1685 } | |
1686 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
1687 This file is part of the GNU C Library. | |
1688 | |
1689 The GNU C Library is free software; you can redistribute it and/or modify | |
1690 it under the terms of the GNU General Public License as published by | |
1691 the Free Software Foundation; either version 2, or (at your option) | |
1692 any later version. | |
1693 | |
1694 The GNU C Library is distributed in the hope that it will be useful, | |
1695 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1696 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
1697 GNU General Public License for more details. | |
1698 | |
1699 You should have received a copy of the GNU General Public License | |
1700 along with the GNU C Library; see the file COPYING. If not, write to | |
64092 | 1701 the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, |
1702 MA 02110-1301, USA. */ | |
17130 | 1703 |
1704 #ifndef _MALLOC_INTERNAL | |
1705 #define _MALLOC_INTERNAL | |
1706 #include <malloc.h> | |
1707 #endif | |
1708 | |
98455
876b289a899e
* gmalloc.c (__sbrk): Also define for uClibc.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
95236
diff
changeset
|
1709 /* uClibc defines __GNU_LIBRARY__, but it is not completely |
876b289a899e
* gmalloc.c (__sbrk): Also define for uClibc.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
95236
diff
changeset
|
1710 compatible. */ |
876b289a899e
* gmalloc.c (__sbrk): Also define for uClibc.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
95236
diff
changeset
|
1711 #if !defined(__GNU_LIBRARY__) || defined(__UCLIBC__) |
17130 | 1712 #define __sbrk sbrk |
98455
876b289a899e
* gmalloc.c (__sbrk): Also define for uClibc.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
95236
diff
changeset
|
1713 #else /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */ |
17130 | 1714 /* It is best not to declare this and cast its result on foreign operating |
1715 systems with potentially hostile include files. */ | |
1716 | |
1717 #include <stddef.h> | |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1718 extern __ptr_t __sbrk PP ((ptrdiff_t increment)); |
98455
876b289a899e
* gmalloc.c (__sbrk): Also define for uClibc.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
95236
diff
changeset
|
1719 #endif /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */ |
17130 | 1720 |
1721 #ifndef NULL | |
1722 #define NULL 0 | |
1723 #endif | |
1724 | |
1725 /* Allocate INCREMENT more bytes of data space, | |
1726 and return the start of data space, or NULL on errors. | |
1727 If INCREMENT is negative, shrink data space. */ | |
1728 __ptr_t | |
1729 __default_morecore (increment) | |
1730 __malloc_ptrdiff_t increment; | |
1731 { | |
54824
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1732 __ptr_t result; |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1733 #if defined(CYGWIN) |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1734 if (!bss_sbrk_did_unexec) |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1735 { |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1736 return bss_sbrk (increment); |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1737 } |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1738 #endif |
54395b0b6779
(__default_morecore): Use bss_sbrk(), not __sbrk(), before Cygwin unexec.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
52401
diff
changeset
|
1739 result = (__ptr_t) __sbrk (increment); |
17130 | 1740 if (result == (__ptr_t) -1) |
1741 return NULL; | |
1742 return result; | |
1743 } | |
1744 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc. | |
1745 | |
1746 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1747 modify it under the terms of the GNU General Public License as |
17130 | 1748 published by the Free Software Foundation; either version 2 of the |
1749 License, or (at your option) any later version. | |
1750 | |
1751 This library is distributed in the hope that it will be useful, | |
1752 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
1753 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1754 General Public License for more details. |
17130 | 1755 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1756 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1757 License along with this library; see the file COPYING. If |
64092 | 1758 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1759 Fifth Floor, Boston, MA 02110-1301, USA. */ | |
17130 | 1760 |
1761 #ifndef _MALLOC_INTERNAL | |
1762 #define _MALLOC_INTERNAL | |
1763 #include <malloc.h> | |
1764 #endif | |
1765 | |
1766 #if __DJGPP__ - 0 == 1 | |
1767 | |
1768 /* There is some problem with memalign in DJGPP v1 and we are supposed | |
1769 to omit it. Noone told me why, they just told me to do it. */ | |
1770 | |
1771 #else | |
1772 | |
37372
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
1773 __ptr_t (*__memalign_hook) PP ((__malloc_size_t __size, |
46942d9e7537
(__malloc_size_t) [__GNUC__]: If STDC_HEADERS is not
Eli Zaretskii <eliz@gnu.org>
parents:
37268
diff
changeset
|
1774 __malloc_size_t __alignment)); |
17130 | 1775 |
1776 __ptr_t | |
1777 memalign (alignment, size) | |
1778 __malloc_size_t alignment; | |
1779 __malloc_size_t size; | |
1780 { | |
1781 __ptr_t result; | |
1782 unsigned long int adj, lastadj; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1783 __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook; |
17130 | 1784 |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1785 if (hook) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1786 return (*hook) (alignment, size); |
17130 | 1787 |
1788 /* Allocate a block with enough extra space to pad the block with up to | |
1789 (ALIGNMENT - 1) bytes if necessary. */ | |
1790 result = malloc (size + alignment - 1); | |
1791 if (result == NULL) | |
1792 return NULL; | |
1793 | |
1794 /* Figure out how much we will need to pad this particular block | |
1795 to achieve the required alignment. */ | |
1796 adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment; | |
1797 | |
1798 do | |
1799 { | |
1800 /* Reallocate the block with only as much excess as it needs. */ | |
1801 free (result); | |
1802 result = malloc (adj + size); | |
1803 if (result == NULL) /* Impossible unless interrupted. */ | |
1804 return NULL; | |
1805 | |
1806 lastadj = adj; | |
1807 adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment; | |
1808 /* It's conceivable we might have been so unlucky as to get a | |
1809 different block with weaker alignment. If so, this block is too | |
1810 short to contain SIZE after alignment correction. So we must | |
1811 try again and get another block, slightly larger. */ | |
1812 } while (adj > lastadj); | |
1813 | |
1814 if (adj != 0) | |
1815 { | |
1816 /* Record this block in the list of aligned blocks, so that `free' | |
1817 can identify the pointer it is passed, which will be in the middle | |
1818 of an allocated block. */ | |
1819 | |
1820 struct alignlist *l; | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1821 LOCK_ALIGNED_BLOCKS (); |
17130 | 1822 for (l = _aligned_blocks; l != NULL; l = l->next) |
1823 if (l->aligned == NULL) | |
1824 /* This slot is free. Use it. */ | |
1825 break; | |
1826 if (l == NULL) | |
1827 { | |
1828 l = (struct alignlist *) malloc (sizeof (struct alignlist)); | |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1829 if (l != NULL) |
17130 | 1830 { |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1831 l->next = _aligned_blocks; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1832 _aligned_blocks = l; |
17130 | 1833 } |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1834 } |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1835 if (l != NULL) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1836 { |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1837 l->exact = result; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1838 result = l->aligned = (char *) result + alignment - adj; |
17130 | 1839 } |
81615
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1840 UNLOCK_ALIGNED_BLOCKS (); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1841 if (l == NULL) |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1842 { |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1843 free (result); |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1844 result = NULL; |
059caeb1f502
[HAVE_GTK_AND_PTHREAD] Check this after including config.h.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
81500
diff
changeset
|
1845 } |
17130 | 1846 } |
1847 | |
1848 return result; | |
1849 } | |
1850 | |
82335
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1851 #ifndef ENOMEM |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1852 #define ENOMEM 12 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1853 #endif |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1854 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1855 #ifndef EINVAL |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1856 #define EINVAL 22 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1857 #endif |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1858 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1859 int |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1860 posix_memalign (memptr, alignment, size) |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1861 __ptr_t *memptr; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1862 __malloc_size_t alignment; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1863 __malloc_size_t size; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1864 { |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1865 __ptr_t mem; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1866 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1867 if (alignment == 0 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1868 || alignment % sizeof (__ptr_t) != 0 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1869 || (alignment & (alignment - 1)) != 0) |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1870 return EINVAL; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1871 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1872 mem = memalign (alignment, size); |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1873 if (mem == NULL) |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1874 return ENOMEM; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1875 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1876 *memptr = mem; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1877 |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1878 return 0; |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1879 } |
310b4cdcc703
(posix_memalign): New function.
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
parents:
82308
diff
changeset
|
1880 |
17130 | 1881 #endif /* Not DJGPP v1 */ |
1882 /* Allocate memory on a page boundary. | |
1883 Copyright (C) 1991, 92, 93, 94, 96 Free Software Foundation, Inc. | |
1884 | |
1885 This library is free software; you can redistribute it and/or | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1886 modify it under the terms of the GNU General Public License as |
17130 | 1887 published by the Free Software Foundation; either version 2 of the |
1888 License, or (at your option) any later version. | |
1889 | |
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 | |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1893 General Public License for more details. |
17130 | 1894 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1895 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1896 License along with this library; see the file COPYING. If |
64092 | 1897 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1898 Fifth Floor, Boston, MA 02110-1301, USA. | |
17130 | 1899 |
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. */ | |
1902 | |
1903 #if defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC) | |
1904 | |
1905 /* Emacs defines GMALLOC_INHIBIT_VALLOC to avoid this definition | |
1906 on MSDOS, where it conflicts with a system header file. */ | |
1907 | |
1908 #define ELIDE_VALLOC | |
1909 | |
1910 #endif | |
1911 | |
1912 #ifndef ELIDE_VALLOC | |
1913 | |
1914 #if defined (__GNU_LIBRARY__) || defined (_LIBC) | |
1915 #include <stddef.h> | |
1916 #include <sys/cdefs.h> | |
17131
6ff1e0aec51e
[__GLIBC__ >= 2]: Don't declare __getpagesize.
Karl Heuer <kwzh@gnu.org>
parents:
17130
diff
changeset
|
1917 #if defined (__GLIBC__) && __GLIBC__ >= 2 |
6ff1e0aec51e
[__GLIBC__ >= 2]: Don't declare __getpagesize.
Karl Heuer <kwzh@gnu.org>
parents:
17130
diff
changeset
|
1918 /* __getpagesize is already declared in <unistd.h> with return type int */ |
6ff1e0aec51e
[__GLIBC__ >= 2]: Don't declare __getpagesize.
Karl Heuer <kwzh@gnu.org>
parents:
17130
diff
changeset
|
1919 #else |
18667
d4f53287fc5b
Rename macro __P to PP.
Richard M. Stallman <rms@gnu.org>
parents:
17131
diff
changeset
|
1920 extern size_t __getpagesize PP ((void)); |
17131
6ff1e0aec51e
[__GLIBC__ >= 2]: Don't declare __getpagesize.
Karl Heuer <kwzh@gnu.org>
parents:
17130
diff
changeset
|
1921 #endif |
17130 | 1922 #else |
1923 #include "getpagesize.h" | |
1924 #define __getpagesize() getpagesize() | |
1925 #endif | |
1926 | |
1927 #ifndef _MALLOC_INTERNAL | |
1928 #define _MALLOC_INTERNAL | |
1929 #include <malloc.h> | |
1930 #endif | |
1931 | |
1932 static __malloc_size_t pagesize; | |
1933 | |
1934 __ptr_t | |
1935 valloc (size) | |
1936 __malloc_size_t size; | |
1937 { | |
1938 if (pagesize == 0) | |
1939 pagesize = __getpagesize (); | |
1940 | |
1941 return memalign (pagesize, size); | |
1942 } | |
1943 | |
1944 #endif /* Not ELIDE_VALLOC. */ | |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1945 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1946 #ifdef GC_MCHECK |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1947 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1948 /* Standard debugging hooks for `malloc'. |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1949 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1950 Written May 1989 by Mike Haertel. |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1951 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1952 This library is free software; you can redistribute it and/or |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1953 modify it under the terms of the GNU General Public License as |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1954 published by the Free Software Foundation; either version 2 of the |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1955 License, or (at your option) any later version. |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1956 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1957 This library is distributed in the hope that it will be useful, |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1958 but WITHOUT ANY WARRANTY; without even the implied warranty of |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1959 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1960 General Public License for more details. |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1961 |
72951
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1962 You should have received a copy of the GNU General Public |
751c24f0ec88
Replace "GNU Library General Public License" by "GNU General Public
Jay Belanger <jay.p.belanger@gmail.com>
parents:
68651
diff
changeset
|
1963 License along with this library; see the file COPYING. If |
64092 | 1964 not, write to the Free Software Foundation, Inc., 51 Franklin Street, |
1965 Fifth Floor, Boston, MA 02110-1301, USA. | |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1966 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1967 The author may be reached (Email) at the address mike@ai.mit.edu, |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1968 or (US mail) as Mike Haertel c/o Free Software Foundation. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1969 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1970 #ifdef emacs |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1971 #include <stdio.h> |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1972 #else |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1973 #ifndef _MALLOC_INTERNAL |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1974 #define _MALLOC_INTERNAL |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1975 #include <malloc.h> |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1976 #include <stdio.h> |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1977 #endif |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1978 #endif |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1979 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1980 /* Old hook values. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1981 static void (*old_free_hook) __P ((__ptr_t ptr)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1982 static __ptr_t (*old_malloc_hook) __P ((__malloc_size_t size)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1983 static __ptr_t (*old_realloc_hook) __P ((__ptr_t ptr, __malloc_size_t size)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1984 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1985 /* Function to call when something awful happens. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1986 static void (*abortfunc) __P ((enum mcheck_status)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1987 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1988 /* Arbitrary magical numbers. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1989 #define MAGICWORD 0xfedabeeb |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1990 #define MAGICFREE 0xd8675309 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1991 #define MAGICBYTE ((char) 0xd7) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1992 #define MALLOCFLOOD ((char) 0x93) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1993 #define FREEFLOOD ((char) 0x95) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1994 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1995 struct hdr |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1996 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1997 __malloc_size_t size; /* Exact size requested by user. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1998 unsigned long int magic; /* Magic number to check header integrity. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
1999 }; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2000 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2001 #if defined(_LIBC) || defined(STDC_HEADERS) || defined(USG) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2002 #define flood memset |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2003 #else |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2004 static void flood __P ((__ptr_t, int, __malloc_size_t)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2005 static void |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2006 flood (ptr, val, size) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2007 __ptr_t ptr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2008 int val; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2009 __malloc_size_t size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2010 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2011 char *cp = ptr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2012 while (size--) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2013 *cp++ = val; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2014 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2015 #endif |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2016 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2017 static enum mcheck_status checkhdr __P ((const struct hdr *)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2018 static enum mcheck_status |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2019 checkhdr (hdr) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2020 const struct hdr *hdr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2021 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2022 enum mcheck_status status; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2023 switch (hdr->magic) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2024 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2025 default: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2026 status = MCHECK_HEAD; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2027 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2028 case MAGICFREE: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2029 status = MCHECK_FREE; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2030 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2031 case MAGICWORD: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2032 if (((char *) &hdr[1])[hdr->size] != MAGICBYTE) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2033 status = MCHECK_TAIL; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2034 else |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2035 status = MCHECK_OK; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2036 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2037 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2038 if (status != MCHECK_OK) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2039 (*abortfunc) (status); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2040 return status; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2041 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2042 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2043 static void freehook __P ((__ptr_t)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2044 static void |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2045 freehook (ptr) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2046 __ptr_t ptr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2047 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2048 struct hdr *hdr; |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
2049 |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2050 if (ptr) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2051 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2052 hdr = ((struct hdr *) ptr) - 1; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2053 checkhdr (hdr); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2054 hdr->magic = MAGICFREE; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2055 flood (ptr, FREEFLOOD, hdr->size); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2056 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2057 else |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2058 hdr = NULL; |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
2059 |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2060 __free_hook = old_free_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2061 free (hdr); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2062 __free_hook = freehook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2063 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2064 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2065 static __ptr_t mallochook __P ((__malloc_size_t)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2066 static __ptr_t |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2067 mallochook (size) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2068 __malloc_size_t size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2069 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2070 struct hdr *hdr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2071 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2072 __malloc_hook = old_malloc_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2073 hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2074 __malloc_hook = mallochook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2075 if (hdr == NULL) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2076 return NULL; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2077 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2078 hdr->size = size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2079 hdr->magic = MAGICWORD; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2080 ((char *) &hdr[1])[size] = MAGICBYTE; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2081 flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2082 return (__ptr_t) (hdr + 1); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2083 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2084 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2085 static __ptr_t reallochook __P ((__ptr_t, __malloc_size_t)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2086 static __ptr_t |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2087 reallochook (ptr, size) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2088 __ptr_t ptr; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2089 __malloc_size_t size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2090 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2091 struct hdr *hdr = NULL; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2092 __malloc_size_t osize = 0; |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
2093 |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2094 if (ptr) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2095 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2096 hdr = ((struct hdr *) ptr) - 1; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2097 osize = hdr->size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2098 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2099 checkhdr (hdr); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2100 if (size < osize) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2101 flood ((char *) ptr + size, FREEFLOOD, osize - size); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2102 } |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
40670
diff
changeset
|
2103 |
32973
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2104 __free_hook = old_free_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2105 __malloc_hook = old_malloc_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2106 __realloc_hook = old_realloc_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2107 hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2108 __free_hook = freehook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2109 __malloc_hook = mallochook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2110 __realloc_hook = reallochook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2111 if (hdr == NULL) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2112 return NULL; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2113 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2114 hdr->size = size; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2115 hdr->magic = MAGICWORD; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2116 ((char *) &hdr[1])[size] = MAGICBYTE; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2117 if (size > osize) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2118 flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2119 return (__ptr_t) (hdr + 1); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2120 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2121 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2122 static void |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2123 mabort (status) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2124 enum mcheck_status status; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2125 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2126 const char *msg; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2127 switch (status) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2128 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2129 case MCHECK_OK: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2130 msg = "memory is consistent, library is buggy"; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2131 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2132 case MCHECK_HEAD: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2133 msg = "memory clobbered before allocated block"; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2134 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2135 case MCHECK_TAIL: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2136 msg = "memory clobbered past end of allocated block"; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2137 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2138 case MCHECK_FREE: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2139 msg = "block freed twice"; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2140 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2141 default: |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2142 msg = "bogus mcheck_status, library is buggy"; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2143 break; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2144 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2145 #ifdef __GNU_LIBRARY__ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2146 __libc_fatal (msg); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2147 #else |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2148 fprintf (stderr, "mcheck: %s\n", msg); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2149 fflush (stderr); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2150 abort (); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2151 #endif |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2152 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2153 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2154 static int mcheck_used = 0; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2155 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2156 int |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2157 mcheck (func) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2158 void (*func) __P ((enum mcheck_status)); |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2159 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2160 abortfunc = (func != NULL) ? func : &mabort; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2161 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2162 /* These hooks may not be safely inserted if malloc is already in use. */ |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2163 if (!__malloc_initialized && !mcheck_used) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2164 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2165 old_free_hook = __free_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2166 __free_hook = freehook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2167 old_malloc_hook = __malloc_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2168 __malloc_hook = mallochook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2169 old_realloc_hook = __realloc_hook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2170 __realloc_hook = reallochook; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2171 mcheck_used = 1; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2172 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2173 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2174 return mcheck_used ? 0 : -1; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2175 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2176 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2177 enum mcheck_status |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2178 mprobe (__ptr_t ptr) |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2179 { |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2180 return mcheck_used ? checkhdr (ptr) : MCHECK_DISABLED; |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2181 } |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2182 |
c3f68b4d9e37
Add code from mcheck.c of glibc-1.09.1.
Gerd Moellmann <gerd@gnu.org>
parents:
32821
diff
changeset
|
2183 #endif /* GC_MCHECK */ |
52401 | 2184 |
2185 /* arch-tag: 93dce5c0-f49a-41b5-86b1-f91c4169c02e | |
2186 (do not change this comment) */ |