1 /* Block-relocating memory allocator.
2 Copyright (C) 1993, 1995, 2000 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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 2, or (at your option)
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.
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, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
24 rather than all of them. This means allowing for a possible
25 hole between the first bloc and the end of malloc storage. */
30 #include "lisp.h" /* Needed for VALBITS. */
31 #include "blockinput.h"
37 typedef POINTER_TYPE
*POINTER
;
40 /* Declared in dispnew.c, this version doesn't screw up if regions
43 extern void safe_bcopy ();
45 #ifdef DOUG_LEA_MALLOC
47 extern int mallopt ();
48 #else /* not DOUG_LEA_MALLOC */
50 extern size_t __malloc_extra_blocks
;
51 #endif /* SYSTEM_MALLOC */
52 #endif /* not DOUG_LEA_MALLOC */
59 typedef void *POINTER
;
64 #define safe_bcopy(x, y, z) memmove (y, x, z)
65 #define bzero(x, len) memset (x, 0, len)
67 #endif /* not emacs */
70 #include "getpagesize.h"
72 #define NIL ((POINTER) 0)
74 /* A flag to indicate whether we have initialized ralloc yet. For
75 Emacs's sake, please do not make this local to malloc_init; on some
76 machines, the dumping procedure makes all static variables
77 read-only. On these machines, the word static is #defined to be
78 the empty string, meaning that r_alloc_initialized becomes an
79 automatic variable, and loses its value each time Emacs is started
82 static int r_alloc_initialized
= 0;
84 static void r_alloc_init ();
87 /* Declarations for working with the malloc, ralloc, and system breaks. */
89 /* Function to set the real break value. */
90 POINTER (*real_morecore
) ();
92 /* The break value, as seen by malloc. */
93 static POINTER virtual_break_value
;
95 /* The address of the end of the last data in use by ralloc,
96 including relocatable blocs as well as malloc data. */
97 static POINTER break_value
;
99 /* This is the size of a page. We round memory requests to this boundary. */
100 static int page_size
;
102 /* Whenever we get memory from the system, get this many extra bytes. This
103 must be a multiple of page_size. */
104 static int extra_bytes
;
106 /* Macros for rounding. Note that rounding to any value is possible
107 by changing the definition of PAGE. */
108 #define PAGE (getpagesize ())
109 #define ALIGNED(addr) (((unsigned long int) (addr) & (page_size - 1)) == 0)
110 #define ROUNDUP(size) (((unsigned long int) (size) + page_size - 1) \
112 #define ROUND_TO_PAGE(addr) (addr & (~(page_size - 1)))
114 #define MEM_ALIGN sizeof(double)
115 #define MEM_ROUNDUP(addr) (((unsigned long int)(addr) + MEM_ALIGN - 1) \
118 /* The hook `malloc' uses for the function which gets more space
121 #ifndef SYSTEM_MALLOC
122 extern POINTER (*__morecore
) ();
127 /***********************************************************************
128 Implementation using sbrk
129 ***********************************************************************/
131 /* Data structures of heaps and blocs. */
133 /* The relocatable objects, or blocs, and the malloc data
134 both reside within one or more heaps.
135 Each heap contains malloc data, running from `start' to `bloc_start',
136 and relocatable objects, running from `bloc_start' to `free'.
138 Relocatable objects may relocate within the same heap
139 or may move into another heap; the heaps themselves may grow
142 We try to make just one heap and make it larger as necessary.
143 But sometimes we can't do that, because we can't get contiguous
144 space to add onto the heap. When that happens, we start a new heap. */
150 /* Start of memory range of this heap. */
152 /* End of memory range of this heap. */
154 /* Start of relocatable data in this heap. */
156 /* Start of unused space in this heap. */
158 /* First bloc in this heap. */
159 struct bp
*first_bloc
;
160 /* Last bloc in this heap. */
161 struct bp
*last_bloc
;
164 #define NIL_HEAP ((heap_ptr) 0)
165 #define HEAP_PTR_SIZE (sizeof (struct heap))
167 /* This is the first heap object.
168 If we need additional heap objects, each one resides at the beginning of
169 the space it covers. */
170 static struct heap heap_base
;
172 /* Head and tail of the list of heaps. */
173 static heap_ptr first_heap
, last_heap
;
175 /* These structures are allocated in the malloc arena.
176 The linked list is kept in order of increasing '.data' members.
177 The data blocks abut each other; if b->next is non-nil, then
178 b->data + b->size == b->next->data.
180 An element with variable==NIL denotes a freed block, which has not yet
181 been collected. They may only appear while r_alloc_freeze > 0, and will be
182 freed when the arena is thawed. Currently, these blocs are not reusable,
183 while the arena is frozen. Very inefficient. */
192 POINTER new_data
; /* temporarily used for relocation */
193 struct heap
*heap
; /* Heap this bloc is in. */
196 #define NIL_BLOC ((bloc_ptr) 0)
197 #define BLOC_PTR_SIZE (sizeof (struct bp))
199 /* Head and tail of the list of relocatable blocs. */
200 static bloc_ptr first_bloc
, last_bloc
;
202 static int use_relocatable_buffers
;
204 /* If >0, no relocation whatsoever takes place. */
205 static int r_alloc_freeze_level
;
208 /* Functions to get and return memory from the system. */
210 /* Find the heap that ADDRESS falls within. */
218 for (heap
= last_heap
; heap
; heap
= heap
->prev
)
220 if (heap
->start
<= address
&& address
<= heap
->end
)
227 /* Find SIZE bytes of space in a heap.
228 Try to get them at ADDRESS (which must fall within some heap's range)
229 if we can get that many within one heap.
231 If enough space is not presently available in our reserve, this means
232 getting more page-aligned space from the system. If the returned space
233 is not contiguous to the last heap, allocate a new heap, and append it
235 obtain does not try to keep track of whether space is in use
236 or not in use. It just returns the address of SIZE bytes that
237 fall within a single heap. If you call obtain twice in a row
238 with the same arguments, you typically get the same value.
239 to the heap list. It's the caller's responsibility to keep
240 track of what space is in use.
242 Return the address of the space if all went well, or zero if we couldn't
243 allocate the memory. */
246 obtain (address
, size
)
251 SIZE already_available
;
253 /* Find the heap that ADDRESS falls within. */
254 for (heap
= last_heap
; heap
; heap
= heap
->prev
)
256 if (heap
->start
<= address
&& address
<= heap
->end
)
263 /* If we can't fit SIZE bytes in that heap,
264 try successive later heaps. */
265 while (heap
&& (char *) address
+ size
> (char *) heap
->end
)
268 if (heap
== NIL_HEAP
)
270 address
= heap
->bloc_start
;
273 /* If we can't fit them within any existing heap,
275 if (heap
== NIL_HEAP
)
277 POINTER
new = (*real_morecore
)(0);
280 already_available
= (char *)last_heap
->end
- (char *)address
;
282 if (new != last_heap
->end
)
284 /* Someone else called sbrk. Make a new heap. */
286 heap_ptr new_heap
= (heap_ptr
) MEM_ROUNDUP (new);
287 POINTER bloc_start
= (POINTER
) MEM_ROUNDUP ((POINTER
)(new_heap
+ 1));
289 if ((*real_morecore
) ((char *) bloc_start
- (char *) new) != new)
292 new_heap
->start
= new;
293 new_heap
->end
= bloc_start
;
294 new_heap
->bloc_start
= bloc_start
;
295 new_heap
->free
= bloc_start
;
296 new_heap
->next
= NIL_HEAP
;
297 new_heap
->prev
= last_heap
;
298 new_heap
->first_bloc
= NIL_BLOC
;
299 new_heap
->last_bloc
= NIL_BLOC
;
300 last_heap
->next
= new_heap
;
301 last_heap
= new_heap
;
303 address
= bloc_start
;
304 already_available
= 0;
307 /* Add space to the last heap (which we may have just created).
308 Get some extra, so we can come here less often. */
310 get
= size
+ extra_bytes
- already_available
;
311 get
= (char *) ROUNDUP ((char *)last_heap
->end
+ get
)
312 - (char *) last_heap
->end
;
314 if ((*real_morecore
) (get
) != last_heap
->end
)
317 last_heap
->end
= (char *) last_heap
->end
+ get
;
323 /* Return unused heap space to the system
324 if there is a lot of unused space now.
325 This can make the last heap smaller;
326 it can also eliminate the last heap entirely. */
334 /* Add the amount of space beyond break_value
335 in all heaps which have extend beyond break_value at all. */
337 for (h
= last_heap
; h
&& break_value
< h
->end
; h
= h
->prev
)
339 excess
+= (char *) h
->end
- (char *) ((break_value
< h
->bloc_start
)
340 ? h
->bloc_start
: break_value
);
343 if (excess
> extra_bytes
* 2 && (*real_morecore
) (0) == last_heap
->end
)
345 /* Keep extra_bytes worth of empty space.
346 And don't free anything unless we can free at least extra_bytes. */
347 excess
-= extra_bytes
;
349 if ((char *)last_heap
->end
- (char *)last_heap
->bloc_start
<= excess
)
351 /* This heap should have no blocs in it. */
352 if (last_heap
->first_bloc
!= NIL_BLOC
353 || last_heap
->last_bloc
!= NIL_BLOC
)
356 /* Return the last heap, with its header, to the system. */
357 excess
= (char *)last_heap
->end
- (char *)last_heap
->start
;
358 last_heap
= last_heap
->prev
;
359 last_heap
->next
= NIL_HEAP
;
363 excess
= (char *) last_heap
->end
364 - (char *) ROUNDUP ((char *)last_heap
->end
- excess
);
365 last_heap
->end
= (char *) last_heap
->end
- excess
;
368 if ((*real_morecore
) (- excess
) == 0)
370 /* If the system didn't want that much memory back, adjust
371 the end of the last heap to reflect that. This can occur
372 if break_value is still within the original data segment. */
373 last_heap
->end
= (char *) last_heap
->end
+ excess
;
374 /* Make sure that the result of the adjustment is accurate.
375 It should be, for the else clause above; the other case,
376 which returns the entire last heap to the system, seems
377 unlikely to trigger this mode of failure. */
378 if (last_heap
->end
!= (*real_morecore
) (0))
384 /* Return the total size in use by relocating allocator,
385 above where malloc gets space. */
388 r_alloc_size_in_use ()
390 return (char *) break_value
- (char *) virtual_break_value
;
393 /* The meat - allocating, freeing, and relocating blocs. */
395 /* Find the bloc referenced by the address in PTR. Returns a pointer
402 register bloc_ptr p
= first_bloc
;
404 while (p
!= NIL_BLOC
)
406 if (p
->variable
== ptr
&& p
->data
== *ptr
)
415 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
416 Returns a pointer to the new bloc, or zero if we couldn't allocate
417 memory for the new block. */
423 register bloc_ptr new_bloc
;
424 register heap_ptr heap
;
426 if (! (new_bloc
= (bloc_ptr
) malloc (BLOC_PTR_SIZE
))
427 || ! (new_bloc
->data
= obtain (break_value
, size
)))
435 break_value
= (char *) new_bloc
->data
+ size
;
437 new_bloc
->size
= size
;
438 new_bloc
->next
= NIL_BLOC
;
439 new_bloc
->variable
= (POINTER
*) NIL
;
440 new_bloc
->new_data
= 0;
442 /* Record in the heap that this space is in use. */
443 heap
= find_heap (new_bloc
->data
);
444 heap
->free
= break_value
;
446 /* Maintain the correspondence between heaps and blocs. */
447 new_bloc
->heap
= heap
;
448 heap
->last_bloc
= new_bloc
;
449 if (heap
->first_bloc
== NIL_BLOC
)
450 heap
->first_bloc
= new_bloc
;
452 /* Put this bloc on the doubly-linked list of blocs. */
455 new_bloc
->prev
= last_bloc
;
456 last_bloc
->next
= new_bloc
;
457 last_bloc
= new_bloc
;
461 first_bloc
= last_bloc
= new_bloc
;
462 new_bloc
->prev
= NIL_BLOC
;
468 /* Calculate new locations of blocs in the list beginning with BLOC,
469 relocating it to start at ADDRESS, in heap HEAP. If enough space is
470 not presently available in our reserve, call obtain for
473 Store the new location of each bloc in its new_data field.
474 Do not touch the contents of blocs or break_value. */
477 relocate_blocs (bloc
, heap
, address
)
482 register bloc_ptr b
= bloc
;
484 /* No need to ever call this if arena is frozen, bug somewhere! */
485 if (r_alloc_freeze_level
)
490 /* If bloc B won't fit within HEAP,
491 move to the next heap and try again. */
492 while (heap
&& (char *) address
+ b
->size
> (char *) heap
->end
)
495 if (heap
== NIL_HEAP
)
497 address
= heap
->bloc_start
;
500 /* If BLOC won't fit in any heap,
501 get enough new space to hold BLOC and all following blocs. */
502 if (heap
== NIL_HEAP
)
504 register bloc_ptr tb
= b
;
507 /* Add up the size of all the following blocs. */
508 while (tb
!= NIL_BLOC
)
516 /* Get that space. */
517 address
= obtain (address
, s
);
524 /* Record the new address of this bloc
525 and update where the next bloc can start. */
526 b
->new_data
= address
;
528 address
= (char *) address
+ b
->size
;
535 /* Reorder the bloc BLOC to go before bloc BEFORE in the doubly linked list.
536 This is necessary if we put the memory of space of BLOC
537 before that of BEFORE. */
540 reorder_bloc (bloc
, before
)
541 bloc_ptr bloc
, before
;
545 /* Splice BLOC out from where it is. */
554 /* Splice it in before BEFORE. */
565 /* Update the records of which heaps contain which blocs, starting
566 with heap HEAP and bloc BLOC. */
569 update_heap_bloc_correspondence (bloc
, heap
)
575 /* Initialize HEAP's status to reflect blocs before BLOC. */
576 if (bloc
!= NIL_BLOC
&& bloc
->prev
!= NIL_BLOC
&& bloc
->prev
->heap
== heap
)
578 /* The previous bloc is in HEAP. */
579 heap
->last_bloc
= bloc
->prev
;
580 heap
->free
= (char *) bloc
->prev
->data
+ bloc
->prev
->size
;
584 /* HEAP contains no blocs before BLOC. */
585 heap
->first_bloc
= NIL_BLOC
;
586 heap
->last_bloc
= NIL_BLOC
;
587 heap
->free
= heap
->bloc_start
;
590 /* Advance through blocs one by one. */
591 for (b
= bloc
; b
!= NIL_BLOC
; b
= b
->next
)
593 /* Advance through heaps, marking them empty,
594 till we get to the one that B is in. */
597 if (heap
->bloc_start
<= b
->data
&& b
->data
<= heap
->end
)
600 /* We know HEAP is not null now,
601 because there has to be space for bloc B. */
602 heap
->first_bloc
= NIL_BLOC
;
603 heap
->last_bloc
= NIL_BLOC
;
604 heap
->free
= heap
->bloc_start
;
607 /* Update HEAP's status for bloc B. */
608 heap
->free
= (char *) b
->data
+ b
->size
;
610 if (heap
->first_bloc
== NIL_BLOC
)
611 heap
->first_bloc
= b
;
613 /* Record that B is in HEAP. */
617 /* If there are any remaining heaps and no blocs left,
618 mark those heaps as empty. */
622 heap
->first_bloc
= NIL_BLOC
;
623 heap
->last_bloc
= NIL_BLOC
;
624 heap
->free
= heap
->bloc_start
;
629 /* Resize BLOC to SIZE bytes. This relocates the blocs
630 that come after BLOC in memory. */
633 resize_bloc (bloc
, size
)
642 /* No need to ever call this if arena is frozen, bug somewhere! */
643 if (r_alloc_freeze_level
)
646 if (bloc
== NIL_BLOC
|| size
== bloc
->size
)
649 for (heap
= first_heap
; heap
!= NIL_HEAP
; heap
= heap
->next
)
651 if (heap
->bloc_start
<= bloc
->data
&& bloc
->data
<= heap
->end
)
655 if (heap
== NIL_HEAP
)
658 old_size
= bloc
->size
;
661 /* Note that bloc could be moved into the previous heap. */
662 address
= (bloc
->prev
? (char *) bloc
->prev
->data
+ bloc
->prev
->size
663 : (char *) first_heap
->bloc_start
);
666 if (heap
->bloc_start
<= address
&& address
<= heap
->end
)
671 if (! relocate_blocs (bloc
, heap
, address
))
673 bloc
->size
= old_size
;
679 for (b
= last_bloc
; b
!= bloc
; b
= b
->prev
)
684 b
->data
= b
->new_data
;
688 safe_bcopy (b
->data
, b
->new_data
, b
->size
);
689 *b
->variable
= b
->data
= b
->new_data
;
695 bloc
->data
= bloc
->new_data
;
699 safe_bcopy (bloc
->data
, bloc
->new_data
, old_size
);
700 bzero ((char *) bloc
->new_data
+ old_size
, size
- old_size
);
701 *bloc
->variable
= bloc
->data
= bloc
->new_data
;
706 for (b
= bloc
; b
!= NIL_BLOC
; b
= b
->next
)
711 b
->data
= b
->new_data
;
715 safe_bcopy (b
->data
, b
->new_data
, b
->size
);
716 *b
->variable
= b
->data
= b
->new_data
;
721 update_heap_bloc_correspondence (bloc
, heap
);
723 break_value
= (last_bloc
? (char *) last_bloc
->data
+ last_bloc
->size
724 : (char *) first_heap
->bloc_start
);
728 /* Free BLOC from the chain of blocs, relocating any blocs above it.
729 This may return space to the system. */
735 heap_ptr heap
= bloc
->heap
;
737 if (r_alloc_freeze_level
)
739 bloc
->variable
= (POINTER
*) NIL
;
743 resize_bloc (bloc
, 0);
745 if (bloc
== first_bloc
&& bloc
== last_bloc
)
747 first_bloc
= last_bloc
= NIL_BLOC
;
749 else if (bloc
== last_bloc
)
751 last_bloc
= bloc
->prev
;
752 last_bloc
->next
= NIL_BLOC
;
754 else if (bloc
== first_bloc
)
756 first_bloc
= bloc
->next
;
757 first_bloc
->prev
= NIL_BLOC
;
761 bloc
->next
->prev
= bloc
->prev
;
762 bloc
->prev
->next
= bloc
->next
;
765 /* Update the records of which blocs are in HEAP. */
766 if (heap
->first_bloc
== bloc
)
768 if (bloc
->next
!= 0 && bloc
->next
->heap
== heap
)
769 heap
->first_bloc
= bloc
->next
;
771 heap
->first_bloc
= heap
->last_bloc
= NIL_BLOC
;
773 if (heap
->last_bloc
== bloc
)
775 if (bloc
->prev
!= 0 && bloc
->prev
->heap
== heap
)
776 heap
->last_bloc
= bloc
->prev
;
778 heap
->first_bloc
= heap
->last_bloc
= NIL_BLOC
;
785 /* Interface routines. */
787 /* Obtain SIZE bytes of storage from the free pool, or the system, as
788 necessary. If relocatable blocs are in use, this means relocating
789 them. This function gets plugged into the GNU malloc's __morecore
792 We provide hysteresis, never relocating by less than extra_bytes.
794 If we're out of memory, we should return zero, to imitate the other
795 __morecore hook values - in particular, __default_morecore in the
796 GNU malloc package. */
805 if (! r_alloc_initialized
)
808 if (! use_relocatable_buffers
)
809 return (*real_morecore
) (size
);
812 return virtual_break_value
;
816 /* Allocate a page-aligned space. GNU malloc would reclaim an
817 extra space if we passed an unaligned one. But we could
818 not always find a space which is contiguous to the previous. */
819 POINTER new_bloc_start
;
820 heap_ptr h
= first_heap
;
821 SIZE get
= ROUNDUP (size
);
823 address
= (POINTER
) ROUNDUP (virtual_break_value
);
825 /* Search the list upward for a heap which is large enough. */
826 while ((char *) h
->end
< (char *) MEM_ROUNDUP ((char *)address
+ get
))
831 address
= (POINTER
) ROUNDUP (h
->start
);
834 /* If not found, obtain more space. */
837 get
+= extra_bytes
+ page_size
;
839 if (! obtain (address
, get
))
842 if (first_heap
== last_heap
)
843 address
= (POINTER
) ROUNDUP (virtual_break_value
);
845 address
= (POINTER
) ROUNDUP (last_heap
->start
);
849 new_bloc_start
= (POINTER
) MEM_ROUNDUP ((char *)address
+ get
);
851 if (first_heap
->bloc_start
< new_bloc_start
)
853 /* This is no clean solution - no idea how to do it better. */
854 if (r_alloc_freeze_level
)
857 /* There is a bug here: if the above obtain call succeeded, but the
858 relocate_blocs call below does not succeed, we need to free
859 the memory that we got with obtain. */
861 /* Move all blocs upward. */
862 if (! relocate_blocs (first_bloc
, h
, new_bloc_start
))
865 /* Note that (POINTER)(h+1) <= new_bloc_start since
866 get >= page_size, so the following does not destroy the heap
868 for (b
= last_bloc
; b
!= NIL_BLOC
; b
= b
->prev
)
870 safe_bcopy (b
->data
, b
->new_data
, b
->size
);
871 *b
->variable
= b
->data
= b
->new_data
;
874 h
->bloc_start
= new_bloc_start
;
876 update_heap_bloc_correspondence (first_bloc
, h
);
880 /* Give up managing heaps below the one the new
881 virtual_break_value points to. */
882 first_heap
->prev
= NIL_HEAP
;
883 first_heap
->next
= h
->next
;
884 first_heap
->start
= h
->start
;
885 first_heap
->end
= h
->end
;
886 first_heap
->free
= h
->free
;
887 first_heap
->first_bloc
= h
->first_bloc
;
888 first_heap
->last_bloc
= h
->last_bloc
;
889 first_heap
->bloc_start
= h
->bloc_start
;
891 if (first_heap
->next
)
892 first_heap
->next
->prev
= first_heap
;
894 last_heap
= first_heap
;
897 bzero (address
, size
);
901 SIZE excess
= (char *)first_heap
->bloc_start
902 - ((char *)virtual_break_value
+ size
);
904 address
= virtual_break_value
;
906 if (r_alloc_freeze_level
== 0 && excess
> 2 * extra_bytes
)
908 excess
-= extra_bytes
;
909 first_heap
->bloc_start
910 = (POINTER
) MEM_ROUNDUP ((char *)first_heap
->bloc_start
- excess
);
912 relocate_blocs (first_bloc
, first_heap
, first_heap
->bloc_start
);
914 for (b
= first_bloc
; b
!= NIL_BLOC
; b
= b
->next
)
916 safe_bcopy (b
->data
, b
->new_data
, b
->size
);
917 *b
->variable
= b
->data
= b
->new_data
;
921 if ((char *)virtual_break_value
+ size
< (char *)first_heap
->start
)
923 /* We found an additional space below the first heap */
924 first_heap
->start
= (POINTER
) ((char *)virtual_break_value
+ size
);
928 virtual_break_value
= (POINTER
) ((char *)address
+ size
);
929 break_value
= (last_bloc
930 ? (char *) last_bloc
->data
+ last_bloc
->size
931 : (char *) first_heap
->bloc_start
);
939 /* Allocate a relocatable bloc of storage of size SIZE. A pointer to
940 the data is returned in *PTR. PTR is thus the address of some variable
941 which will use the data area.
943 The allocation of 0 bytes is valid.
944 In case r_alloc_freeze is set, a best fit of unused blocs could be done
945 before allocating a new area. Not yet done.
947 If we can't allocate the necessary memory, set *PTR to zero, and
955 register bloc_ptr new_bloc
;
957 if (! r_alloc_initialized
)
960 new_bloc
= get_bloc (MEM_ROUNDUP (size
));
963 new_bloc
->variable
= ptr
;
964 *ptr
= new_bloc
->data
;
972 /* Free a bloc of relocatable storage whose data is pointed to by PTR.
973 Store 0 in *PTR to show there's no block allocated. */
977 register POINTER
*ptr
;
979 register bloc_ptr dead_bloc
;
981 if (! r_alloc_initialized
)
984 dead_bloc
= find_bloc (ptr
);
985 if (dead_bloc
== NIL_BLOC
)
988 free_bloc (dead_bloc
);
992 refill_memory_reserve ();
996 /* Given a pointer at address PTR to relocatable data, resize it to SIZE.
997 Do this by shifting all blocks above this one up in memory, unless
998 SIZE is less than or equal to the current bloc size, in which case
1001 In case r_alloc_freeze is set, a new bloc is allocated, and the
1002 memory copied to it. Not very efficient. We could traverse the
1003 bloc_list for a best fit of free blocs first.
1005 Change *PTR to reflect the new bloc, and return this value.
1007 If more memory cannot be allocated, then leave *PTR unchanged, and
1011 r_re_alloc (ptr
, size
)
1015 register bloc_ptr bloc
;
1017 if (! r_alloc_initialized
)
1021 return r_alloc (ptr
, size
);
1025 return r_alloc (ptr
, 0);
1028 bloc
= find_bloc (ptr
);
1029 if (bloc
== NIL_BLOC
)
1032 if (size
< bloc
->size
)
1034 /* Wouldn't it be useful to actually resize the bloc here? */
1035 /* I think so too, but not if it's too expensive... */
1036 if ((bloc
->size
- MEM_ROUNDUP (size
) >= page_size
)
1037 && r_alloc_freeze_level
== 0)
1039 resize_bloc (bloc
, MEM_ROUNDUP (size
));
1040 /* Never mind if this fails, just do nothing... */
1041 /* It *should* be infallible! */
1044 else if (size
> bloc
->size
)
1046 if (r_alloc_freeze_level
)
1049 new_bloc
= get_bloc (MEM_ROUNDUP (size
));
1052 new_bloc
->variable
= ptr
;
1053 *ptr
= new_bloc
->data
;
1054 bloc
->variable
= (POINTER
*) NIL
;
1061 if (! resize_bloc (bloc
, MEM_ROUNDUP (size
)))
1068 /* Disable relocations, after making room for at least SIZE bytes
1069 of non-relocatable heap if possible. The relocatable blocs are
1070 guaranteed to hold still until thawed, even if this means that
1071 malloc must return a null pointer. */
1074 r_alloc_freeze (size
)
1077 if (! r_alloc_initialized
)
1080 /* If already frozen, we can't make any more room, so don't try. */
1081 if (r_alloc_freeze_level
> 0)
1083 /* If we can't get the amount requested, half is better than nothing. */
1084 while (size
> 0 && r_alloc_sbrk (size
) == 0)
1086 ++r_alloc_freeze_level
;
1088 r_alloc_sbrk (-size
);
1095 if (! r_alloc_initialized
)
1098 if (--r_alloc_freeze_level
< 0)
1101 /* This frees all unused blocs. It is not too inefficient, as the resize
1102 and bcopy is done only once. Afterwards, all unreferenced blocs are
1103 already shrunk to zero size. */
1104 if (!r_alloc_freeze_level
)
1106 bloc_ptr
*b
= &first_bloc
;
1108 if (!(*b
)->variable
)
1116 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
1118 /* Reinitialize the morecore hook variables after restarting a dumped
1119 Emacs. This is needed when using Doug Lea's malloc from GNU libc. */
1123 /* Only do this if the hook has been reset, so that we don't get an
1124 infinite loop, in case Emacs was linked statically. */
1125 if (__morecore
!= r_alloc_sbrk
)
1127 real_morecore
= __morecore
;
1128 __morecore
= r_alloc_sbrk
;
1132 #endif /* emacs && DOUG_LEA_MALLOC */
1145 if (!r_alloc_initialized
)
1148 assert (first_heap
);
1149 assert (last_heap
->end
<= (POINTER
) sbrk (0));
1150 assert ((POINTER
) first_heap
< first_heap
->start
);
1151 assert (first_heap
->start
<= virtual_break_value
);
1152 assert (virtual_break_value
<= first_heap
->end
);
1154 for (h
= first_heap
; h
; h
= h
->next
)
1156 assert (h
->prev
== ph
);
1157 assert ((POINTER
) ROUNDUP (h
->end
) == h
->end
);
1158 #if 0 /* ??? The code in ralloc.c does not really try to ensure
1159 the heap start has any sort of alignment.
1160 Perhaps it should. */
1161 assert ((POINTER
) MEM_ROUNDUP (h
->start
) == h
->start
);
1163 assert ((POINTER
) MEM_ROUNDUP (h
->bloc_start
) == h
->bloc_start
);
1164 assert (h
->start
<= h
->bloc_start
&& h
->bloc_start
<= h
->end
);
1168 assert (ph
->end
< h
->start
);
1169 assert (h
->start
<= (POINTER
)h
&& (POINTER
)(h
+1) <= h
->bloc_start
);
1172 if (h
->bloc_start
<= break_value
&& break_value
<= h
->end
)
1179 assert (last_heap
== ph
);
1181 for (b
= first_bloc
; b
; b
= b
->next
)
1183 assert (b
->prev
== pb
);
1184 assert ((POINTER
) MEM_ROUNDUP (b
->data
) == b
->data
);
1185 assert ((SIZE
) MEM_ROUNDUP (b
->size
) == b
->size
);
1188 for (h
= first_heap
; h
; h
= h
->next
)
1190 if (h
->bloc_start
<= b
->data
&& b
->data
+ b
->size
<= h
->end
)
1197 if (pb
&& pb
->data
+ pb
->size
!= b
->data
)
1199 assert (ph
&& b
->data
== h
->bloc_start
);
1202 if (ph
->bloc_start
<= pb
->data
1203 && pb
->data
+ pb
->size
<= ph
->end
)
1205 assert (pb
->data
+ pb
->size
+ b
->size
> ph
->end
);
1210 assert (ph
->bloc_start
+ b
->size
> ph
->end
);
1218 assert (last_bloc
== pb
);
1221 assert (last_bloc
->data
+ last_bloc
->size
== break_value
);
1223 assert (first_heap
->bloc_start
== break_value
);
1230 /***********************************************************************
1232 ***********************************************************************/
1234 /* Initialize various things for memory allocation. */
1239 if (r_alloc_initialized
)
1241 r_alloc_initialized
= 1;
1244 #ifndef SYSTEM_MALLOC
1245 real_morecore
= __morecore
;
1246 __morecore
= r_alloc_sbrk
;
1248 first_heap
= last_heap
= &heap_base
;
1249 first_heap
->next
= first_heap
->prev
= NIL_HEAP
;
1250 first_heap
->start
= first_heap
->bloc_start
1251 = virtual_break_value
= break_value
= (*real_morecore
) (0);
1252 if (break_value
== NIL
)
1255 extra_bytes
= ROUNDUP (50000);
1258 #ifdef DOUG_LEA_MALLOC
1260 mallopt (M_TOP_PAD
, 64 * 4096);
1263 #ifndef SYSTEM_MALLOC
1264 /* Give GNU malloc's morecore some hysteresis
1265 so that we move all the relocatable blocks much less often. */
1266 __malloc_extra_blocks
= 64;
1270 #ifndef SYSTEM_MALLOC
1271 first_heap
->end
= (POINTER
) ROUNDUP (first_heap
->start
);
1273 /* The extra call to real_morecore guarantees that the end of the
1274 address space is a multiple of page_size, even if page_size is
1275 not really the page size of the system running the binary in
1276 which page_size is stored. This allows a binary to be built on a
1277 system with one page size and run on a system with a smaller page
1279 (*real_morecore
) ((char *) first_heap
->end
- (char *) first_heap
->start
);
1281 /* Clear the rest of the last page; this memory is in our address space
1282 even though it is after the sbrk value. */
1283 /* Doubly true, with the additional call that explicitly adds the
1284 rest of that page to the address space. */
1285 bzero (first_heap
->start
,
1286 (char *) first_heap
->end
- (char *) first_heap
->start
);
1287 virtual_break_value
= break_value
= first_heap
->bloc_start
= first_heap
->end
;
1290 use_relocatable_buffers
= 1;
1293 /* arch-tag: 6a524a15-faff-44c8-95d4-a5da6f55110f
1294 (do not change this comment) */