annotate src/ralloc.c @ 86187:2a95aa038f83

Add: declare-function, check-declare, process-lines.
author Glenn Morris <rgm@gnu.org>
date Sat, 17 Nov 2007 03:51:20 +0000
parents 922696f363b0
children fc2bcd2a8aad f55f9811f5d7
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1 /* Block-relocating memory allocator.
75227
e90d04cd455a Update copyright for years from Emacs 21 to present (mainly adding
Glenn Morris <rgm@gnu.org>
parents: 73539
diff changeset
2 Copyright (C) 1993, 1995, 2000, 2001, 2002, 2003, 2004,
e90d04cd455a Update copyright for years from Emacs 21 to present (mainly adding
Glenn Morris <rgm@gnu.org>
parents: 73539
diff changeset
3 2005, 2006, 2007 Free Software Foundation, Inc.
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
4
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
5 This file is part of GNU Emacs.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
6
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
7 GNU Emacs is free software; you can redistribute it and/or modify
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
8 it under the terms of the GNU General Public License as published by
78260
922696f363b0 Switch license to GPLv3 or later.
Glenn Morris <rgm@gnu.org>
parents: 75227
diff changeset
9 the Free Software Foundation; either version 3, or (at your option)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
10 any later version.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
11
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
12 GNU Emacs is distributed in the hope that it will be useful,
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
15 GNU General Public License for more details.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
16
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
17 You should have received a copy of the GNU General Public License
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
18 along with GNU Emacs; see the file COPYING. If not, write to
64084
a8fa7c632ee4 Update FSF's address.
Lute Kamstra <lute@gnu.org>
parents: 61226
diff changeset
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
a8fa7c632ee4 Update FSF's address.
Lute Kamstra <lute@gnu.org>
parents: 61226
diff changeset
20 Boston, MA 02110-1301, USA. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
21
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
22 /* NOTES:
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
23
3591
507f64624555 Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents: 3136
diff changeset
24 Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
25 rather than all of them. This means allowing for a possible
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
26 hole between the first bloc and the end of malloc storage. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
27
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
28 #ifdef emacs
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
29
4696
1fc792473491 Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents: 4230
diff changeset
30 #include <config.h>
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
31 #include "lisp.h" /* Needed for VALBITS. */
61226
1050c59c8ed5 #include blockinput also
Jan Djärv <jan.h.d@swipnet.se>
parents: 61225
diff changeset
32 #include "blockinput.h"
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
33
29917
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
34 #ifdef HAVE_UNISTD_H
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
35 #include <unistd.h>
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
36 #endif
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
37
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
38 typedef POINTER_TYPE *POINTER;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
39 typedef size_t SIZE;
1451
107c9b227e7f [emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents: 1403
diff changeset
40
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
41 /* Declared in dispnew.c, this version doesn't screw up if regions
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
42 overlap. */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
43
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
44 extern void safe_bcopy ();
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
45
17845
ac6367122ee2 (mallopt): Declare, if appropriate.
Richard M. Stallman <rms@gnu.org>
parents: 14953
diff changeset
46 #ifdef DOUG_LEA_MALLOC
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
47 #define M_TOP_PAD -2
17845
ac6367122ee2 (mallopt): Declare, if appropriate.
Richard M. Stallman <rms@gnu.org>
parents: 14953
diff changeset
48 extern int mallopt ();
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
49 #else /* not DOUG_LEA_MALLOC */
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
50 #ifndef SYSTEM_MALLOC
31891
d8d68cbd1113 (__malloc_extra_blocks): Declare as __malloc_size_t.
Dave Love <fx@gnu.org>
parents: 31606
diff changeset
51 extern size_t __malloc_extra_blocks;
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
52 #endif /* SYSTEM_MALLOC */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
53 #endif /* not DOUG_LEA_MALLOC */
10785
f3a45c2e57c2 (r_alloc_init): Set __malloc_extra_blocks.
Richard M. Stallman <rms@gnu.org>
parents: 10767
diff changeset
54
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
55 #else /* not emacs */
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
56
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
57 #include <stddef.h>
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
58
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
59 typedef size_t SIZE;
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
60 typedef void *POINTER;
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
61
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
62 #include <unistd.h>
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
63 #include <malloc.h>
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
64
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
65 #define safe_bcopy(x, y, z) memmove (y, x, z)
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
66 #define bzero(x, len) memset (x, 0, len)
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
67
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
68 #endif /* not emacs */
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
69
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
70
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
71 #include "getpagesize.h"
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
72
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
73 #define NIL ((POINTER) 0)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
74
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
75 /* A flag to indicate whether we have initialized ralloc yet. For
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
76 Emacs's sake, please do not make this local to malloc_init; on some
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
77 machines, the dumping procedure makes all static variables
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
78 read-only. On these machines, the word static is #defined to be
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
79 the empty string, meaning that r_alloc_initialized becomes an
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
80 automatic variable, and loses its value each time Emacs is started
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
81 up. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
82
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
83 static int r_alloc_initialized = 0;
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
84
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
85 static void r_alloc_init ();
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
86
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
87
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
88 /* Declarations for working with the malloc, ralloc, and system breaks. */
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
89
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
90 /* Function to set the real break value. */
30061
3de459e6c652 Make real_morecore non-static.
Andrew Innes <andrewi@gnu.org>
parents: 29917
diff changeset
91 POINTER (*real_morecore) ();
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
92
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
93 /* The break value, as seen by malloc. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
94 static POINTER virtual_break_value;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
95
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
96 /* The address of the end of the last data in use by ralloc,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
97 including relocatable blocs as well as malloc data. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
98 static POINTER break_value;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
99
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
100 /* This is the size of a page. We round memory requests to this boundary. */
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
101 static int page_size;
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
102
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
103 /* Whenever we get memory from the system, get this many extra bytes. This
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
104 must be a multiple of page_size. */
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
105 static int extra_bytes;
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
106
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
107 /* Macros for rounding. Note that rounding to any value is possible
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
108 by changing the definition of PAGE. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
109 #define PAGE (getpagesize ())
4230
df4d091e603e (ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents: 3591
diff changeset
110 #define ALIGNED(addr) (((unsigned long int) (addr) & (page_size - 1)) == 0)
df4d091e603e (ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents: 3591
diff changeset
111 #define ROUNDUP(size) (((unsigned long int) (size) + page_size - 1) \
df4d091e603e (ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents: 3591
diff changeset
112 & ~(page_size - 1))
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
113 #define ROUND_TO_PAGE(addr) (addr & (~(page_size - 1)))
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
114
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
115 #define MEM_ALIGN sizeof(double)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
116 #define MEM_ROUNDUP(addr) (((unsigned long int)(addr) + MEM_ALIGN - 1) \
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
117 & ~(MEM_ALIGN - 1))
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
118
36187
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
119 /* The hook `malloc' uses for the function which gets more space
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
120 from the system. */
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
121
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
122 #ifndef SYSTEM_MALLOC
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
123 extern POINTER (*__morecore) ();
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
124 #endif
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
125
72f30168f26c (__morecore) [!SYSTEM_MALLOC]: Move declaration
Gerd Moellmann <gerd@gnu.org>
parents: 31891
diff changeset
126
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
127
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
128 /***********************************************************************
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
129 Implementation using sbrk
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
130 ***********************************************************************/
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
131
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
132 /* Data structures of heaps and blocs. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
133
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
134 /* The relocatable objects, or blocs, and the malloc data
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
135 both reside within one or more heaps.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
136 Each heap contains malloc data, running from `start' to `bloc_start',
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
137 and relocatable objects, running from `bloc_start' to `free'.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
138
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
139 Relocatable objects may relocate within the same heap
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
140 or may move into another heap; the heaps themselves may grow
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
141 but they never move.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
142
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
143 We try to make just one heap and make it larger as necessary.
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
144 But sometimes we can't do that, because we can't get contiguous
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
145 space to add onto the heap. When that happens, we start a new heap. */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
146
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
147 typedef struct heap
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
148 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
149 struct heap *next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
150 struct heap *prev;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
151 /* Start of memory range of this heap. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
152 POINTER start;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
153 /* End of memory range of this heap. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
154 POINTER end;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
155 /* Start of relocatable data in this heap. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
156 POINTER bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
157 /* Start of unused space in this heap. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
158 POINTER free;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
159 /* First bloc in this heap. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
160 struct bp *first_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
161 /* Last bloc in this heap. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
162 struct bp *last_bloc;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
163 } *heap_ptr;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
164
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
165 #define NIL_HEAP ((heap_ptr) 0)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
166 #define HEAP_PTR_SIZE (sizeof (struct heap))
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
167
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
168 /* This is the first heap object.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
169 If we need additional heap objects, each one resides at the beginning of
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
170 the space it covers. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
171 static struct heap heap_base;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
172
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
173 /* Head and tail of the list of heaps. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
174 static heap_ptr first_heap, last_heap;
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
175
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
176 /* These structures are allocated in the malloc arena.
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
177 The linked list is kept in order of increasing '.data' members.
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
178 The data blocks abut each other; if b->next is non-nil, then
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
179 b->data + b->size == b->next->data.
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
180
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
181 An element with variable==NIL denotes a freed block, which has not yet
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
182 been collected. They may only appear while r_alloc_freeze > 0, and will be
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
183 freed when the arena is thawed. Currently, these blocs are not reusable,
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
184 while the arena is frozen. Very inefficient. */
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
185
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
186 typedef struct bp
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
187 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
188 struct bp *next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
189 struct bp *prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
190 POINTER *variable;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
191 POINTER data;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
192 SIZE size;
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
193 POINTER new_data; /* temporarily used for relocation */
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
194 struct heap *heap; /* Heap this bloc is in. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
195 } *bloc_ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
196
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
197 #define NIL_BLOC ((bloc_ptr) 0)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
198 #define BLOC_PTR_SIZE (sizeof (struct bp))
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
199
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
200 /* Head and tail of the list of relocatable blocs. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
201 static bloc_ptr first_bloc, last_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
202
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
203 static int use_relocatable_buffers;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
204
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
205 /* If >0, no relocation whatsoever takes place. */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
206 static int r_alloc_freeze_level;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
207
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
208
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
209 /* Functions to get and return memory from the system. */
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
210
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
211 /* Find the heap that ADDRESS falls within. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
212
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
213 static heap_ptr
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
214 find_heap (address)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
215 POINTER address;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
216 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
217 heap_ptr heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
218
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
219 for (heap = last_heap; heap; heap = heap->prev)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
220 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
221 if (heap->start <= address && address <= heap->end)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
222 return heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
223 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
224
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
225 return NIL_HEAP;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
226 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
227
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
228 /* Find SIZE bytes of space in a heap.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
229 Try to get them at ADDRESS (which must fall within some heap's range)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
230 if we can get that many within one heap.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
231
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
232 If enough space is not presently available in our reserve, this means
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
233 getting more page-aligned space from the system. If the returned space
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
234 is not contiguous to the last heap, allocate a new heap, and append it
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
235
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
236 obtain does not try to keep track of whether space is in use
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
237 or not in use. It just returns the address of SIZE bytes that
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
238 fall within a single heap. If you call obtain twice in a row
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
239 with the same arguments, you typically get the same value.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
240 to the heap list. It's the caller's responsibility to keep
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
241 track of what space is in use.
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
242
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
243 Return the address of the space if all went well, or zero if we couldn't
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
244 allocate the memory. */
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
245
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
246 static POINTER
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
247 obtain (address, size)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
248 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
249 SIZE size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
250 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
251 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
252 SIZE already_available;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
253
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
254 /* Find the heap that ADDRESS falls within. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
255 for (heap = last_heap; heap; heap = heap->prev)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
256 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
257 if (heap->start <= address && address <= heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
258 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
259 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
260
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
261 if (! heap)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
262 abort ();
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
263
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
264 /* If we can't fit SIZE bytes in that heap,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
265 try successive later heaps. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
266 while (heap && (char *) address + size > (char *) heap->end)
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
267 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
268 heap = heap->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
269 if (heap == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
270 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
271 address = heap->bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
272 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
273
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
274 /* If we can't fit them within any existing heap,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
275 get more space. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
276 if (heap == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
277 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
278 POINTER new = (*real_morecore)(0);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
279 SIZE get;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
280
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
281 already_available = (char *)last_heap->end - (char *)address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
282
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
283 if (new != last_heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
284 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
285 /* Someone else called sbrk. Make a new heap. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
286
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
287 heap_ptr new_heap = (heap_ptr) MEM_ROUNDUP (new);
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
288 POINTER bloc_start = (POINTER) MEM_ROUNDUP ((POINTER)(new_heap + 1));
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
289
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
290 if ((*real_morecore) ((char *) bloc_start - (char *) new) != new)
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
291 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
292
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
293 new_heap->start = new;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
294 new_heap->end = bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
295 new_heap->bloc_start = bloc_start;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
296 new_heap->free = bloc_start;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
297 new_heap->next = NIL_HEAP;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
298 new_heap->prev = last_heap;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
299 new_heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
300 new_heap->last_bloc = NIL_BLOC;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
301 last_heap->next = new_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
302 last_heap = new_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
303
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
304 address = bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
305 already_available = 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
306 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
307
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
308 /* Add space to the last heap (which we may have just created).
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
309 Get some extra, so we can come here less often. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
310
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
311 get = size + extra_bytes - already_available;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
312 get = (char *) ROUNDUP ((char *)last_heap->end + get)
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
313 - (char *) last_heap->end;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
314
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
315 if ((*real_morecore) (get) != last_heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
316 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
317
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
318 last_heap->end = (char *) last_heap->end + get;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
319 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
320
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
321 return address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
322 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
323
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
324 /* Return unused heap space to the system
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
325 if there is a lot of unused space now.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
326 This can make the last heap smaller;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
327 it can also eliminate the last heap entirely. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
328
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
329 static void
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
330 relinquish ()
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
331 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
332 register heap_ptr h;
73539
db045c86d29b * ralloc.c (relinquish): Use a long for excess space counter to
Chong Yidong <cyd@stupidchicken.com>
parents: 68651
diff changeset
333 long excess = 0;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
334
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
335 /* Add the amount of space beyond break_value
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
336 in all heaps which have extend beyond break_value at all. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
337
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
338 for (h = last_heap; h && break_value < h->end; h = h->prev)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
339 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
340 excess += (char *) h->end - (char *) ((break_value < h->bloc_start)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
341 ? h->bloc_start : break_value);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
342 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
343
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
344 if (excess > extra_bytes * 2 && (*real_morecore) (0) == last_heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
345 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
346 /* Keep extra_bytes worth of empty space.
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
347 And don't free anything unless we can free at least extra_bytes. */
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
348 excess -= extra_bytes;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
349
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
350 if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
351 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
352 /* This heap should have no blocs in it. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
353 if (last_heap->first_bloc != NIL_BLOC
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
354 || last_heap->last_bloc != NIL_BLOC)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
355 abort ();
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
356
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
357 /* Return the last heap, with its header, to the system. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
358 excess = (char *)last_heap->end - (char *)last_heap->start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
359 last_heap = last_heap->prev;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
360 last_heap->next = NIL_HEAP;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
361 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
362 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
363 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
364 excess = (char *) last_heap->end
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
365 - (char *) ROUNDUP ((char *)last_heap->end - excess);
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
366 last_heap->end = (char *) last_heap->end - excess;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
367 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
368
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
369 if ((*real_morecore) (- excess) == 0)
19999
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
370 {
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
371 /* If the system didn't want that much memory back, adjust
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
372 the end of the last heap to reflect that. This can occur
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
373 if break_value is still within the original data segment. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
374 last_heap->end = (char *) last_heap->end + excess;
19999
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
375 /* Make sure that the result of the adjustment is accurate.
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
376 It should be, for the else clause above; the other case,
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
377 which returns the entire last heap to the system, seems
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
378 unlikely to trigger this mode of failure. */
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
379 if (last_heap->end != (*real_morecore) (0))
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
380 abort ();
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
381 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
382 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
383 }
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
384
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
385 /* Return the total size in use by relocating allocator,
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
386 above where malloc gets space. */
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
387
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
388 long
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
389 r_alloc_size_in_use ()
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
390 {
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
391 return (char *) break_value - (char *) virtual_break_value;
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
392 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
393
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
394 /* The meat - allocating, freeing, and relocating blocs. */
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
395
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
396 /* Find the bloc referenced by the address in PTR. Returns a pointer
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
397 to that block. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
398
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
399 static bloc_ptr
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
400 find_bloc (ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
401 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
402 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
403 register bloc_ptr p = first_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
404
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
405 while (p != NIL_BLOC)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
406 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
407 if (p->variable == ptr && p->data == *ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
408 return p;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
409
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
410 p = p->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
411 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
412
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
413 return p;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
414 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
415
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
416 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
417 Returns a pointer to the new bloc, or zero if we couldn't allocate
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
418 memory for the new block. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
419
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
420 static bloc_ptr
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
421 get_bloc (size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
422 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
423 {
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
424 register bloc_ptr new_bloc;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
425 register heap_ptr heap;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
426
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
427 if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
428 || ! (new_bloc->data = obtain (break_value, size)))
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
429 {
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
430 if (new_bloc)
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
431 free (new_bloc);
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
432
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
433 return 0;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
434 }
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
435
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
436 break_value = (char *) new_bloc->data + size;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
437
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
438 new_bloc->size = size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
439 new_bloc->next = NIL_BLOC;
1013
6bf2c4766d4c * ralloc.c (get_bloc): When initializing new_bloc->variable, cast
Jim Blandy <jimb@redhat.com>
parents: 734
diff changeset
440 new_bloc->variable = (POINTER *) NIL;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
441 new_bloc->new_data = 0;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
442
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
443 /* Record in the heap that this space is in use. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
444 heap = find_heap (new_bloc->data);
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
445 heap->free = break_value;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
446
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
447 /* Maintain the correspondence between heaps and blocs. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
448 new_bloc->heap = heap;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
449 heap->last_bloc = new_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
450 if (heap->first_bloc == NIL_BLOC)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
451 heap->first_bloc = new_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
452
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
453 /* Put this bloc on the doubly-linked list of blocs. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
454 if (first_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
455 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
456 new_bloc->prev = last_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
457 last_bloc->next = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
458 last_bloc = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
459 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
460 else
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
461 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
462 first_bloc = last_bloc = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
463 new_bloc->prev = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
464 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
465
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
466 return new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
467 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
468
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
469 /* Calculate new locations of blocs in the list beginning with BLOC,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
470 relocating it to start at ADDRESS, in heap HEAP. If enough space is
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
471 not presently available in our reserve, call obtain for
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
472 more space.
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
473
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
474 Store the new location of each bloc in its new_data field.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
475 Do not touch the contents of blocs or break_value. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
476
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
477 static int
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
478 relocate_blocs (bloc, heap, address)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
479 bloc_ptr bloc;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
480 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
481 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
482 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
483 register bloc_ptr b = bloc;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
484
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
485 /* No need to ever call this if arena is frozen, bug somewhere! */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
486 if (r_alloc_freeze_level)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
487 abort();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
488
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
489 while (b)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
490 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
491 /* If bloc B won't fit within HEAP,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
492 move to the next heap and try again. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
493 while (heap && (char *) address + b->size > (char *) heap->end)
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
494 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
495 heap = heap->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
496 if (heap == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
497 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
498 address = heap->bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
499 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
500
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
501 /* If BLOC won't fit in any heap,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
502 get enough new space to hold BLOC and all following blocs. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
503 if (heap == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
504 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
505 register bloc_ptr tb = b;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
506 register SIZE s = 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
507
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
508 /* Add up the size of all the following blocs. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
509 while (tb != NIL_BLOC)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
510 {
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
511 if (tb->variable)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
512 s += tb->size;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
513
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
514 tb = tb->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
515 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
516
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
517 /* Get that space. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
518 address = obtain (address, s);
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
519 if (address == 0)
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
520 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
521
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
522 heap = last_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
523 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
524
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
525 /* Record the new address of this bloc
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
526 and update where the next bloc can start. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
527 b->new_data = address;
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
528 if (b->variable)
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
529 address = (char *) address + b->size;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
530 b = b->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
531 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
532
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
533 return 1;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
534 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
535
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
536 /* Reorder the bloc BLOC to go before bloc BEFORE in the doubly linked list.
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
537 This is necessary if we put the memory of space of BLOC
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
538 before that of BEFORE. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
539
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
540 static void
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
541 reorder_bloc (bloc, before)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
542 bloc_ptr bloc, before;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
543 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
544 bloc_ptr prev, next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
545
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
546 /* Splice BLOC out from where it is. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
547 prev = bloc->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
548 next = bloc->next;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
549
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
550 if (prev)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
551 prev->next = next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
552 if (next)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
553 next->prev = prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
554
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
555 /* Splice it in before BEFORE. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
556 prev = before->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
557
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
558 if (prev)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
559 prev->next = bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
560 bloc->prev = prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
561
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
562 before->prev = bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
563 bloc->next = before;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
564 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
565
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
566 /* Update the records of which heaps contain which blocs, starting
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
567 with heap HEAP and bloc BLOC. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
568
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
569 static void
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
570 update_heap_bloc_correspondence (bloc, heap)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
571 bloc_ptr bloc;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
572 heap_ptr heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
573 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
574 register bloc_ptr b;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
575
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
576 /* Initialize HEAP's status to reflect blocs before BLOC. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
577 if (bloc != NIL_BLOC && bloc->prev != NIL_BLOC && bloc->prev->heap == heap)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
578 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
579 /* The previous bloc is in HEAP. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
580 heap->last_bloc = bloc->prev;
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
581 heap->free = (char *) bloc->prev->data + bloc->prev->size;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
582 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
583 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
584 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
585 /* HEAP contains no blocs before BLOC. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
586 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
587 heap->last_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
588 heap->free = heap->bloc_start;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
589 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
590
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
591 /* Advance through blocs one by one. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
592 for (b = bloc; b != NIL_BLOC; b = b->next)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
593 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
594 /* Advance through heaps, marking them empty,
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
595 till we get to the one that B is in. */
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
596 while (heap)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
597 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
598 if (heap->bloc_start <= b->data && b->data <= heap->end)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
599 break;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
600 heap = heap->next;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
601 /* We know HEAP is not null now,
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
602 because there has to be space for bloc B. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
603 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
604 heap->last_bloc = NIL_BLOC;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
605 heap->free = heap->bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
606 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
607
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
608 /* Update HEAP's status for bloc B. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
609 heap->free = (char *) b->data + b->size;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
610 heap->last_bloc = b;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
611 if (heap->first_bloc == NIL_BLOC)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
612 heap->first_bloc = b;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
613
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
614 /* Record that B is in HEAP. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
615 b->heap = heap;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
616 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
617
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
618 /* If there are any remaining heaps and no blocs left,
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
619 mark those heaps as empty. */
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
620 heap = heap->next;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
621 while (heap)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
622 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
623 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
624 heap->last_bloc = NIL_BLOC;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
625 heap->free = heap->bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
626 heap = heap->next;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
627 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
628 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
629
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
630 /* Resize BLOC to SIZE bytes. This relocates the blocs
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
631 that come after BLOC in memory. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
632
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
633 static int
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
634 resize_bloc (bloc, size)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
635 bloc_ptr bloc;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
636 SIZE size;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
637 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
638 register bloc_ptr b;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
639 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
640 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
641 SIZE old_size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
642
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
643 /* No need to ever call this if arena is frozen, bug somewhere! */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
644 if (r_alloc_freeze_level)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
645 abort();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
646
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
647 if (bloc == NIL_BLOC || size == bloc->size)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
648 return 1;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
649
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
650 for (heap = first_heap; heap != NIL_HEAP; heap = heap->next)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
651 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
652 if (heap->bloc_start <= bloc->data && bloc->data <= heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
653 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
654 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
655
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
656 if (heap == NIL_HEAP)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
657 abort ();
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
658
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
659 old_size = bloc->size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
660 bloc->size = size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
661
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
662 /* Note that bloc could be moved into the previous heap. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
663 address = (bloc->prev ? (char *) bloc->prev->data + bloc->prev->size
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
664 : (char *) first_heap->bloc_start);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
665 while (heap)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
666 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
667 if (heap->bloc_start <= address && address <= heap->end)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
668 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
669 heap = heap->prev;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
670 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
671
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
672 if (! relocate_blocs (bloc, heap, address))
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
673 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
674 bloc->size = old_size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
675 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
676 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
677
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
678 if (size > old_size)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
679 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
680 for (b = last_bloc; b != bloc; b = b->prev)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
681 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
682 if (!b->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
683 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
684 b->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
685 b->data = b->new_data;
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
686 }
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
687 else
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
688 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
689 safe_bcopy (b->data, b->new_data, b->size);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
690 *b->variable = b->data = b->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
691 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
692 }
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
693 if (!bloc->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
694 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
695 bloc->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
696 bloc->data = bloc->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
697 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
698 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
699 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
700 safe_bcopy (bloc->data, bloc->new_data, old_size);
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
701 bzero ((char *) bloc->new_data + old_size, size - old_size);
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
702 *bloc->variable = bloc->data = bloc->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
703 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
704 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
705 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
706 {
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
707 for (b = bloc; b != NIL_BLOC; b = b->next)
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
708 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
709 if (!b->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
710 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
711 b->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
712 b->data = b->new_data;
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
713 }
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
714 else
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
715 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
716 safe_bcopy (b->data, b->new_data, b->size);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
717 *b->variable = b->data = b->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
718 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
719 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
720 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
721
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
722 update_heap_bloc_correspondence (bloc, heap);
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
723
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
724 break_value = (last_bloc ? (char *) last_bloc->data + last_bloc->size
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
725 : (char *) first_heap->bloc_start);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
726 return 1;
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
727 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
728
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
729 /* Free BLOC from the chain of blocs, relocating any blocs above it.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
730 This may return space to the system. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
731
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
732 static void
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
733 free_bloc (bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
734 bloc_ptr bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
735 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
736 heap_ptr heap = bloc->heap;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
737
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
738 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
739 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
740 bloc->variable = (POINTER *) NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
741 return;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
742 }
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
743
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
744 resize_bloc (bloc, 0);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
745
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
746 if (bloc == first_bloc && bloc == last_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
747 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
748 first_bloc = last_bloc = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
749 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
750 else if (bloc == last_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
751 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
752 last_bloc = bloc->prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
753 last_bloc->next = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
754 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
755 else if (bloc == first_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
756 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
757 first_bloc = bloc->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
758 first_bloc->prev = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
759 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
760 else
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
761 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
762 bloc->next->prev = bloc->prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
763 bloc->prev->next = bloc->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
764 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
765
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
766 /* Update the records of which blocs are in HEAP. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
767 if (heap->first_bloc == bloc)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
768 {
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
769 if (bloc->next != 0 && bloc->next->heap == heap)
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
770 heap->first_bloc = bloc->next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
771 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
772 heap->first_bloc = heap->last_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
773 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
774 if (heap->last_bloc == bloc)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
775 {
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
776 if (bloc->prev != 0 && bloc->prev->heap == heap)
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
777 heap->last_bloc = bloc->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
778 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
779 heap->first_bloc = heap->last_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
780 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
781
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
782 relinquish ();
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
783 free (bloc);
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
784 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
785
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
786 /* Interface routines. */
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
787
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
788 /* Obtain SIZE bytes of storage from the free pool, or the system, as
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
789 necessary. If relocatable blocs are in use, this means relocating
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
790 them. This function gets plugged into the GNU malloc's __morecore
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
791 hook.
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
792
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
793 We provide hysteresis, never relocating by less than extra_bytes.
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
794
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
795 If we're out of memory, we should return zero, to imitate the other
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
796 __morecore hook values - in particular, __default_morecore in the
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
797 GNU malloc package. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
798
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
799 POINTER
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
800 r_alloc_sbrk (size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
801 long size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
802 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
803 register bloc_ptr b;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
804 POINTER address;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
805
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
806 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
807 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
808
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
809 if (! use_relocatable_buffers)
1401
9689db083f88 (sbrk): Removed decl.
Roland McGrath <roland@gnu.org>
parents: 1398
diff changeset
810 return (*real_morecore) (size);
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
811
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
812 if (size == 0)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
813 return virtual_break_value;
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
814
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
815 if (size > 0)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
816 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
817 /* Allocate a page-aligned space. GNU malloc would reclaim an
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
818 extra space if we passed an unaligned one. But we could
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
819 not always find a space which is contiguous to the previous. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
820 POINTER new_bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
821 heap_ptr h = first_heap;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
822 SIZE get = ROUNDUP (size);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
823
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
824 address = (POINTER) ROUNDUP (virtual_break_value);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
825
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
826 /* Search the list upward for a heap which is large enough. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
827 while ((char *) h->end < (char *) MEM_ROUNDUP ((char *)address + get))
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
828 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
829 h = h->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
830 if (h == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
831 break;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
832 address = (POINTER) ROUNDUP (h->start);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
833 }
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
834
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
835 /* If not found, obtain more space. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
836 if (h == NIL_HEAP)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
837 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
838 get += extra_bytes + page_size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
839
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
840 if (! obtain (address, get))
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
841 return 0;
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
842
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
843 if (first_heap == last_heap)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
844 address = (POINTER) ROUNDUP (virtual_break_value);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
845 else
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
846 address = (POINTER) ROUNDUP (last_heap->start);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
847 h = last_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
848 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
849
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
850 new_bloc_start = (POINTER) MEM_ROUNDUP ((char *)address + get);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
851
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
852 if (first_heap->bloc_start < new_bloc_start)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
853 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
854 /* This is no clean solution - no idea how to do it better. */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
855 if (r_alloc_freeze_level)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
856 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
857
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
858 /* There is a bug here: if the above obtain call succeeded, but the
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
859 relocate_blocs call below does not succeed, we need to free
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
860 the memory that we got with obtain. */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
861
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
862 /* Move all blocs upward. */
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
863 if (! relocate_blocs (first_bloc, h, new_bloc_start))
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
864 return 0;
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
865
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
866 /* Note that (POINTER)(h+1) <= new_bloc_start since
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
867 get >= page_size, so the following does not destroy the heap
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
868 header. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
869 for (b = last_bloc; b != NIL_BLOC; b = b->prev)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
870 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
871 safe_bcopy (b->data, b->new_data, b->size);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
872 *b->variable = b->data = b->new_data;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
873 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
874
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
875 h->bloc_start = new_bloc_start;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
876
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
877 update_heap_bloc_correspondence (first_bloc, h);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
878 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
879 if (h != first_heap)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
880 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
881 /* Give up managing heaps below the one the new
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
882 virtual_break_value points to. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
883 first_heap->prev = NIL_HEAP;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
884 first_heap->next = h->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
885 first_heap->start = h->start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
886 first_heap->end = h->end;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
887 first_heap->free = h->free;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
888 first_heap->first_bloc = h->first_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
889 first_heap->last_bloc = h->last_bloc;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
890 first_heap->bloc_start = h->bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
891
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
892 if (first_heap->next)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
893 first_heap->next->prev = first_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
894 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
895 last_heap = first_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
896 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
897
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
898 bzero (address, size);
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
899 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
900 else /* size < 0 */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
901 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
902 SIZE excess = (char *)first_heap->bloc_start
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
903 - ((char *)virtual_break_value + size);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
904
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
905 address = virtual_break_value;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
906
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
907 if (r_alloc_freeze_level == 0 && excess > 2 * extra_bytes)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
908 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
909 excess -= extra_bytes;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
910 first_heap->bloc_start
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
911 = (POINTER) MEM_ROUNDUP ((char *)first_heap->bloc_start - excess);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
912
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
913 relocate_blocs (first_bloc, first_heap, first_heap->bloc_start);
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
914
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
915 for (b = first_bloc; b != NIL_BLOC; b = b->next)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
916 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
917 safe_bcopy (b->data, b->new_data, b->size);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
918 *b->variable = b->data = b->new_data;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
919 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
920 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
921
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
922 if ((char *)virtual_break_value + size < (char *)first_heap->start)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
923 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
924 /* We found an additional space below the first heap */
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
925 first_heap->start = (POINTER) ((char *)virtual_break_value + size);
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
926 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
927 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
928
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
929 virtual_break_value = (POINTER) ((char *)address + size);
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
930 break_value = (last_bloc
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
931 ? (char *) last_bloc->data + last_bloc->size
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
932 : (char *) first_heap->bloc_start);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
933 if (size < 0)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
934 relinquish ();
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
935
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
936 return address;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
937 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
938
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
939
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
940 /* Allocate a relocatable bloc of storage of size SIZE. A pointer to
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
941 the data is returned in *PTR. PTR is thus the address of some variable
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
942 which will use the data area.
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
943
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
944 The allocation of 0 bytes is valid.
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
945 In case r_alloc_freeze is set, a best fit of unused blocs could be done
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
946 before allocating a new area. Not yet done.
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
947
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
948 If we can't allocate the necessary memory, set *PTR to zero, and
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
949 return zero. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
950
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
951 POINTER
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
952 r_alloc (ptr, size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
953 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
954 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
955 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
956 register bloc_ptr new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
957
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
958 if (! r_alloc_initialized)
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
959 r_alloc_init ();
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
960
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
961 new_bloc = get_bloc (MEM_ROUNDUP (size));
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
962 if (new_bloc)
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
963 {
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
964 new_bloc->variable = ptr;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
965 *ptr = new_bloc->data;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
966 }
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
967 else
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
968 *ptr = 0;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
969
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
970 return *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
971 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
972
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
973 /* Free a bloc of relocatable storage whose data is pointed to by PTR.
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
974 Store 0 in *PTR to show there's no block allocated. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
975
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
976 void
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
977 r_alloc_free (ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
978 register POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
979 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
980 register bloc_ptr dead_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
981
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
982 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
983 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
984
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
985 dead_bloc = find_bloc (ptr);
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
986 if (dead_bloc == NIL_BLOC)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
987 abort ();
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
988
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
989 free_bloc (dead_bloc);
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
990 *ptr = 0;
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
991
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
992 #ifdef emacs
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
993 refill_memory_reserve ();
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
994 #endif
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
995 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
996
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
997 /* Given a pointer at address PTR to relocatable data, resize it to SIZE.
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
998 Do this by shifting all blocks above this one up in memory, unless
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
999 SIZE is less than or equal to the current bloc size, in which case
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
1000 do nothing.
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1001
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1002 In case r_alloc_freeze is set, a new bloc is allocated, and the
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
1003 memory copied to it. Not very efficient. We could traverse the
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1004 bloc_list for a best fit of free blocs first.
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1005
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
1006 Change *PTR to reflect the new bloc, and return this value.
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
1007
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
1008 If more memory cannot be allocated, then leave *PTR unchanged, and
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
1009 return zero. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1010
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1011 POINTER
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1012 r_re_alloc (ptr, size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1013 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1014 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1015 {
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
1016 register bloc_ptr bloc;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1017
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1018 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1019 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1020
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1021 if (!*ptr)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1022 return r_alloc (ptr, size);
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1023 if (!size)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1024 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1025 r_alloc_free (ptr);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1026 return r_alloc (ptr, 0);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1027 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1028
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
1029 bloc = find_bloc (ptr);
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
1030 if (bloc == NIL_BLOC)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1031 abort ();
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1032
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1033 if (size < bloc->size)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1034 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1035 /* Wouldn't it be useful to actually resize the bloc here? */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1036 /* I think so too, but not if it's too expensive... */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1037 if ((bloc->size - MEM_ROUNDUP (size) >= page_size)
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1038 && r_alloc_freeze_level == 0)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1039 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1040 resize_bloc (bloc, MEM_ROUNDUP (size));
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1041 /* Never mind if this fails, just do nothing... */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1042 /* It *should* be infallible! */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1043 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1044 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1045 else if (size > bloc->size)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1046 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1047 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1048 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1049 bloc_ptr new_bloc;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1050 new_bloc = get_bloc (MEM_ROUNDUP (size));
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1051 if (new_bloc)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1052 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1053 new_bloc->variable = ptr;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1054 *ptr = new_bloc->data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1055 bloc->variable = (POINTER *) NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1056 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1057 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1058 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1059 }
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1060 else
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1061 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1062 if (! resize_bloc (bloc, MEM_ROUNDUP (size)))
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1063 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1064 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1065 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1066 return *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1067 }
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1068
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1069 /* Disable relocations, after making room for at least SIZE bytes
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1070 of non-relocatable heap if possible. The relocatable blocs are
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1071 guaranteed to hold still until thawed, even if this means that
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1072 malloc must return a null pointer. */
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
1073
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1074 void
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1075 r_alloc_freeze (size)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1076 long size;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1077 {
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1078 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1079 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1080
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1081 /* If already frozen, we can't make any more room, so don't try. */
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1082 if (r_alloc_freeze_level > 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1083 size = 0;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1084 /* If we can't get the amount requested, half is better than nothing. */
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1085 while (size > 0 && r_alloc_sbrk (size) == 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1086 size /= 2;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1087 ++r_alloc_freeze_level;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1088 if (size > 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1089 r_alloc_sbrk (-size);
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1090 }
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1091
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1092 void
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1093 r_alloc_thaw ()
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1094 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1095
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1096 if (! r_alloc_initialized)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1097 r_alloc_init ();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1098
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1099 if (--r_alloc_freeze_level < 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1100 abort ();
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1101
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1102 /* This frees all unused blocs. It is not too inefficient, as the resize
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1103 and bcopy is done only once. Afterwards, all unreferenced blocs are
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1104 already shrunk to zero size. */
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1105 if (!r_alloc_freeze_level)
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1106 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1107 bloc_ptr *b = &first_bloc;
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1108 while (*b)
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1109 if (!(*b)->variable)
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1110 free_bloc (*b);
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1111 else
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1112 b = &(*b)->next;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1113 }
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1114 }
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1115
18757
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1116
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1117 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1118
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1119 /* Reinitialize the morecore hook variables after restarting a dumped
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1120 Emacs. This is needed when using Doug Lea's malloc from GNU libc. */
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1121 void
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1122 r_alloc_reinit ()
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1123 {
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1124 /* Only do this if the hook has been reset, so that we don't get an
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1125 infinite loop, in case Emacs was linked statically. */
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1126 if (__morecore != r_alloc_sbrk)
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1127 {
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1128 real_morecore = __morecore;
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1129 __morecore = r_alloc_sbrk;
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1130 }
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1131 }
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1132
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1133 #endif /* emacs && DOUG_LEA_MALLOC */
18757
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1134
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1135 #ifdef DEBUG
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1136
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1137 #include <assert.h>
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1138
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1139 void
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1140 r_alloc_check ()
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1141 {
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1142 int found = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1143 heap_ptr h, ph = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1144 bloc_ptr b, pb = 0;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1145
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1146 if (!r_alloc_initialized)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1147 return;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1148
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1149 assert (first_heap);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1150 assert (last_heap->end <= (POINTER) sbrk (0));
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1151 assert ((POINTER) first_heap < first_heap->start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1152 assert (first_heap->start <= virtual_break_value);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1153 assert (virtual_break_value <= first_heap->end);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1154
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1155 for (h = first_heap; h; h = h->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1156 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1157 assert (h->prev == ph);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1158 assert ((POINTER) ROUNDUP (h->end) == h->end);
14953
36e4b3043730 (r_alloc_check): Don't check alignment of h->start.
Richard M. Stallman <rms@gnu.org>
parents: 14186
diff changeset
1159 #if 0 /* ??? The code in ralloc.c does not really try to ensure
36e4b3043730 (r_alloc_check): Don't check alignment of h->start.
Richard M. Stallman <rms@gnu.org>
parents: 14186
diff changeset
1160 the heap start has any sort of alignment.
36e4b3043730 (r_alloc_check): Don't check alignment of h->start.
Richard M. Stallman <rms@gnu.org>
parents: 14186
diff changeset
1161 Perhaps it should. */
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1162 assert ((POINTER) MEM_ROUNDUP (h->start) == h->start);
14953
36e4b3043730 (r_alloc_check): Don't check alignment of h->start.
Richard M. Stallman <rms@gnu.org>
parents: 14186
diff changeset
1163 #endif
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1164 assert ((POINTER) MEM_ROUNDUP (h->bloc_start) == h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1165 assert (h->start <= h->bloc_start && h->bloc_start <= h->end);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1166
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1167 if (ph)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1168 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1169 assert (ph->end < h->start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1170 assert (h->start <= (POINTER)h && (POINTER)(h+1) <= h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1171 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1172
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1173 if (h->bloc_start <= break_value && break_value <= h->end)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1174 found = 1;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1175
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1176 ph = h;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1177 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1178
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1179 assert (found);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1180 assert (last_heap == ph);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1181
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1182 for (b = first_bloc; b; b = b->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1183 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1184 assert (b->prev == pb);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1185 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1186 assert ((SIZE) MEM_ROUNDUP (b->size) == b->size);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1187
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1188 ph = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1189 for (h = first_heap; h; h = h->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1190 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1191 if (h->bloc_start <= b->data && b->data + b->size <= h->end)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1192 break;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1193 ph = h;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1194 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1195
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1196 assert (h);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1197
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1198 if (pb && pb->data + pb->size != b->data)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1199 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1200 assert (ph && b->data == h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1201 while (ph)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1202 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1203 if (ph->bloc_start <= pb->data
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1204 && pb->data + pb->size <= ph->end)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1205 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1206 assert (pb->data + pb->size + b->size > ph->end);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1207 break;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1208 }
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1209 else
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1210 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1211 assert (ph->bloc_start + b->size > ph->end);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1212 }
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1213 ph = ph->prev;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1214 }
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1215 }
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1216 pb = b;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1217 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1218
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1219 assert (last_bloc == pb);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1220
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1221 if (last_bloc)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1222 assert (last_bloc->data + last_bloc->size == break_value);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1223 else
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1224 assert (first_heap->bloc_start == break_value);
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1225 }
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1226
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1227 #endif /* DEBUG */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1228
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1229
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1230
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1231 /***********************************************************************
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1232 Initialization
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1233 ***********************************************************************/
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1234
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1235 /* Initialize various things for memory allocation. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1236
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1237 static void
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1238 r_alloc_init ()
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1239 {
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1240 if (r_alloc_initialized)
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1241 return;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1242 r_alloc_initialized = 1;
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1243
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1244 page_size = PAGE;
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1245 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1246 real_morecore = __morecore;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1247 __morecore = r_alloc_sbrk;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1248
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1249 first_heap = last_heap = &heap_base;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1250 first_heap->next = first_heap->prev = NIL_HEAP;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1251 first_heap->start = first_heap->bloc_start
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1252 = virtual_break_value = break_value = (*real_morecore) (0);
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1253 if (break_value == NIL)
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1254 abort ();
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1255
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1256 extra_bytes = ROUNDUP (50000);
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1257 #endif
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1258
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1259 #ifdef DOUG_LEA_MALLOC
61225
1e515cc6ca0c * alloc.c (allocate_string_data): Call BLOCK_INPUT before calling
Jan Djärv <jan.h.d@swipnet.se>
parents: 52401
diff changeset
1260 BLOCK_INPUT;
1e515cc6ca0c * alloc.c (allocate_string_data): Call BLOCK_INPUT before calling
Jan Djärv <jan.h.d@swipnet.se>
parents: 52401
diff changeset
1261 mallopt (M_TOP_PAD, 64 * 4096);
1e515cc6ca0c * alloc.c (allocate_string_data): Call BLOCK_INPUT before calling
Jan Djärv <jan.h.d@swipnet.se>
parents: 52401
diff changeset
1262 UNBLOCK_INPUT;
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1263 #else
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1264 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1265 /* Give GNU malloc's morecore some hysteresis
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1266 so that we move all the relocatable blocks much less often. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1267 __malloc_extra_blocks = 64;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1268 #endif
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1269 #endif
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1270
31509
6bc82db7d305 (r_alloc_init): Conditionalize on SYSTEM_MALLOC, not REL_ALLOC_MMAP.
Dave Love <fx@gnu.org>
parents: 31504
diff changeset
1271 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1272 first_heap->end = (POINTER) ROUNDUP (first_heap->start);
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1273
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1274 /* The extra call to real_morecore guarantees that the end of the
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1275 address space is a multiple of page_size, even if page_size is
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1276 not really the page size of the system running the binary in
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1277 which page_size is stored. This allows a binary to be built on a
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1278 system with one page size and run on a system with a smaller page
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1279 size. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
1280 (*real_morecore) ((char *) first_heap->end - (char *) first_heap->start);
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1281
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1282 /* Clear the rest of the last page; this memory is in our address space
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1283 even though it is after the sbrk value. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1284 /* Doubly true, with the additional call that explicitly adds the
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1285 rest of that page to the address space. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
1286 bzero (first_heap->start,
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
1287 (char *) first_heap->end - (char *) first_heap->start);
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1288 virtual_break_value = break_value = first_heap->bloc_start = first_heap->end;
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1289 #endif
49600
23a1cea22d13 Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents: 36187
diff changeset
1290
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1291 use_relocatable_buffers = 1;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1292 }
52401
695cf19ef79e Add arch taglines
Miles Bader <miles@gnu.org>
parents: 49600
diff changeset
1293
695cf19ef79e Add arch taglines
Miles Bader <miles@gnu.org>
parents: 49600
diff changeset
1294 /* arch-tag: 6a524a15-faff-44c8-95d4-a5da6f55110f
695cf19ef79e Add arch taglines
Miles Bader <miles@gnu.org>
parents: 49600
diff changeset
1295 (do not change this comment) */