annotate src/ralloc.c @ 36007:6be98ede1ec8

(struct face): Add comment for how to handle a negative value in box_line_width.
author Kenichi Handa <handa@m17n.org>
date Fri, 09 Feb 2001 12:35:06 +0000
parents d8d68cbd1113
children 72f30168f26c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1 /* Block-relocating memory allocator.
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
2 Copyright (C) 1993, 1995, 2000 Free Software Foundation, Inc.
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
3
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
4 This file is part of GNU Emacs.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
5
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
6 GNU Emacs is free software; you can redistribute it and/or modify
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
7 it under the terms of the GNU General Public License as published by
10432
15d01ad97928 (r_alloc_init): Remove unused variable END.
Roland McGrath <roland@gnu.org>
parents: 9666
diff changeset
8 the Free Software Foundation; either version 2, or (at your option)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
9 any later version.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
10
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
11 GNU Emacs is distributed in the hope that it will be useful,
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
14 GNU General Public License for more details.
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
15
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
16 You should have received a copy of the GNU General Public License
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
17 along with GNU Emacs; see the file COPYING. If not, write to
14186
ee40177f6c68 Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents: 14036
diff changeset
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
ee40177f6c68 Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents: 14036
diff changeset
19 Boston, MA 02111-1307, USA. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
20
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
21 /* NOTES:
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
22
3591
507f64624555 Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents: 3136
diff changeset
23 Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
24 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
25 hole between the first bloc and the end of malloc storage. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
26
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
27 #ifdef emacs
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
28
4696
1fc792473491 Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents: 4230
diff changeset
29 #include <config.h>
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
30 #include "lisp.h" /* Needed for VALBITS. */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
31
29917
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
32 #ifdef HAVE_UNISTD_H
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
33 #include <unistd.h>
ee0c984f226d Maybe include unistd.h.
Dave Love <fx@gnu.org>
parents: 19999
diff changeset
34 #endif
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
35
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
36 typedef POINTER_TYPE *POINTER;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
37 typedef size_t SIZE;
1451
107c9b227e7f [emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents: 1403
diff changeset
38
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
39 /* 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
40 overlap. */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
41
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
42 extern void safe_bcopy ();
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
43
17845
ac6367122ee2 (mallopt): Declare, if appropriate.
Richard M. Stallman <rms@gnu.org>
parents: 14953
diff changeset
44 #ifdef DOUG_LEA_MALLOC
ac6367122ee2 (mallopt): Declare, if appropriate.
Richard M. Stallman <rms@gnu.org>
parents: 14953
diff changeset
45 #define M_TOP_PAD -2
ac6367122ee2 (mallopt): Declare, if appropriate.
Richard M. Stallman <rms@gnu.org>
parents: 14953
diff changeset
46 extern int mallopt ();
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
47 #else /* not DOUG_LEA_MALLOC */
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
48 #ifndef SYSTEM_MALLOC
31891
d8d68cbd1113 (__malloc_extra_blocks): Declare as __malloc_size_t.
Dave Love <fx@gnu.org>
parents: 31606
diff changeset
49 extern size_t __malloc_extra_blocks;
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
50 #endif /* SYSTEM_MALLOC */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
51 #endif /* not DOUG_LEA_MALLOC */
10785
f3a45c2e57c2 (r_alloc_init): Set __malloc_extra_blocks.
Richard M. Stallman <rms@gnu.org>
parents: 10767
diff changeset
52
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
53 #else /* not emacs */
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
54
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
55 #include <stddef.h>
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 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
58 typedef void *POINTER;
1403
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
59
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
60 #include <unistd.h>
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
61 #include <malloc.h>
f0ea279194f8 Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents: 1401
diff changeset
62
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
63 #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
64 #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
65
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
66 #endif /* not emacs */
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
67
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
68
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
69 #include "getpagesize.h"
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
70
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
71 #define NIL ((POINTER) 0)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
72
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
73 /* 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
74 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
75 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
76 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
77 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
78 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
79 up. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
80
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
81 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
82
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
83 static void r_alloc_init ();
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
84
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
85
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
86 /* Declarations for working with the malloc, ralloc, and system breaks. */
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
87
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
88 /* Function to set the real break value. */
30061
3de459e6c652 Make real_morecore non-static.
Andrew Innes <andrewi@gnu.org>
parents: 29917
diff changeset
89 POINTER (*real_morecore) ();
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
90
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
91 /* The break value, as seen by malloc. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
92 static POINTER virtual_break_value;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
93
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
94 /* 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
95 including relocatable blocs as well as malloc data. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
96 static POINTER break_value;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
97
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
98 /* 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
99 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
100
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
101 /* Whenever we get memory from the system, get this many extra bytes. This
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
102 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
103 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
104
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
105 /* 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
106 by changing the definition of PAGE. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
107 #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
108 #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
109 #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
110 & ~(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
111 #define ROUND_TO_PAGE(addr) (addr & (~(page_size - 1)))
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
112
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
113 #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
114 #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
115 & ~(MEM_ALIGN - 1))
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
116
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
117
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
118 /***********************************************************************
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
119 Implementation using sbrk
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
120 ***********************************************************************/
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
121
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
122 /* 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
123
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
124 /* 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
125 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
126 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
127 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
128
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
129 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
130 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
131 but they never move.
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
132
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
133 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
134 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
135 space to add onto the heap. When that happens, we start a new heap. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
136
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
137 typedef struct heap
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
138 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
139 struct heap *next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
140 struct heap *prev;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
141 /* 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
142 POINTER start;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
143 /* 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
144 POINTER end;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
145 /* 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
146 POINTER bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
147 /* 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
148 POINTER free;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
149 /* First bloc in this heap. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
150 struct bp *first_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
151 /* Last bloc in this heap. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
152 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
153 } *heap_ptr;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
154
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
155 #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
156 #define HEAP_PTR_SIZE (sizeof (struct heap))
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
157
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
158 /* 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
159 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
160 the space it covers. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
161 static struct heap heap_base;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
162
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
163 /* 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
164 static heap_ptr first_heap, last_heap;
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
165
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
166 /* These structures are allocated in the malloc arena.
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
167 The linked list is kept in order of increasing '.data' members.
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
168 The data blocks abut each other; if b->next is non-nil, then
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
169 b->data + b->size == b->next->data.
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
170
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
171 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
172 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
173 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
174 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
175
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
176 typedef struct bp
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
177 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
178 struct bp *next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
179 struct bp *prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
180 POINTER *variable;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
181 POINTER data;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
182 SIZE size;
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
183 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
184 struct heap *heap; /* Heap this bloc is in. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
185 } *bloc_ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
186
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
187 #define NIL_BLOC ((bloc_ptr) 0)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
188 #define BLOC_PTR_SIZE (sizeof (struct bp))
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
189
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
190 /* Head and tail of the list of relocatable blocs. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
191 static bloc_ptr first_bloc, last_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
192
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
193 static int use_relocatable_buffers;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
194
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
195 /* 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
196 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
197
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
198
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
199 /* 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
200
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
201 /* 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
202
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
203 static heap_ptr
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
204 find_heap (address)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
205 POINTER address;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
206 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
207 heap_ptr heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
208
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
209 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
210 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
211 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
212 return heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
213 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
214
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
215 return NIL_HEAP;
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
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
218 /* 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
219 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
220 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
221
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
222 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
223 getting more page-aligned space from the system. If the returned space
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
224 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
225
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
226 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
227 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
228 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
229 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
230 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
231 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
232
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
233 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
234 allocate the memory. */
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
235
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
236 static POINTER
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
237 obtain (address, size)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
238 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
239 SIZE size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
240 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
241 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
242 SIZE already_available;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
243
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
244 /* 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
245 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
246 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
247 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
248 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
249 }
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 if (! heap)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
252 abort ();
9459
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 /* 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
255 try successive later heaps. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
256 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
257 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
258 heap = heap->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
259 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
260 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
261 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
262 }
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 them within any existing heap,
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
265 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
266 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
267 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
268 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
269 SIZE get;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
270
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
271 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
272
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
273 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
274 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
275 /* 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
276
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
277 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
278 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
279
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
280 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
281 return 0;
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 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
284 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
285 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
286 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
287 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
288 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
289 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
290 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
291 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
292 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
293
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
294 address = bloc_start;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
295 already_available = 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
296 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
297
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
298 /* 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
299 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
300
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
301 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
302 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
303 - (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
304
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
305 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
306 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
307
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
308 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
309 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
310
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
311 return address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
312 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
313
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
314 /* 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
315 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
316 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
317 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
318
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
319 static void
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
320 relinquish ()
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
321 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
322 register heap_ptr h;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
323 int excess = 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
324
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
325 /* 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
326 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
327
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
328 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
329 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
330 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
331 ? 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
332 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
333
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
334 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
335 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
336 /* 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
337 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
338 excess -= extra_bytes;
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 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
341 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
342 /* 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
343 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
344 || 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
345 abort ();
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
346
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
347 /* 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
348 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
349 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
350 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
351 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
352 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
353 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
354 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
355 - (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
356 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
357 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
358
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
359 if ((*real_morecore) (- excess) == 0)
19999
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
360 {
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
361 /* 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
362 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
363 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
364 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
365 /* 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
366 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
367 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
368 unlikely to trigger this mode of failure. */
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
369 if (last_heap->end != (*real_morecore) (0))
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
370 abort ();
cc8daec6d363 (relinquish): When returning memory to the system,
Karl Heuer <kwzh@gnu.org>
parents: 18757
diff changeset
371 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
372 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
373 }
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
374
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
375 /* 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
376 above where malloc gets space. */
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
377
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
378 long
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
379 r_alloc_size_in_use ()
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
380 {
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
381 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
382 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
383
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
384 /* 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
385
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
386 /* 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
387 to that block. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
388
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
389 static bloc_ptr
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
390 find_bloc (ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
391 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
392 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
393 register bloc_ptr p = first_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
394
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
395 while (p != NIL_BLOC)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
396 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
397 if (p->variable == ptr && p->data == *ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
398 return p;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
399
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
400 p = p->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
401 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
402
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
403 return p;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
404 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
405
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
406 /* 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
407 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
408 memory for the new block. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
409
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
410 static bloc_ptr
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
411 get_bloc (size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
412 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
413 {
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
414 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
415 register heap_ptr heap;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
416
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
417 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
418 || ! (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
419 {
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
420 if (new_bloc)
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
421 free (new_bloc);
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
422
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
423 return 0;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
424 }
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
425
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
426 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
427
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
428 new_bloc->size = size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
429 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
430 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
431 new_bloc->new_data = 0;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
432
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
433 /* 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
434 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
435 heap->free = break_value;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
436
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
437 /* 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
438 new_bloc->heap = heap;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
439 heap->last_bloc = new_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
440 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
441 heap->first_bloc = new_bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
442
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
443 /* Put this bloc on the doubly-linked list of blocs. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
444 if (first_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
445 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
446 new_bloc->prev = last_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
447 last_bloc->next = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
448 last_bloc = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
449 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
450 else
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
451 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
452 first_bloc = last_bloc = new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
453 new_bloc->prev = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
454 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
455
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
456 return new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
457 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
458
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
459 /* 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
460 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
461 not presently available in our reserve, call obtain for
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
462 more space.
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
463
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
464 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
465 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
466
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
467 static int
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
468 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
469 bloc_ptr bloc;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
470 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
471 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
472 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
473 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
474
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
475 /* No need to ever call this if arena is frozen, bug somewhere! */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
476 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
477 abort();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
478
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
479 while (b)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
480 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
481 /* 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
482 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
483 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
484 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
485 heap = heap->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
486 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
487 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
488 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
489 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
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 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
492 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
493 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
494 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
495 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
496 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
497
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
498 /* 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
499 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
500 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
501 if (tb->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
502 s += tb->size;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
503
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
504 tb = tb->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
505 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
506
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
507 /* Get that space. */
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
508 address = obtain (address, s);
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
509 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
510 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
511
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
512 heap = last_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
513 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
514
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
515 /* 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
516 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
517 b->new_data = address;
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
518 if (b->variable)
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
519 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
520 b = b->next;
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
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
523 return 1;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
524 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
525
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
526 /* 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
527 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
528 before that of BEFORE. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
529
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
530 static void
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
531 reorder_bloc (bloc, before)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
532 bloc_ptr bloc, before;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
533 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
534 bloc_ptr prev, next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
535
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
536 /* 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
537 prev = bloc->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
538 next = bloc->next;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
539
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
540 if (prev)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
541 prev->next = next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
542 if (next)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
543 next->prev = prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
544
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
545 /* Splice it in before BEFORE. */
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
546 prev = before->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
547
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
548 if (prev)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
549 prev->next = bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
550 bloc->prev = prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
551
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
552 before->prev = bloc;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
553 bloc->next = before;
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
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
556 /* 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
557 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
558
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
559 static void
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
560 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
561 bloc_ptr bloc;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
562 heap_ptr heap;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
563 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
564 register bloc_ptr b;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
565
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
566 /* 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
567 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
568 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
569 /* 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
570 heap->last_bloc = bloc->prev;
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
571 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
572 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
573 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
574 {
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
575 /* 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
576 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
577 heap->last_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
578 heap->free = heap->bloc_start;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
579 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
580
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
581 /* 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
582 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
583 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
584 /* 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
585 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
586 while (heap)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
587 {
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
588 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
589 break;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
590 heap = heap->next;
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
591 /* 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
592 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
593 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
594 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
595 heap->free = heap->bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
596 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
597
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
598 /* 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
599 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
600 heap->last_bloc = b;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
601 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
602 heap->first_bloc = b;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
603
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
604 /* 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
605 b->heap = heap;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
606 }
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
607
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
608 /* 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
609 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
610 heap = heap->next;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
611 while (heap)
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
612 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
613 heap->first_bloc = NIL_BLOC;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
614 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
615 heap->free = heap->bloc_start;
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
616 heap = heap->next;
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 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
619
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
620 /* 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
621 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
622
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
623 static int
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
624 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
625 bloc_ptr bloc;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
626 SIZE size;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
627 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
628 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
629 heap_ptr heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
630 POINTER address;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
631 SIZE old_size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
632
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
633 /* No need to ever call this if arena is frozen, bug somewhere! */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
634 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
635 abort();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
636
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
637 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
638 return 1;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
639
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
640 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
641 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
642 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
643 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
644 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
645
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
646 if (heap == NIL_HEAP)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
647 abort ();
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
648
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
649 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
650 bloc->size = size;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
651
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
652 /* 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
653 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
654 : (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
655 while (heap)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
656 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
657 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
658 break;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
659 heap = heap->prev;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
660 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
661
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
662 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
663 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
664 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
665 return 0;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
666 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
667
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
668 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
669 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
670 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
671 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
672 if (!b->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
673 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
674 b->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
675 b->data = b->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
676 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
677 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
678 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
679 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
680 *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
681 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
682 }
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
683 if (!bloc->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
684 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
685 bloc->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
686 bloc->data = bloc->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
687 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
688 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
689 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
690 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
691 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
692 *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
693 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
694 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
695 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
696 {
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
697 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
698 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
699 if (!b->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
700 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
701 b->size = 0;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
702 b->data = b->new_data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
703 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
704 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
705 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
706 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
707 *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
708 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
709 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
710 }
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
711
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
712 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
713
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
714 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
715 : (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
716 return 1;
1595
ac1be1d32868 * ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents: 1473
diff changeset
717 }
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
718
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
719 /* 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
720 This may return space to the system. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
721
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
722 static void
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
723 free_bloc (bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
724 bloc_ptr bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
725 {
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
726 heap_ptr heap = bloc->heap;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
727
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
728 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
729 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
730 bloc->variable = (POINTER *) NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
731 return;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
732 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
733
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
734 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
735
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
736 if (bloc == first_bloc && bloc == last_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
737 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
738 first_bloc = last_bloc = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
739 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
740 else if (bloc == last_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
741 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
742 last_bloc = bloc->prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
743 last_bloc->next = NIL_BLOC;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
744 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
745 else if (bloc == first_bloc)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
746 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
747 first_bloc = bloc->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
748 first_bloc->prev = 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
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
751 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
752 bloc->next->prev = bloc->prev;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
753 bloc->prev->next = bloc->next;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
754 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
755
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
756 /* 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
757 if (heap->first_bloc == bloc)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
758 {
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
759 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
760 heap->first_bloc = bloc->next;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
761 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
762 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
763 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
764 if (heap->last_bloc == bloc)
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
765 {
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
766 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
767 heap->last_bloc = bloc->prev;
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
768 else
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
769 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
770 }
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
771
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
772 relinquish ();
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
773 free (bloc);
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
774 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
775
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
776 /* Interface routines. */
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
777
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
778 /* 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
779 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
780 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
781 hook.
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
782
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
783 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
784
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
785 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
786 __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
787 GNU malloc package. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
788
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
789 POINTER
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
790 r_alloc_sbrk (size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
791 long size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
792 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
793 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
794 POINTER address;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
795
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
796 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
797 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
798
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
799 if (! use_relocatable_buffers)
1401
9689db083f88 (sbrk): Removed decl.
Roland McGrath <roland@gnu.org>
parents: 1398
diff changeset
800 return (*real_morecore) (size);
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
801
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
802 if (size == 0)
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
803 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
804
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
805 if (size > 0)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
806 {
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
807 /* 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
808 extra space if we passed an unaligned one. But we could
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
809 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
810 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
811 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
812 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
813
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
814 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
815
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
816 /* 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
817 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
818 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
819 h = h->next;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
820 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
821 break;
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
822 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
823 }
1473
6359d8850fa3 (relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents: 1451
diff changeset
824
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
825 /* 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
826 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
827 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
828 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
829
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
830 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
831 return 0;
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
832
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
833 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
834 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
835 else
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
836 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
837 h = last_heap;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
838 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
839
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
840 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
841
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
842 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
843 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
844 /* This is no clean solution - no idea how to do it better. */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
845 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
846 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
847
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
848 /* 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
849 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
850 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
851
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
852 /* Move all blocs upward. */
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
853 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
854 return 0;
577
53f29271d1b0 *** empty log message ***
Jim Blandy <jimb@redhat.com>
parents: 485
diff changeset
855
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
856 /* 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
857 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
858 header. */
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
859 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
860 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
861 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
862 *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
863 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
864
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
865 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
866
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
867 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
868 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
869 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
870 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
871 /* 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
872 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
873 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
874 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
875 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
876 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
877 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
878 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
879 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
880 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
881
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
882 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
883 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
884 else
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
885 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
886 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
887
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
888 bzero (address, size);
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
889 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
890 else /* size < 0 */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
891 {
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
892 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
893 - ((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
894
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
895 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
896
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
897 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
898 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
899 excess -= extra_bytes;
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
900 first_heap->bloc_start
9666
d50850d0c8f8 (struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents: 9596
diff changeset
901 = (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
902
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
903 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
904
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
905 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
906 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
907 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
908 *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
909 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
910 }
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
911
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
912 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
913 {
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
914 /* 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
915 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
916 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
917 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
918
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
919 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
920 break_value = (last_bloc
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
921 ? (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
922 : (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
923 if (size < 0)
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
924 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
925
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
926 return address;
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
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
929
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
930 /* Allocate a relocatable bloc of storage of size SIZE. A pointer to
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
931 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
932 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
933
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
934 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
935 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
936 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
937
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
938 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
939 return zero. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
940
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
941 POINTER
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
942 r_alloc (ptr, size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
943 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
944 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
945 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
946 register bloc_ptr new_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
947
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
948 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
949 r_alloc_init ();
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
950
9596
134f7085c56b (heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents: 9459
diff changeset
951 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
952 if (new_bloc)
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
953 {
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
954 new_bloc->variable = ptr;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
955 *ptr = new_bloc->data;
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
956 }
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
957 else
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
958 *ptr = 0;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
959
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
960 return *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
961 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
962
1390
92df75f4167f (check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents: 1249
diff changeset
963 /* 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
964 Store 0 in *PTR to show there's no block allocated. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
965
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
966 void
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
967 r_alloc_free (ptr)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
968 register POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
969 {
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
970 register bloc_ptr dead_bloc;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
971
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
972 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
973 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
974
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
975 dead_bloc = find_bloc (ptr);
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
976 if (dead_bloc == NIL_BLOC)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
977 abort ();
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
978
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
979 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
980 *ptr = 0;
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
981
10747
c6a68e4ee53a (r_alloc_free): Call refill_memory_reserve only if emacs.
Richard M. Stallman <rms@gnu.org>
parents: 10682
diff changeset
982 #ifdef emacs
10682
5659c0885145 (r_alloc_size_in_use): New function.
Richard M. Stallman <rms@gnu.org>
parents: 10432
diff changeset
983 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
984 #endif
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
985 }
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
986
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
987 /* 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
988 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
989 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
990 do nothing.
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
991
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
992 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
993 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
994 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
995
1249
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
996 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
997
761b9b4fd3ed * ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents: 1121
diff changeset
998 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
999 return zero. */
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1000
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1001 POINTER
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1002 r_re_alloc (ptr, size)
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1003 POINTER *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1004 SIZE size;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1005 {
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
1006 register bloc_ptr bloc;
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1007
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1008 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1009 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1010
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1011 if (!*ptr)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1012 return r_alloc (ptr, size);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1013 if (!size)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1014 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1015 r_alloc_free (ptr);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1016 return r_alloc (ptr, 0);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1017 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1018
1087
6c410cc87574 * ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents: 1013
diff changeset
1019 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
1020 if (bloc == NIL_BLOC)
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1021 abort ();
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1022
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1023 if (size < bloc->size)
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 /* 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
1026 /* I think so too, but not if it's too expensive... */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1027 if ((bloc->size - MEM_ROUNDUP (size) >= page_size)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1028 && r_alloc_freeze_level == 0)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1029 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1030 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
1031 /* 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
1032 /* It *should* be infallible! */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1033 }
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 else if (size > bloc->size)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1036 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1037 if (r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1038 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1039 bloc_ptr new_bloc;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1040 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
1041 if (new_bloc)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1042 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1043 new_bloc->variable = ptr;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1044 *ptr = new_bloc->data;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1045 bloc->variable = (POINTER *) NIL;
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 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1048 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1049 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1050 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1051 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1052 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
1053 return NIL;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1054 }
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1055 }
118
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1056 return *ptr;
49342840ba00 Initial revision
Jim Blandy <jimb@redhat.com>
parents:
diff changeset
1057 }
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1058
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1059 /* 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
1060 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
1061 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
1062 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
1063
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1064 void
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1065 r_alloc_freeze (size)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1066 long size;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1067 {
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1068 if (! r_alloc_initialized)
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1069 r_alloc_init ();
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1070
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1071 /* 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
1072 if (r_alloc_freeze_level > 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1073 size = 0;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1074 /* 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
1075 while (size > 0 && r_alloc_sbrk (size) == 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1076 size /= 2;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1077 ++r_alloc_freeze_level;
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1078 if (size > 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1079 r_alloc_sbrk (-size);
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1080 }
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1081
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1082 void
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1083 r_alloc_thaw ()
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1084 {
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1085
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1086 if (! r_alloc_initialized)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1087 r_alloc_init ();
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1088
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1089 if (--r_alloc_freeze_level < 0)
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1090 abort ();
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1091
14036
621a575db6f7 Comment fixes.
Karl Heuer <kwzh@gnu.org>
parents: 11146
diff changeset
1092 /* This frees all unused blocs. It is not too inefficient, as the resize
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1093 and bcopy is done only once. Afterwards, all unreferenced blocs are
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1094 already shrunk to zero size. */
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1095 if (!r_alloc_freeze_level)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1096 {
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1097 bloc_ptr *b = &first_bloc;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1098 while (*b)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1099 if (!(*b)->variable)
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1100 free_bloc (*b);
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1101 else
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1102 b = &(*b)->next;
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1103 }
8951
b628561b185b (r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents: 5063
diff changeset
1104 }
11146
9a14b32f5d71 (r_re_alloc): Correct realloc behavior--allow shrinking
Richard M. Stallman <rms@gnu.org>
parents: 10785
diff changeset
1105
18757
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1106
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1107 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1108
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1109 /* 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
1110 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
1111 void
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1112 r_alloc_reinit ()
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1113 {
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1114 /* 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
1115 infinite loop, in case Emacs was linked statically. */
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1116 if (__morecore != r_alloc_sbrk)
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1117 {
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1118 real_morecore = __morecore;
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1119 __morecore = r_alloc_sbrk;
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1120 }
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1121 }
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1122
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1123 #endif /* emacs && DOUG_LEA_MALLOC */
18757
9d6149f4c762 (r_alloc_reinit): New function.
Richard M. Stallman <rms@gnu.org>
parents: 17845
diff changeset
1124
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1125 #ifdef DEBUG
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1126
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1127 #include <assert.h>
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1128
10767
2954efb1d06c (r_alloc_check): Return void.
Richard M. Stallman <rms@gnu.org>
parents: 10766
diff changeset
1129 void
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1130 r_alloc_check ()
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1131 {
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1132 int found = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1133 heap_ptr h, ph = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1134 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
1135
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1136 if (!r_alloc_initialized)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1137 return;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1138
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1139 assert (first_heap);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1140 assert (last_heap->end <= (POINTER) sbrk (0));
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1141 assert ((POINTER) first_heap < first_heap->start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1142 assert (first_heap->start <= virtual_break_value);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1143 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
1144
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1145 for (h = first_heap; h; h = h->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1146 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1147 assert (h->prev == ph);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1148 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
1149 #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
1150 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
1151 Perhaps it should. */
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1152 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
1153 #endif
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1154 assert ((POINTER) MEM_ROUNDUP (h->bloc_start) == h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1155 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
1156
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1157 if (ph)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1158 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1159 assert (ph->end < h->start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1160 assert (h->start <= (POINTER)h && (POINTER)(h+1) <= h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1161 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1162
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1163 if (h->bloc_start <= break_value && break_value <= h->end)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1164 found = 1;
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1165
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1166 ph = h;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1167 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1168
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1169 assert (found);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1170 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
1171
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1172 for (b = first_bloc; b; b = b->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1173 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1174 assert (b->prev == pb);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1175 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1176 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
1177
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1178 ph = 0;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1179 for (h = first_heap; h; h = h->next)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1180 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1181 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
1182 break;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1183 ph = h;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1184 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1185
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1186 assert (h);
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 if (pb && pb->data + pb->size != b->data)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1189 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1190 assert (ph && b->data == h->bloc_start);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1191 while (ph)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1192 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1193 if (ph->bloc_start <= pb->data
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1194 && pb->data + pb->size <= ph->end)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1195 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1196 assert (pb->data + pb->size + b->size > ph->end);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1197 break;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1198 }
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1199 else
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1200 {
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1201 assert (ph->bloc_start + b->size > ph->end);
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 ph = ph->prev;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1204 }
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 pb = b;
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1207 }
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1208
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1209 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
1210
10766
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1211 if (last_bloc)
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1212 assert (last_bloc->data + last_bloc->size == break_value);
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1213 else
07eea2d610d3 Whitespace fixes.
Richard M. Stallman <rms@gnu.org>
parents: 10747
diff changeset
1214 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
1215 }
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1216
9459
a1569f00a6a6 Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents: 8951
diff changeset
1217 #endif /* DEBUG */
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1218
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1219
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1220
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1221 /***********************************************************************
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1222 Initialization
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1223 ***********************************************************************/
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1224
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1225 /* The hook `malloc' uses for the function which gets more space
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1226 from the system. */
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1227
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1228 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1229 extern POINTER (*__morecore) ();
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1230 #endif
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1231
31513
6e606fa28569 (r_alloc_init_fd): Move. Fix conditional for pcc.
Dave Love <fx@gnu.org>
parents: 31509
diff changeset
1232
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1233 /* Initialize various things for memory allocation. */
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 static void
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1236 r_alloc_init ()
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1237 {
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1238 if (r_alloc_initialized)
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1239 return;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1240 r_alloc_initialized = 1;
31515
92dec3ff92a1 (mmap_fd): Remove initializer which can make it
Gerd Moellmann <gerd@gnu.org>
parents: 31513
diff changeset
1241
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1242 page_size = PAGE;
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1243 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1244 real_morecore = __morecore;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1245 __morecore = r_alloc_sbrk;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1246
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1247 first_heap = last_heap = &heap_base;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1248 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
1249 first_heap->start = first_heap->bloc_start
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1250 = 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
1251 if (break_value == NIL)
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1252 abort ();
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1253
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1254 extra_bytes = ROUNDUP (50000);
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1255 #endif
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1256
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1257 #ifdef DOUG_LEA_MALLOC
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1258 mallopt (M_TOP_PAD, 64 * 4096);
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1259 #else
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1260 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1261 /* Give GNU malloc's morecore some hysteresis
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1262 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
1263 __malloc_extra_blocks = 64;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1264 #endif
31498
17d4a8f3df67 Don't include string.h (redundant).
Dave Love <fx@gnu.org>
parents: 31473
diff changeset
1265 #endif
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1266
31509
6bc82db7d305 (r_alloc_init): Conditionalize on SYSTEM_MALLOC, not REL_ALLOC_MMAP.
Dave Love <fx@gnu.org>
parents: 31504
diff changeset
1267 #ifndef SYSTEM_MALLOC
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1268 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
1269
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1270 /* 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
1271 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
1272 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
1273 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
1274 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
1275 size. */
31473
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
1276 (*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
1277
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1278 /* 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
1279 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
1280 /* 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
1281 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
1282 bzero (first_heap->start,
055accd6bf1d (obtain, relinquish, relinquish, r_alloc_size_in_use)
Gerd Moellmann <gerd@gnu.org>
parents: 31468
diff changeset
1283 (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
1284 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
1285 #endif
31515
92dec3ff92a1 (mmap_fd): Remove initializer which can make it
Gerd Moellmann <gerd@gnu.org>
parents: 31513
diff changeset
1286
31414
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1287 use_relocatable_buffers = 1;
76dcf201d009 (POINTER, SIZE) [emacs]: Define in terms of
Gerd Moellmann <gerd@gnu.org>
parents: 30061
diff changeset
1288 }