annotate src/ralloc.c @ 31118:37c389d61cee

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