Mercurial > emacs
annotate src/ralloc.c @ 10029:fdc1155b891c
(sort_args): New function.
(main): Call sort_args.
Check for -d/-display after -nw, -batch, -help.
Accept --display, with arg attached or separate.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Sat, 19 Nov 1994 20:45:17 +0000 |
parents | d50850d0c8f8 |
children | 15d01ad97928 |
rev | line source |
---|---|
118 | 1 /* Block-relocating memory allocator. |
2961 | 2 Copyright (C) 1993 Free Software Foundation, Inc. |
118 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
8 the Free Software Foundation; either version 1, or (at your option) | |
9 any later version. | |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 /* NOTES: | |
21 | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3136
diff
changeset
|
22 Only relocate the blocs necessary for SIZE in r_alloc_sbrk, |
118 | 23 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
|
24 hole between the first bloc and the end of malloc storage. */ |
118 | 25 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
26 #ifdef emacs |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
27 |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
4230
diff
changeset
|
28 #include <config.h> |
577 | 29 #include "lisp.h" /* Needed for VALBITS. */ |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
30 |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
31 #undef NULL |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
32 |
1451
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
33 /* 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
|
34 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
|
35 to has a size of 1. */ |
3109
cd1bbe721cb5
(POINTER): Always use char *.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
36 #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
|
37 #ifdef __STDC__ |
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
38 typedef void *POINTER; |
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
39 #else |
1729
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
40 |
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
41 #ifdef HAVE_CONFIG_H |
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
42 #include "config.h" |
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
43 #endif |
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
44 |
1451
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
45 typedef char *POINTER; |
1729
5c3898c5aa2d
[! emacs] [HAVE_CONFIG_H]: #include "config.h"
Roland McGrath <roland@gnu.org>
parents:
1595
diff
changeset
|
46 |
1451
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
47 #endif |
3109
cd1bbe721cb5
(POINTER): Always use char *.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
48 #endif /* 0 */ |
cd1bbe721cb5
(POINTER): Always use char *.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
49 |
cd1bbe721cb5
(POINTER): Always use char *.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
50 /* Unconditionally use char * for this. */ |
cd1bbe721cb5
(POINTER): Always use char *.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
51 typedef char *POINTER; |
1451
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
52 |
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
53 typedef unsigned long SIZE; |
107c9b227e7f
[emacs]: Define POINTER and SIZE.
Richard M. Stallman <rms@gnu.org>
parents:
1403
diff
changeset
|
54 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
55 /* 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
|
56 overlap. */ |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
57 extern void safe_bcopy (); |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
58 |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
59 #include "getpagesize.h" |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
60 |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
61 #else /* Not emacs. */ |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
62 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
63 #include <stddef.h> |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
64 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
65 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
|
66 typedef void *POINTER; |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
67 |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
68 #include <unistd.h> |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
69 #include <malloc.h> |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
70 #include <string.h> |
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
71 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
72 #define safe_bcopy(x, y, z) memmove (y, x, z) |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
73 |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
74 #endif /* emacs. */ |
118 | 75 |
76 #define NIL ((POINTER) 0) | |
77 | |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
78 /* 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
|
79 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
|
80 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
|
81 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
|
82 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
|
83 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
|
84 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
|
85 |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
86 static void r_alloc_init (); |
118 | 87 |
577 | 88 /* Declarations for working with the malloc, ralloc, and system breaks. */ |
89 | |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
90 /* Function to set the real break value. */ |
1401 | 91 static POINTER (*real_morecore) (); |
118 | 92 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
93 /* The break value, as seen by malloc. */ |
118 | 94 static POINTER virtual_break_value; |
95 | |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
96 /* The address of the end of the last data in use by ralloc, |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
97 including relocatable blocs as well as malloc data. */ |
118 | 98 static POINTER break_value; |
99 | |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
100 /* This is the size of a page. We round memory requests to this boundary. */ |
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
101 static int page_size; |
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
102 |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
103 /* 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
|
104 must be a multiple of page_size. */ |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
105 static int extra_bytes; |
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
106 |
118 | 107 /* Macros for rounding. Note that rounding to any value is possible |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
108 by changing the definition of PAGE. */ |
118 | 109 #define PAGE (getpagesize ()) |
4230
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents:
3591
diff
changeset
|
110 #define ALIGNED(addr) (((unsigned long int) (addr) & (page_size - 1)) == 0) |
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents:
3591
diff
changeset
|
111 #define ROUNDUP(size) (((unsigned long int) (size) + page_size - 1) \ |
df4d091e603e
(ALIGNED, ROUNDUP): Use `unsigned long int' instead of `unsigned int' for
Roland McGrath <roland@gnu.org>
parents:
3591
diff
changeset
|
112 & ~(page_size - 1)) |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
113 #define ROUND_TO_PAGE(addr) (addr & (~(page_size - 1))) |
118 | 114 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
115 #define MEM_ALIGN sizeof(double) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
116 #define MEM_ROUNDUP(addr) (((unsigned long int)(addr) + MEM_ALIGN - 1) \ |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
117 & ~(MEM_ALIGN - 1)) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
118 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
119 /* 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
|
120 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
121 /* 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
|
122 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
|
123 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
|
124 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
|
125 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
126 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
|
127 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
|
128 but they never move. |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
129 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
130 We try to make just one heap and make it larger as necessary. |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
131 But sometimes we can't do that, because we can't get continguous |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
132 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
|
133 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
134 typedef struct heap |
118 | 135 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
136 struct heap *next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
137 struct heap *prev; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
138 /* 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
|
139 POINTER start; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
140 /* 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
|
141 POINTER end; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
142 /* 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
|
143 POINTER bloc_start; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
144 /* 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
|
145 POINTER free; |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
146 /* First bloc in this heap. */ |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
147 struct bp *first_bloc; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
148 /* Last bloc in this heap. */ |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
149 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
|
150 } *heap_ptr; |
118 | 151 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
152 #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
|
153 #define HEAP_PTR_SIZE (sizeof (struct heap)) |
118 | 154 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
155 /* 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
|
156 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
|
157 the space it covers. */ |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
158 static struct heap heap_base; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
159 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
160 /* 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
|
161 static heap_ptr first_heap, last_heap; |
577 | 162 |
163 /* These structures are allocated in the malloc arena. | |
164 The linked list is kept in order of increasing '.data' members. | |
165 The data blocks abut each other; if b->next is non-nil, then | |
166 b->data + b->size == b->next->data. */ | |
118 | 167 typedef struct bp |
168 { | |
169 struct bp *next; | |
170 struct bp *prev; | |
171 POINTER *variable; | |
172 POINTER data; | |
173 SIZE size; | |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
174 POINTER new_data; /* tmporarily used for relocation */ |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
175 /* Heap this bloc is in. */ |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
176 struct heap *heap; |
118 | 177 } *bloc_ptr; |
178 | |
179 #define NIL_BLOC ((bloc_ptr) 0) | |
180 #define BLOC_PTR_SIZE (sizeof (struct bp)) | |
181 | |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
182 /* Head and tail of the list of relocatable blocs. */ |
118 | 183 static bloc_ptr first_bloc, last_bloc; |
184 | |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
185 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
186 /* 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
|
187 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
188 /* 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
|
189 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
190 static heap_ptr |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
191 find_heap (address) |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
192 POINTER address; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
193 { |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
194 heap_ptr heap; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
195 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
196 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
|
197 { |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
198 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
|
199 return heap; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
200 } |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
201 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
202 return NIL_HEAP; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
203 } |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
204 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
205 /* 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
|
206 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
|
207 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
|
208 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
209 If enough space is not presently available in our reserve, this means |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
210 getting more page-aligned space from the system. If the retuned space |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
211 is not contiguos 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
|
212 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
213 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
|
214 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
|
215 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
|
216 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
|
217 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
|
218 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
|
219 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
220 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
|
221 allocate the memory. */ |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
222 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
223 static POINTER |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
224 obtain (address, size) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
225 POINTER address; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
226 SIZE size; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
227 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
228 heap_ptr heap; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
229 SIZE already_available; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
230 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
231 /* 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
|
232 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
|
233 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
234 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
|
235 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
236 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
237 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
238 if (! heap) |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
239 abort (); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
240 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
241 /* 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
|
242 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
|
243 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
|
244 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
245 heap = heap->next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
246 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
|
247 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
248 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
|
249 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
250 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
251 /* 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
|
252 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
|
253 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
|
254 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
255 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
|
256 SIZE get; |
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 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
|
259 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
260 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
|
261 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
262 /* 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
|
263 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
264 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
|
265 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
|
266 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
267 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
|
268 return 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
269 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
270 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
|
271 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
|
272 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
|
273 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
|
274 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
|
275 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
|
276 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
|
277 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
|
278 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
|
279 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
|
280 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
281 address = bloc_start; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
282 already_available = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
283 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
284 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
285 /* 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
|
286 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
|
287 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
288 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
|
289 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
|
290 - (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
|
291 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
292 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
|
293 return 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
294 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
295 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
|
296 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
297 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
298 return address; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
299 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
300 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
301 /* 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
|
302 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
|
303 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
|
304 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
|
305 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
306 static void |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
307 relinquish () |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
308 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
309 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
|
310 int excess = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
311 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
312 /* 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
|
313 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
|
314 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
315 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
|
316 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
317 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
|
318 ? 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
|
319 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
320 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
321 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
|
322 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
323 /* 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
|
324 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
|
325 excess -= extra_bytes; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
326 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
327 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
|
328 { |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
329 /* 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
|
330 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
|
331 || 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
|
332 abort (); |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
333 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
334 /* 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
|
335 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
|
336 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
|
337 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
|
338 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
339 else |
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 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
|
342 - (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
|
343 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
|
344 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
345 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
346 if ((*real_morecore) (- excess) == 0) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
347 abort (); |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
348 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
349 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
350 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
351 /* 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
|
352 |
577 | 353 /* 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
|
354 to that block. */ |
118 | 355 |
356 static bloc_ptr | |
357 find_bloc (ptr) | |
358 POINTER *ptr; | |
359 { | |
360 register bloc_ptr p = first_bloc; | |
361 | |
362 while (p != NIL_BLOC) | |
363 { | |
364 if (p->variable == ptr && p->data == *ptr) | |
365 return p; | |
366 | |
367 p = p->next; | |
368 } | |
369 | |
370 return p; | |
371 } | |
372 | |
373 /* 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
|
374 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
|
375 memory for the new block. */ |
118 | 376 |
377 static bloc_ptr | |
378 get_bloc (size) | |
379 SIZE size; | |
380 { | |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
381 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
|
382 register heap_ptr heap; |
118 | 383 |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
384 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
|
385 || ! (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
|
386 { |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
387 if (new_bloc) |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
388 free (new_bloc); |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
389 |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
390 return 0; |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
391 } |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
392 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
393 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
|
394 |
118 | 395 new_bloc->size = size; |
396 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
|
397 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
|
398 new_bloc->new_data = 0; |
118 | 399 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
400 /* 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
|
401 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
|
402 heap->free = break_value; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
403 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
404 /* 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
|
405 new_bloc->heap = heap; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
406 heap->last_bloc = new_bloc; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
407 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
|
408 heap->first_bloc = new_bloc; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
409 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
410 /* Put this bloc on the doubly-linked list of blocs. */ |
118 | 411 if (first_bloc) |
412 { | |
413 new_bloc->prev = last_bloc; | |
414 last_bloc->next = new_bloc; | |
415 last_bloc = new_bloc; | |
416 } | |
417 else | |
418 { | |
419 first_bloc = last_bloc = new_bloc; | |
420 new_bloc->prev = NIL_BLOC; | |
421 } | |
422 | |
423 return new_bloc; | |
424 } | |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
425 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
426 /* 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
|
427 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
|
428 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
|
429 more space. |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
430 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
431 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
|
432 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
|
433 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
434 static int |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
435 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
|
436 bloc_ptr bloc; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
437 heap_ptr heap; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
438 POINTER address; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
439 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
440 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
|
441 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
442 while (b) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
443 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
444 /* 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
|
445 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
|
446 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
|
447 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
448 heap = heap->next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
449 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
|
450 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
451 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
|
452 } |
118 | 453 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
454 /* 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
|
455 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
|
456 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
|
457 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
458 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
|
459 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
|
460 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
461 /* 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
|
462 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
|
463 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
464 s += tb->size; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
465 tb = tb->next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
466 } |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
467 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
468 /* Get that space. */ |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
469 address = obtain (address, s); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
470 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
|
471 return 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
472 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
473 heap = last_heap; |
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 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
476 /* 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
|
477 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
|
478 b->new_data = address; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
479 address += b->size; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
480 b = b->next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
481 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
482 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
483 return 1; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
484 } |
118 | 485 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
486 /* 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
|
487 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
|
488 before that of BEFORE. */ |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
489 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
490 static void |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
491 reorder_bloc (bloc, before) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
492 bloc_ptr bloc, before; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
493 { |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
494 bloc_ptr prev, next; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
495 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
496 /* 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
|
497 prev = bloc->prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
498 next = bloc->next; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
499 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
500 if (prev) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
501 prev->next = next; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
502 if (next) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
503 next->prev = prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
504 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
505 /* Splice it in before BEFORE. */ |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
506 prev = before->prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
507 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
508 if (prev) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
509 prev->next = bloc; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
510 bloc->prev = prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
511 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
512 before->prev = bloc; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
513 bloc->next = before; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
514 } |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
515 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
516 /* 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
|
517 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
|
518 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
519 static void |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
520 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
|
521 bloc_ptr bloc; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
522 heap_ptr heap; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
523 { |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
524 register bloc_ptr b; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
525 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
526 /* 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
|
527 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
|
528 { |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
529 /* 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
|
530 heap->last_bloc = bloc->prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
531 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
|
532 } |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
533 else |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
534 { |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
535 /* 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
|
536 heap->first_bloc = NIL_BLOC; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
537 heap->last_bloc = NIL_BLOC; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
538 heap->free = heap->bloc_start; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
539 } |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
540 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
541 /* 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
|
542 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
|
543 { |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
544 /* 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
|
545 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
|
546 while (heap) |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
547 { |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
548 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
|
549 break; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
550 heap = heap->next; |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
551 /* 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
|
552 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
|
553 heap->first_bloc = NIL_BLOC; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
554 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
|
555 heap->free = heap->bloc_start; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
556 } |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
557 |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
558 /* 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
|
559 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
|
560 heap->last_bloc = b; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
561 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
|
562 heap->first_bloc = b; |
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 /* 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
|
565 b->heap = heap; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
566 } |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
567 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
568 /* 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
|
569 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
|
570 heap = heap->next; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
571 while (heap) |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
572 { |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
573 heap->first_bloc = NIL_BLOC; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
574 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
|
575 heap->free = heap->bloc_start; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
576 heap = heap->next; |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
577 } |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
578 } |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
579 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
580 /* 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
|
581 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
|
582 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
583 static int |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
584 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
|
585 bloc_ptr bloc; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
586 SIZE size; |
118 | 587 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
588 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
|
589 heap_ptr heap; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
590 POINTER address; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
591 SIZE old_size; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
592 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
593 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
|
594 return 1; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
595 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
596 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
|
597 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
598 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
|
599 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
600 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
601 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
602 if (heap == NIL_HEAP) |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
603 abort (); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
604 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
605 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
|
606 bloc->size = size; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
607 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
608 /* 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
|
609 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
|
610 : 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
|
611 while (heap) |
118 | 612 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
613 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
|
614 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
615 heap = heap->prev; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
616 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
617 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
618 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
|
619 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
620 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
|
621 return 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
622 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
623 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
624 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
|
625 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
626 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
|
627 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
628 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
|
629 *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
|
630 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
631 safe_bcopy (bloc->data, bloc->new_data, old_size); |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
632 bzero (bloc->new_data + old_size, size - old_size); |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
633 *bloc->variable = bloc->data = bloc->new_data; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
634 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
635 else |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
636 { |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
637 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
|
638 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
639 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
|
640 *b->variable = b->data = b->new_data; |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
641 } |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
642 } |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
643 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
644 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
|
645 |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
646 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
|
647 : 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
|
648 return 1; |
1595
ac1be1d32868
* ralloc.c (relocate_some_blocs): Handle BLOC == NIL_BLOC.
Jim Blandy <jimb@redhat.com>
parents:
1473
diff
changeset
|
649 } |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
650 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
651 /* 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
|
652 This may return space to the system. */ |
118 | 653 |
654 static void | |
655 free_bloc (bloc) | |
656 bloc_ptr bloc; | |
657 { | |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
658 heap_ptr heap = bloc->heap; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
659 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
660 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
|
661 |
118 | 662 if (bloc == first_bloc && bloc == last_bloc) |
663 { | |
664 first_bloc = last_bloc = NIL_BLOC; | |
665 } | |
666 else if (bloc == last_bloc) | |
667 { | |
668 last_bloc = bloc->prev; | |
669 last_bloc->next = NIL_BLOC; | |
670 } | |
671 else if (bloc == first_bloc) | |
672 { | |
673 first_bloc = bloc->next; | |
674 first_bloc->prev = NIL_BLOC; | |
675 } | |
676 else | |
677 { | |
678 bloc->next->prev = bloc->prev; | |
679 bloc->prev->next = bloc->next; | |
680 } | |
681 | |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
682 /* 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
|
683 if (heap->first_bloc == bloc) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
684 { |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
685 if (bloc->next->heap == heap) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
686 heap->first_bloc = bloc->next; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
687 else |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
688 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
|
689 } |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
690 if (heap->last_bloc == bloc) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
691 { |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
692 if (bloc->prev->heap == heap) |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
693 heap->last_bloc = bloc->prev; |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
694 else |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
695 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
|
696 } |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
697 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
698 relinquish (); |
118 | 699 free (bloc); |
700 } | |
701 | |
577 | 702 /* Interface routines. */ |
703 | |
118 | 704 static int use_relocatable_buffers; |
8951
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
705 static int r_alloc_freeze_level; |
118 | 706 |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
707 /* 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
|
708 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
|
709 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
|
710 hook. |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
711 |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
712 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
|
713 |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
714 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
|
715 __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
|
716 GNU malloc package. */ |
118 | 717 |
718 POINTER | |
719 r_alloc_sbrk (size) | |
720 long size; | |
721 { | |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
722 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
|
723 POINTER address; |
118 | 724 |
725 if (! use_relocatable_buffers) | |
1401 | 726 return (*real_morecore) (size); |
118 | 727 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
728 if (size == 0) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
729 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
|
730 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
731 if (size > 0) |
118 | 732 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
733 /* 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
|
734 extra space if we passed an unaligned one. But we could |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
735 not always find a space which is contiguos 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
|
736 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
|
737 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
|
738 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
|
739 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
740 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
|
741 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
742 /* 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
|
743 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
|
744 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
745 h = h->next; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
746 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
|
747 break; |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
748 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
|
749 } |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
750 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
751 /* 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
|
752 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
|
753 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
754 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
|
755 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
756 if (r_alloc_freeze_level > 0 || ! 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
|
757 return 0; |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
758 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
759 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
|
760 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
|
761 else |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
762 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
|
763 h = last_heap; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
764 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
765 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
766 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
|
767 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
768 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
|
769 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
770 /* Move all blocs upward. */ |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
771 if (r_alloc_freeze_level > 0 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
772 || ! relocate_blocs (first_bloc, h, new_bloc_start)) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
773 return 0; |
577 | 774 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
775 /* 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
|
776 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
|
777 header. */ |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
778 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
|
779 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
780 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
|
781 *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
|
782 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
783 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
784 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
|
785 |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
786 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
|
787 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
788 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
789 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
|
790 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
791 /* 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
|
792 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
|
793 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
|
794 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
|
795 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
|
796 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
|
797 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
|
798 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
|
799 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
|
800 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
|
801 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
802 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
|
803 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
|
804 else |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
805 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
|
806 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
807 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
808 bzero (address, size); |
118 | 809 } |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
810 else /* size < 0 */ |
118 | 811 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
812 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
|
813 - ((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
|
814 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
815 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
|
816 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
817 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
|
818 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
819 excess -= extra_bytes; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
820 first_heap->bloc_start |
9666
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
821 = (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
|
822 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
823 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
|
824 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
825 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
|
826 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
827 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
|
828 *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
|
829 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
830 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
831 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
832 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
|
833 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
834 /* 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
|
835 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
|
836 } |
118 | 837 } |
838 | |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
839 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
|
840 break_value = (last_bloc |
d50850d0c8f8
(struct heap): New fields first_bloc, last_bloc.
Richard M. Stallman <rms@gnu.org>
parents:
9596
diff
changeset
|
841 ? 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
|
842 : 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
|
843 if (size < 0) |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
844 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
|
845 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
846 return address; |
118 | 847 } |
848 | |
849 /* Allocate a relocatable bloc of storage of size SIZE. A pointer to | |
850 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
|
851 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
|
852 |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
853 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
|
854 return zero. */ |
118 | 855 |
856 POINTER | |
857 r_alloc (ptr, size) | |
858 POINTER *ptr; | |
859 SIZE size; | |
860 { | |
861 register bloc_ptr new_bloc; | |
862 | |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
863 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
|
864 r_alloc_init (); |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
865 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
866 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
|
867 if (new_bloc) |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
868 { |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
869 new_bloc->variable = ptr; |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
870 *ptr = new_bloc->data; |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
871 } |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
872 else |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
873 *ptr = 0; |
118 | 874 |
875 return *ptr; | |
876 } | |
877 | |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
878 /* 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
|
879 Store 0 in *PTR to show there's no block allocated. */ |
118 | 880 |
881 void | |
882 r_alloc_free (ptr) | |
883 register POINTER *ptr; | |
884 { | |
885 register bloc_ptr dead_bloc; | |
886 | |
887 dead_bloc = find_bloc (ptr); | |
888 if (dead_bloc == NIL_BLOC) | |
889 abort (); | |
890 | |
891 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
|
892 *ptr = 0; |
118 | 893 } |
894 | |
1087
6c410cc87574
* ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents:
1013
diff
changeset
|
895 /* 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
|
896 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
|
897 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
|
898 do nothing. |
118 | 899 |
1249
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
900 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
|
901 |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
902 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
|
903 return zero. */ |
118 | 904 |
905 POINTER | |
906 r_re_alloc (ptr, size) | |
907 POINTER *ptr; | |
908 SIZE size; | |
909 { | |
1087
6c410cc87574
* ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents:
1013
diff
changeset
|
910 register bloc_ptr bloc; |
118 | 911 |
1087
6c410cc87574
* ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents:
1013
diff
changeset
|
912 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
|
913 if (bloc == NIL_BLOC) |
118 | 914 abort (); |
915 | |
1087
6c410cc87574
* ralloc.c (r_re_alloc): Instead of allocating a new bloc at the
Jim Blandy <jimb@redhat.com>
parents:
1013
diff
changeset
|
916 if (size <= bloc->size) |
577 | 917 /* Wouldn't it be useful to actually resize the bloc here? */ |
118 | 918 return *ptr; |
919 | |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
920 if (! resize_bloc (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
|
921 return 0; |
761b9b4fd3ed
* ralloc.c: Since the users of the relocating allocation code
Jim Blandy <jimb@redhat.com>
parents:
1121
diff
changeset
|
922 |
118 | 923 return *ptr; |
924 } | |
8951
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
925 |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
926 /* 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
|
927 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
|
928 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
|
929 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
|
930 |
8951
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
931 void |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
932 r_alloc_freeze (size) |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
933 long size; |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
934 { |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
935 /* 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
|
936 if (r_alloc_freeze_level > 0) |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
937 size = 0; |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
938 /* 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
|
939 while (size > 0 && r_alloc_sbrk (size) == 0) |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
940 size /= 2; |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
941 ++r_alloc_freeze_level; |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
942 if (size > 0) |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
943 r_alloc_sbrk (-size); |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
944 } |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
945 |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
946 void |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
947 r_alloc_thaw () |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
948 { |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
949 if (--r_alloc_freeze_level < 0) |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
950 abort (); |
b628561b185b
(r_alloc_freeze_level): New variable.
Karl Heuer <kwzh@gnu.org>
parents:
5063
diff
changeset
|
951 } |
118 | 952 |
953 /* The hook `malloc' uses for the function which gets more space | |
954 from the system. */ | |
955 extern POINTER (*__morecore) (); | |
956 | |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
957 /* Initialize various things for memory allocation. */ |
118 | 958 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
959 static void |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
960 r_alloc_init () |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
961 { |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
962 POINTER end; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
963 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
964 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
|
965 return; |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
966 |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
967 r_alloc_initialized = 1; |
1401 | 968 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
|
969 __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
|
970 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
971 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
|
972 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
|
973 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
|
974 = virtual_break_value = break_value = (*real_morecore) (0); |
1403
f0ea279194f8
Removed #include "mem-limits.h".
Roland McGrath <roland@gnu.org>
parents:
1401
diff
changeset
|
975 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
|
976 abort (); |
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
977 |
1473
6359d8850fa3
(relinquish): Adjust page_break_value by amount of memory actually given back.
Richard M. Stallman <rms@gnu.org>
parents:
1451
diff
changeset
|
978 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
|
979 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
|
980 |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
981 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
|
982 |
9ab921a16318
(r_alloc_init): Explicitly use real_morecore
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
983 /* 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
|
984 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
|
985 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
|
986 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
|
987 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
|
988 size. */ |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
989 (*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
|
990 |
1390
92df75f4167f
(check_memory_limits): Reduce warnlevel when usage drops far enough.
Richard M. Stallman <rms@gnu.org>
parents:
1249
diff
changeset
|
991 /* 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
|
992 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
|
993 /* 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
|
994 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
|
995 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
|
996 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
|
997 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
|
998 } |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
999 #ifdef DEBUG |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1000 #include <assert.h> |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1001 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1002 int |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1003 r_alloc_check () |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1004 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1005 int found = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1006 heap_ptr h, ph = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1007 bloc_ptr b, pb = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1008 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1009 if (!r_alloc_initialized) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1010 return; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1011 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1012 assert (first_heap); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1013 assert (last_heap->end <= (POINTER) sbrk (0)); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1014 assert ((POINTER) first_heap < first_heap->start); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1015 assert (first_heap->start <= virtual_break_value); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1016 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
|
1017 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1018 for (h = first_heap; h; h = h->next) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1019 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1020 assert (h->prev == ph); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1021 assert ((POINTER) ROUNDUP (h->end) == h->end); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1022 assert ((POINTER) MEM_ROUNDUP (h->start) == h->start); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1023 assert ((POINTER) MEM_ROUNDUP (h->bloc_start) == h->bloc_start); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1024 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
|
1025 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1026 if (ph) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1027 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1028 assert (ph->end < h->start); |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1029 assert (h->start <= (POINTER)h && (POINTER)(h+1) <= h->bloc_start); |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1030 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1031 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1032 if (h->bloc_start <= break_value && break_value <= h->end) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1033 found = 1; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1034 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1035 ph = h; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1036 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1037 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1038 assert (found); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1039 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
|
1040 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1041 for (b = first_bloc; b; b = b->next) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1042 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1043 assert (b->prev == pb); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1044 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data); |
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1045 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
|
1046 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1047 ph = 0; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1048 for (h = first_heap; h; h = h->next) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1049 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1050 if (h->bloc_start <= b->data && b->data + b->size <= h->end) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1051 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1052 ph = h; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1053 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1054 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1055 assert (h); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1056 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1057 if (pb && pb->data + pb->size != b->data) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1058 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1059 assert (ph && b->data == h->bloc_start); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1060 while (ph) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1061 { |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1062 if (ph->bloc_start <= pb->data |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1063 && pb->data + pb->size <= ph->end) |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1064 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1065 assert (pb->data + pb->size + b->size > ph->end); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1066 break; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1067 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1068 else |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1069 { |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1070 assert (ph->bloc_start + b->size > ph->end); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1071 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1072 ph = ph->prev; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1073 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1074 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1075 pb = b; |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1076 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1077 |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1078 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
|
1079 |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1080 if (last_bloc) |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1081 assert (last_bloc->data + last_bloc->size == break_value); |
9459
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1082 else |
9596
134f7085c56b
(heap_base): Move static var to top level.
Richard M. Stallman <rms@gnu.org>
parents:
9459
diff
changeset
|
1083 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
|
1084 } |
a1569f00a6a6
Install Hiroshi Nakano's rewrite to allow multiple heaps, for implementations
Karl Heuer <kwzh@gnu.org>
parents:
8951
diff
changeset
|
1085 #endif /* DEBUG */ |