1 /* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999-2023 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* Generic garbage collection (GC) functions and data, not specific to
21 any particular GC implementation. */
24 #define INCLUDE_MALLOC_H
26 #include "coretypes.h"
28 #include "diagnostic-core.h"
29 #include "ggc-internal.h"
30 #include "hosthooks.h"
34 /* When true, protect the contents of the identifier hash table. */
35 bool ggc_protect_identifiers
= true;
37 /* Statistics about the allocation. */
38 static ggc_statistics
*ggc_stats
;
40 struct traversal_state
;
42 static int compare_ptr_data (const void *, const void *);
43 static void relocate_ptrs (void *, void *, void *);
44 static void write_pch_globals (const struct ggc_root_tab
* const *tab
,
45 struct traversal_state
*state
);
47 /* Maintain global roots that are preserved during GC. */
49 /* This extra vector of dynamically registered root_tab-s is used by
50 ggc_mark_roots and gives the ability to dynamically add new GGC root
51 tables, for instance from some plugins; this vector is on the heap
52 since it is used by GGC internally. */
53 typedef const struct ggc_root_tab
*const_ggc_root_tab_t
;
54 static vec
<const_ggc_root_tab_t
> extra_root_vec
;
56 /* Dynamically register a new GGC root table RT. This is useful for
60 ggc_register_root_tab (const struct ggc_root_tab
* rt
)
63 extra_root_vec
.safe_push (rt
);
66 /* Mark all the roots in the table RT. */
69 ggc_mark_root_tab (const_ggc_root_tab_t rt
)
73 for ( ; rt
->base
!= NULL
; rt
++)
74 for (i
= 0; i
< rt
->nelt
; i
++)
75 (*rt
->cb
) (*(void **) ((char *)rt
->base
+ rt
->stride
* i
));
78 /* Iterate through all registered roots and mark each element. */
83 const struct ggc_root_tab
*const *rt
;
84 const_ggc_root_tab_t rtp
, rti
;
87 for (rt
= gt_ggc_deletable_rtab
; *rt
; rt
++)
88 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
89 memset (rti
->base
, 0, rti
->stride
);
91 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
92 ggc_mark_root_tab (*rt
);
94 FOR_EACH_VEC_ELT (extra_root_vec
, i
, rtp
)
95 ggc_mark_root_tab (rtp
);
97 if (ggc_protect_identifiers
)
98 ggc_mark_stringpool ();
102 if (! ggc_protect_identifiers
)
103 ggc_purge_stringpool ();
105 /* Some plugins may call ggc_set_mark from here. */
106 invoke_plugin_callbacks (PLUGIN_GGC_MARKING
, NULL
);
109 /* Allocate a block of memory, then clear it. */
111 ggc_internal_cleared_alloc (size_t size
, void (*f
)(void *), size_t s
, size_t n
114 void *buf
= ggc_internal_alloc (size
, f
, s
, n PASS_MEM_STAT
);
115 memset (buf
, 0, size
);
119 /* Resize a block of memory, possibly re-allocating it. */
121 ggc_realloc (void *x
, size_t size MEM_STAT_DECL
)
127 return ggc_internal_alloc (size PASS_MEM_STAT
);
129 old_size
= ggc_get_size (x
);
131 if (size
<= old_size
)
133 /* Mark the unwanted memory as unaccessible. We also need to make
134 the "new" size accessible, since ggc_get_size returns the size of
135 the pool, not the size of the individually allocated object, the
136 size which was previously made accessible. Unfortunately, we
137 don't know that previously allocated size. Without that
138 knowledge we have to lose some initialization-tracking for the
139 old parts of the object. An alternative is to mark the whole
140 old_size as reachable, but that would lose tracking of writes
141 after the end of the object (by small offsets). Discard the
142 handle to avoid handle leak. */
143 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x
+ size
,
145 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x
, size
));
149 r
= ggc_internal_alloc (size PASS_MEM_STAT
);
151 /* Since ggc_get_size returns the size of the pool, not the size of the
152 individually allocated object, we'd access parts of the old object
153 that were marked invalid with the memcpy below. We lose a bit of the
154 initialization-tracking since some of it may be uninitialized. */
155 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x
, old_size
));
157 memcpy (r
, x
, old_size
);
159 /* The old object is not supposed to be used anymore. */
166 ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED
,
167 size_t n ATTRIBUTE_UNUSED
)
169 gcc_assert (c
* n
== sizeof (struct htab
));
170 return ggc_cleared_alloc
<htab
> ();
173 /* TODO: once we actually use type information in GGC, create a new tag
174 gt_gcc_ptr_array and use it for pointer arrays. */
176 ggc_cleared_alloc_ptr_array_two_args (size_t c
, size_t n
)
178 gcc_assert (sizeof (void **) == n
);
179 return ggc_cleared_vec_alloc
<void **> (c
);
182 /* These are for splay_tree_new_ggc. */
184 ggc_splay_alloc (int sz
, void *nl
)
187 return ggc_internal_alloc (sz
);
191 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED
, void *nl
)
197 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED
,
198 ggc_statistics
*stats
)
200 /* Set the pointer so that during collection we will actually gather
204 /* Then do one collection to fill in the statistics. */
207 /* At present, we don't really gather any interesting statistics. */
209 /* Don't gather statistics any more. */
213 /* Functions for saving and restoring GCable memory to disk. */
218 void *note_ptr_cookie
;
219 gt_note_pointers note_ptr_fn
;
220 gt_handle_reorder reorder_fn
;
225 #define POINTER_HASH(x) (hashval_t)((intptr_t)x >> 3)
227 /* Helper for hashing saving_htab. */
229 struct saving_hasher
: free_ptr_hash
<ptr_data
>
231 typedef void *compare_type
;
232 static inline hashval_t
hash (const ptr_data
*);
233 static inline bool equal (const ptr_data
*, const void *);
237 saving_hasher::hash (const ptr_data
*p
)
239 return POINTER_HASH (p
->obj
);
243 saving_hasher::equal (const ptr_data
*p1
, const void *p2
)
245 return p1
->obj
== p2
;
248 static hash_table
<saving_hasher
> *saving_htab
;
249 static vec
<void *> callback_vec
;
250 static vec
<void *> reloc_addrs_vec
;
252 /* Register an object in the hash table. */
255 gt_pch_note_object (void *obj
, void *note_ptr_cookie
,
256 gt_note_pointers note_ptr_fn
,
257 size_t length_override
)
259 struct ptr_data
**slot
;
261 if (obj
== NULL
|| obj
== (void *) 1)
264 slot
= (struct ptr_data
**)
265 saving_htab
->find_slot_with_hash (obj
, POINTER_HASH (obj
), INSERT
);
268 gcc_assert ((*slot
)->note_ptr_fn
== note_ptr_fn
269 && (*slot
)->note_ptr_cookie
== note_ptr_cookie
);
273 *slot
= XCNEW (struct ptr_data
);
275 (*slot
)->note_ptr_fn
= note_ptr_fn
;
276 (*slot
)->note_ptr_cookie
= note_ptr_cookie
;
277 if (length_override
!= (size_t)-1)
278 (*slot
)->size
= length_override
;
279 else if (note_ptr_fn
== gt_pch_p_S
)
280 (*slot
)->size
= strlen ((const char *)obj
) + 1;
282 (*slot
)->size
= ggc_get_size (obj
);
286 /* Register address of a callback pointer. */
288 gt_pch_note_callback (void *obj
, void *base
)
291 memcpy (&ptr
, obj
, sizeof (void *));
294 struct ptr_data
*data
295 = (struct ptr_data
*)
296 saving_htab
->find_with_hash (base
, POINTER_HASH (base
));
298 callback_vec
.safe_push ((char *) data
->new_addr
299 + ((char *) obj
- (char *) base
));
303 /* Register an object in the hash table. */
306 gt_pch_note_reorder (void *obj
, void *note_ptr_cookie
,
307 gt_handle_reorder reorder_fn
)
309 struct ptr_data
*data
;
311 if (obj
== NULL
|| obj
== (void *) 1)
314 data
= (struct ptr_data
*)
315 saving_htab
->find_with_hash (obj
, POINTER_HASH (obj
));
316 gcc_assert (data
&& data
->note_ptr_cookie
== note_ptr_cookie
);
317 /* The GTY 'reorder' option doesn't make sense if we don't walk pointers,
318 such as for strings. */
319 gcc_checking_assert (data
->note_ptr_fn
!= gt_pch_p_S
);
321 data
->reorder_fn
= reorder_fn
;
324 /* Handy state for the traversal functions. */
326 struct traversal_state
329 struct ggc_pch_data
*d
;
331 struct ptr_data
**ptrs
;
335 /* Callbacks for htab_traverse. */
338 ggc_call_count (ptr_data
**slot
, traversal_state
*state
)
340 struct ptr_data
*d
= *slot
;
342 ggc_pch_count_object (state
->d
, d
->obj
, d
->size
);
348 ggc_call_alloc (ptr_data
**slot
, traversal_state
*state
)
350 struct ptr_data
*d
= *slot
;
352 d
->new_addr
= ggc_pch_alloc_object (state
->d
, d
->obj
, d
->size
);
353 state
->ptrs
[state
->ptrs_i
++] = d
;
357 /* Callback for qsort. */
360 compare_ptr_data (const void *p1_p
, const void *p2_p
)
362 const struct ptr_data
*const p1
= *(const struct ptr_data
*const *)p1_p
;
363 const struct ptr_data
*const p2
= *(const struct ptr_data
*const *)p2_p
;
364 return (((size_t)p1
->new_addr
> (size_t)p2
->new_addr
)
365 - ((size_t)p1
->new_addr
< (size_t)p2
->new_addr
));
368 /* Callbacks for note_ptr_fn. */
371 relocate_ptrs (void *ptr_p
, void *real_ptr_p
, void *state_p
)
373 void **ptr
= (void **)ptr_p
;
374 struct traversal_state
*state
375 = (struct traversal_state
*)state_p
;
376 struct ptr_data
*result
;
378 if (*ptr
== NULL
|| *ptr
== (void *)1)
381 result
= (struct ptr_data
*)
382 saving_htab
->find_with_hash (*ptr
, POINTER_HASH (*ptr
));
384 *ptr
= result
->new_addr
;
385 if (ptr_p
== real_ptr_p
)
387 if (real_ptr_p
== NULL
)
389 gcc_assert (real_ptr_p
>= state
->ptrs
[state
->ptrs_i
]->obj
390 && ((char *) real_ptr_p
+ sizeof (void *)
391 <= ((char *) state
->ptrs
[state
->ptrs_i
]->obj
392 + state
->ptrs
[state
->ptrs_i
]->size
)));
394 = (void *) ((char *) state
->ptrs
[state
->ptrs_i
]->new_addr
395 + ((char *) real_ptr_p
396 - (char *) state
->ptrs
[state
->ptrs_i
]->obj
));
397 reloc_addrs_vec
.safe_push (addr
);
400 /* Write out, after relocation, the pointers in TAB. */
402 write_pch_globals (const struct ggc_root_tab
* const *tab
,
403 struct traversal_state
*state
)
405 const struct ggc_root_tab
*const *rt
;
406 const struct ggc_root_tab
*rti
;
409 for (rt
= tab
; *rt
; rt
++)
410 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
411 for (i
= 0; i
< rti
->nelt
; i
++)
413 void *ptr
= *(void **)((char *)rti
->base
+ rti
->stride
* i
);
414 struct ptr_data
*new_ptr
;
415 if (ptr
== NULL
|| ptr
== (void *)1)
417 if (fwrite (&ptr
, sizeof (void *), 1, state
->f
)
419 fatal_error (input_location
, "cannot write PCH file: %m");
423 new_ptr
= (struct ptr_data
*)
424 saving_htab
->find_with_hash (ptr
, POINTER_HASH (ptr
));
425 if (fwrite (&new_ptr
->new_addr
, sizeof (void *), 1, state
->f
)
427 fatal_error (input_location
, "cannot write PCH file: %m");
432 /* Callback for qsort. */
435 compare_ptr (const void *p1_p
, const void *p2_p
)
437 void *p1
= *(void *const *)p1_p
;
438 void *p2
= *(void *const *)p2_p
;
439 return (((uintptr_t)p1
> (uintptr_t)p2
)
440 - ((uintptr_t)p1
< (uintptr_t)p2
));
443 /* Decode one uleb128 from P, return first byte after it, store
444 decoded value into *VAL. */
446 static unsigned char *
447 read_uleb128 (unsigned char *p
, size_t *val
)
449 unsigned int shift
= 0;
457 result
|= ((size_t) byte
& 0x7f) << shift
;
466 /* Store VAL as uleb128 at P, return length in bytes. */
469 write_uleb128 (unsigned char *p
, size_t val
)
474 unsigned char byte
= (val
& 0x7f);
477 /* More bytes to follow. */
487 /* Hold the information we need to mmap the file back in. */
493 void *preferred_base
;
496 /* Write out the state of the compiler to F. */
499 gt_pch_save (FILE *f
)
501 const struct ggc_root_tab
*const *rt
;
502 const struct ggc_root_tab
*rti
;
504 struct traversal_state state
;
505 char *this_object
= NULL
;
506 size_t this_object_size
= 0;
507 struct mmap_info mmi
;
508 const size_t mmap_offset_alignment
= host_hooks
.gt_pch_alloc_granularity ();
510 gt_pch_save_stringpool ();
512 timevar_push (TV_PCH_PTR_REALLOC
);
513 saving_htab
= new hash_table
<saving_hasher
> (50000);
515 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
516 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
517 for (i
= 0; i
< rti
->nelt
; i
++)
518 (*rti
->pchw
)(*(void **)((char *)rti
->base
+ rti
->stride
* i
));
520 /* Prepare the objects for writing, determine addresses and such. */
522 state
.d
= init_ggc_pch ();
524 saving_htab
->traverse
<traversal_state
*, ggc_call_count
> (&state
);
526 mmi
.size
= ggc_pch_total_size (state
.d
);
528 /* Try to arrange things so that no relocation is necessary, but
529 don't try very hard. On most platforms, this will always work,
530 and on the rest it's a lot of work to do better.
531 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
532 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
533 mmi
.preferred_base
= host_hooks
.gt_pch_get_address (mmi
.size
, fileno (f
));
534 /* If the host cannot supply any suitable address for this, we are stuck. */
535 if (mmi
.preferred_base
== NULL
)
536 fatal_error (input_location
,
537 "cannot write PCH file: required memory segment unavailable");
539 ggc_pch_this_base (state
.d
, mmi
.preferred_base
);
541 state
.ptrs
= XNEWVEC (struct ptr_data
*, state
.count
);
544 saving_htab
->traverse
<traversal_state
*, ggc_call_alloc
> (&state
);
545 timevar_pop (TV_PCH_PTR_REALLOC
);
547 timevar_push (TV_PCH_PTR_SORT
);
548 qsort (state
.ptrs
, state
.count
, sizeof (*state
.ptrs
), compare_ptr_data
);
549 timevar_pop (TV_PCH_PTR_SORT
);
551 /* Write out all the scalar variables. */
552 for (rt
= gt_pch_scalar_rtab
; *rt
; rt
++)
553 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
554 if (fwrite (rti
->base
, rti
->stride
, 1, f
) != 1)
555 fatal_error (input_location
, "cannot write PCH file: %m");
557 /* Write out all the global pointers, after translation. */
558 write_pch_globals (gt_ggc_rtab
, &state
);
560 /* Pad the PCH file so that the mmapped area starts on an allocation
561 granularity (usually page) boundary. */
564 o
= ftell (state
.f
) + sizeof (mmi
);
566 fatal_error (input_location
, "cannot get position in PCH file: %m");
567 mmi
.offset
= mmap_offset_alignment
- o
% mmap_offset_alignment
;
568 if (mmi
.offset
== mmap_offset_alignment
)
572 if (fwrite (&mmi
, sizeof (mmi
), 1, state
.f
) != 1)
573 fatal_error (input_location
, "cannot write PCH file: %m");
575 && fseek (state
.f
, mmi
.offset
, SEEK_SET
) != 0)
576 fatal_error (input_location
, "cannot write padding to PCH file: %m");
578 ggc_pch_prepare_write (state
.d
, state
.f
);
580 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
581 vec
<char> vbits
= vNULL
;
584 /* Actually write out the objects. */
585 for (i
= 0; i
< state
.count
; i
++)
588 if (this_object_size
< state
.ptrs
[i
]->size
)
590 this_object_size
= state
.ptrs
[i
]->size
;
591 this_object
= XRESIZEVAR (char, this_object
, this_object_size
);
593 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
594 /* obj might contain uninitialized bytes, e.g. in the trailing
595 padding of the object. Avoid warnings by making the memory
596 temporarily defined and then restoring previous state. */
598 size_t valid_size
= state
.ptrs
[i
]->size
;
599 if (UNLIKELY (RUNNING_ON_VALGRIND
))
601 if (vbits
.length () < valid_size
)
602 vbits
.safe_grow (valid_size
, true);
603 get_vbits
= VALGRIND_GET_VBITS (state
.ptrs
[i
]->obj
,
604 vbits
.address (), valid_size
);
607 /* We assume that first part of obj is addressable, and
608 the rest is unaddressable. Find out where the boundary is
609 using binary search. */
610 size_t lo
= 0, hi
= valid_size
;
613 size_t mid
= (lo
+ hi
) / 2;
614 get_vbits
= VALGRIND_GET_VBITS ((char *) state
.ptrs
[i
]->obj
615 + mid
, vbits
.address (),
619 else if (get_vbits
== 1)
624 if (get_vbits
== 1 || get_vbits
== 3)
627 get_vbits
= VALGRIND_GET_VBITS (state
.ptrs
[i
]->obj
,
633 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (state
.ptrs
[i
]->obj
,
634 state
.ptrs
[i
]->size
));
637 memcpy (this_object
, state
.ptrs
[i
]->obj
, state
.ptrs
[i
]->size
);
638 if (state
.ptrs
[i
]->reorder_fn
!= NULL
)
639 state
.ptrs
[i
]->reorder_fn (state
.ptrs
[i
]->obj
,
640 state
.ptrs
[i
]->note_ptr_cookie
,
641 relocate_ptrs
, &state
);
642 gt_note_pointers note_ptr_fn
= state
.ptrs
[i
]->note_ptr_fn
;
643 gcc_checking_assert (note_ptr_fn
!= NULL
);
644 /* 'gt_pch_p_S' enables certain special handling, but otherwise
645 corresponds to no 'note_ptr_fn'. */
646 if (note_ptr_fn
== gt_pch_p_S
)
648 if (note_ptr_fn
!= NULL
)
649 note_ptr_fn (state
.ptrs
[i
]->obj
, state
.ptrs
[i
]->note_ptr_cookie
,
650 relocate_ptrs
, &state
);
651 ggc_pch_write_object (state
.d
, state
.f
, state
.ptrs
[i
]->obj
,
652 state
.ptrs
[i
]->new_addr
, state
.ptrs
[i
]->size
);
653 if (state
.ptrs
[i
]->reorder_fn
!= NULL
654 || note_ptr_fn
!= NULL
)
655 memcpy (state
.ptrs
[i
]->obj
, this_object
, state
.ptrs
[i
]->size
);
656 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
657 if (UNLIKELY (get_vbits
== 1))
659 (void) VALGRIND_SET_VBITS (state
.ptrs
[i
]->obj
, vbits
.address (),
661 if (valid_size
!= state
.ptrs
[i
]->size
)
662 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *)
670 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
674 reloc_addrs_vec
.qsort (compare_ptr
);
676 size_t reloc_addrs_size
= 0;
677 void *last_addr
= NULL
;
678 unsigned char uleb128_buf
[sizeof (size_t) * 2];
679 for (void *addr
: reloc_addrs_vec
)
681 gcc_assert ((uintptr_t) addr
>= (uintptr_t) mmi
.preferred_base
682 && ((uintptr_t) addr
+ sizeof (void *)
683 < (uintptr_t) mmi
.preferred_base
+ mmi
.size
));
684 if (addr
== last_addr
)
686 if (last_addr
== NULL
)
687 last_addr
= mmi
.preferred_base
;
688 size_t diff
= (uintptr_t) addr
- (uintptr_t) last_addr
;
689 reloc_addrs_size
+= write_uleb128 (uleb128_buf
, diff
);
692 if (fwrite (&reloc_addrs_size
, sizeof (reloc_addrs_size
), 1, f
) != 1)
693 fatal_error (input_location
, "cannot write PCH file: %m");
695 for (void *addr
: reloc_addrs_vec
)
697 if (addr
== last_addr
)
699 if (last_addr
== NULL
)
700 last_addr
= mmi
.preferred_base
;
701 size_t diff
= (uintptr_t) addr
- (uintptr_t) last_addr
;
702 reloc_addrs_size
= write_uleb128 (uleb128_buf
, diff
);
703 if (fwrite (uleb128_buf
, 1, reloc_addrs_size
, f
) != reloc_addrs_size
)
704 fatal_error (input_location
, "cannot write PCH file: %m");
708 ggc_pch_finish (state
.d
, state
.f
);
710 gt_pch_fixup_stringpool ();
712 unsigned num_callbacks
= callback_vec
.length ();
713 void (*pch_save
) (FILE *) = >_pch_save
;
714 if (fwrite (&pch_save
, sizeof (pch_save
), 1, f
) != 1
715 || fwrite (&num_callbacks
, sizeof (num_callbacks
), 1, f
) != 1
717 && fwrite (callback_vec
.address (), sizeof (void *), num_callbacks
,
718 f
) != num_callbacks
))
719 fatal_error (input_location
, "cannot write PCH file: %m");
721 XDELETE (state
.ptrs
);
722 XDELETE (this_object
);
725 callback_vec
.release ();
726 reloc_addrs_vec
.release ();
729 /* Read the state of the compiler back in from F. */
732 gt_pch_restore (FILE *f
)
734 const struct ggc_root_tab
*const *rt
;
735 const struct ggc_root_tab
*rti
;
737 struct mmap_info mmi
;
740 /* We are about to reload the line maps along with the rest of the PCH
741 data, which means that the (loaded) ones cannot be guaranteed to be
742 in any valid state for reporting diagnostics that happen during the
743 load. Save the current table (and use it during the loading process
745 class line_maps
*save_line_table
= line_table
;
747 /* Delete any deletable objects. This makes ggc_pch_read much
748 faster, as it can be sure that no GCable objects remain other
749 than the ones just read in. */
750 for (rt
= gt_ggc_deletable_rtab
; *rt
; rt
++)
751 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
752 memset (rti
->base
, 0, rti
->stride
);
754 /* Read in all the scalar variables. */
755 for (rt
= gt_pch_scalar_rtab
; *rt
; rt
++)
756 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
757 if (fread (rti
->base
, rti
->stride
, 1, f
) != 1)
758 fatal_error (input_location
, "cannot read PCH file: %m");
760 /* Read in all the global pointers, in 6 easy loops. */
761 bool error_reading_pointers
= false;
762 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
763 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
764 for (i
= 0; i
< rti
->nelt
; i
++)
765 if (fread ((char *)rti
->base
+ rti
->stride
* i
,
766 sizeof (void *), 1, f
) != 1)
767 error_reading_pointers
= true;
769 /* Stash the newly read-in line table pointer - it does not point to
770 anything meaningful yet, so swap the old one back in. */
771 class line_maps
*new_line_table
= line_table
;
772 line_table
= save_line_table
;
773 if (error_reading_pointers
)
774 fatal_error (input_location
, "cannot read PCH file: %m");
776 if (fread (&mmi
, sizeof (mmi
), 1, f
) != 1)
777 fatal_error (input_location
, "cannot read PCH file: %m");
779 void *orig_preferred_base
= mmi
.preferred_base
;
780 result
= host_hooks
.gt_pch_use_address (mmi
.preferred_base
, mmi
.size
,
781 fileno (f
), mmi
.offset
);
783 /* We could not mmap or otherwise allocate the required memory at the
787 sorry_at (input_location
, "PCH allocation failure");
788 /* There is no point in continuing from here, we will only end up
789 with a crashed (most likely hanging) compiler. */
793 /* (0) We allocated memory, but did not mmap the file, so we need to read
794 the data in manually. (>0) Otherwise the mmap succeed for the address
798 if (fseek (f
, mmi
.offset
, SEEK_SET
) != 0
799 || fread (mmi
.preferred_base
, mmi
.size
, 1, f
) != 1)
800 fatal_error (input_location
, "cannot read PCH file: %m");
802 else if (fseek (f
, mmi
.offset
+ mmi
.size
, SEEK_SET
) != 0)
803 fatal_error (input_location
, "cannot read PCH file: %m");
805 size_t reloc_addrs_size
;
806 if (fread (&reloc_addrs_size
, sizeof (reloc_addrs_size
), 1, f
) != 1)
807 fatal_error (input_location
, "cannot read PCH file: %m");
809 if (orig_preferred_base
!= mmi
.preferred_base
)
812 = (uintptr_t) mmi
.preferred_base
- (uintptr_t) orig_preferred_base
;
814 /* Adjust all the global pointers by bias. */
815 line_table
= new_line_table
;
816 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
817 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
818 for (i
= 0; i
< rti
->nelt
; i
++)
820 char *addr
= (char *)rti
->base
+ rti
->stride
* i
;
822 memcpy (&p
, addr
, sizeof (void *));
823 if ((uintptr_t) p
>= (uintptr_t) orig_preferred_base
824 && (uintptr_t) p
< (uintptr_t) orig_preferred_base
+ mmi
.size
)
826 p
= (char *) ((uintptr_t) p
+ bias
);
827 memcpy (addr
, &p
, sizeof (void *));
830 new_line_table
= line_table
;
831 line_table
= save_line_table
;
833 /* And adjust all the pointers in the image by bias too. */
834 char *addr
= (char *) mmi
.preferred_base
;
835 unsigned char uleb128_buf
[4096], *uleb128_ptr
= uleb128_buf
;
836 while (reloc_addrs_size
!= 0)
839 = MIN (reloc_addrs_size
,
840 (size_t) (4096 - (uleb128_ptr
- uleb128_buf
)));
841 if (fread (uleb128_ptr
, 1, this_size
, f
) != this_size
)
842 fatal_error (input_location
, "cannot read PCH file: %m");
843 unsigned char *uleb128_end
= uleb128_ptr
+ this_size
;
844 if (this_size
!= reloc_addrs_size
)
845 uleb128_end
-= 2 * sizeof (size_t);
846 uleb128_ptr
= uleb128_buf
;
847 while (uleb128_ptr
< uleb128_end
)
850 uleb128_ptr
= read_uleb128 (uleb128_ptr
, &diff
);
851 addr
= (char *) ((uintptr_t) addr
+ diff
);
854 memcpy (&p
, addr
, sizeof (void *));
855 gcc_assert ((uintptr_t) p
>= (uintptr_t) orig_preferred_base
857 < (uintptr_t) orig_preferred_base
+ mmi
.size
));
858 p
= (char *) ((uintptr_t) p
+ bias
);
859 memcpy (addr
, &p
, sizeof (void *));
861 reloc_addrs_size
-= this_size
;
862 if (reloc_addrs_size
== 0)
864 this_size
= uleb128_end
+ 2 * sizeof (size_t) - uleb128_ptr
;
865 memcpy (uleb128_buf
, uleb128_ptr
, this_size
);
866 uleb128_ptr
= uleb128_buf
+ this_size
;
869 else if (fseek (f
, (mmi
.offset
+ mmi
.size
+ sizeof (reloc_addrs_size
)
870 + reloc_addrs_size
), SEEK_SET
) != 0)
871 fatal_error (input_location
, "cannot read PCH file: %m");
873 ggc_pch_read (f
, mmi
.preferred_base
);
875 void (*pch_save
) (FILE *);
876 unsigned num_callbacks
;
877 if (fread (&pch_save
, sizeof (pch_save
), 1, f
) != 1
878 || fread (&num_callbacks
, sizeof (num_callbacks
), 1, f
) != 1)
879 fatal_error (input_location
, "cannot read PCH file: %m");
880 if (pch_save
!= >_pch_save
)
882 uintptr_t binbias
= (uintptr_t) >_pch_save
- (uintptr_t) pch_save
;
883 void **ptrs
= XNEWVEC (void *, num_callbacks
);
886 = (uintptr_t) mmi
.preferred_base
- (uintptr_t) orig_preferred_base
;
888 if (fread (ptrs
, sizeof (void *), num_callbacks
, f
) != num_callbacks
)
889 fatal_error (input_location
, "cannot read PCH file: %m");
890 for (i
= 0; i
< num_callbacks
; ++i
)
892 void *ptr
= (void *) ((uintptr_t) ptrs
[i
] + bias
);
893 memcpy (&pch_save
, ptr
, sizeof (pch_save
));
894 pch_save
= (void (*) (FILE *)) ((uintptr_t) pch_save
+ binbias
);
895 memcpy (ptr
, &pch_save
, sizeof (pch_save
));
899 else if (fseek (f
, num_callbacks
* sizeof (void *), SEEK_CUR
) != 0)
900 fatal_error (input_location
, "cannot read PCH file: %m");
902 gt_pch_restore_stringpool ();
904 /* Barring corruption of the PCH file, the restored line table should be
905 complete and usable. */
906 line_table
= new_line_table
;
909 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
910 Select no address whatsoever, and let gt_pch_save choose what it will with
911 malloc, presumably. */
914 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED
,
915 int fd ATTRIBUTE_UNUSED
)
920 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
921 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
922 same as base, indicating that the memory has been allocated but needs to
923 be read in from the file. Return -1 if the address differs, to relocation
924 of the PCH file would be required. */
927 default_gt_pch_use_address (void *&base
, size_t size
, int fd ATTRIBUTE_UNUSED
,
928 size_t offset ATTRIBUTE_UNUSED
)
930 void *addr
= xmalloc (size
);
931 return (addr
== base
) - 1;
934 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
935 alignment required for allocating virtual memory. Usually this is the
939 default_gt_pch_alloc_granularity (void)
941 return getpagesize ();
945 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
946 We temporarily allocate SIZE bytes, and let the kernel place the data
947 wherever it will. If it worked, that's our spot, if not we're likely
951 mmap_gt_pch_get_address (size_t size
, int fd
)
955 ret
= mmap (NULL
, size
, PROT_READ
| PROT_WRITE
, MAP_PRIVATE
, fd
, 0);
956 if (ret
== (void *) MAP_FAILED
)
959 munmap ((caddr_t
) ret
, size
);
964 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
965 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
966 mapping the data at BASE, -1 if we couldn't.
968 This version assumes that the kernel honors the START operand of mmap
969 even without MAP_FIXED if START through START+SIZE are not currently
970 mapped with something. */
973 mmap_gt_pch_use_address (void *&base
, size_t size
, int fd
, size_t offset
)
977 /* We're called with size == 0 if we're not planning to load a PCH
978 file at all. This allows the hook to free any static space that
979 we might have allocated at link time. */
983 addr
= mmap ((caddr_t
) base
, size
, PROT_READ
| PROT_WRITE
, MAP_PRIVATE
,
986 return addr
== base
? 1 : -1;
988 #endif /* HAVE_MMAP_FILE */
990 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
992 /* Modify the bound based on rlimits. */
994 ggc_rlimit_bound (double limit
)
996 #if defined(HAVE_GETRLIMIT)
998 # if defined (RLIMIT_AS)
999 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
1000 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
1001 if (getrlimit (RLIMIT_AS
, &rlim
) == 0
1002 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
1003 && rlim
.rlim_cur
< limit
)
1004 limit
= rlim
.rlim_cur
;
1005 # elif defined (RLIMIT_DATA)
1006 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
1007 might be on an OS that has a broken mmap. (Others don't bound
1008 mmap at all, apparently.) */
1009 if (getrlimit (RLIMIT_DATA
, &rlim
) == 0
1010 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
1011 && rlim
.rlim_cur
< limit
1012 /* Darwin has this horribly bogus default setting of
1013 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
1014 appears to be ignored. Ignore such silliness. If a limit
1015 this small was actually effective for mmap, GCC wouldn't even
1017 && rlim
.rlim_cur
>= 8 * ONE_M
)
1018 limit
= rlim
.rlim_cur
;
1019 # endif /* RLIMIT_AS or RLIMIT_DATA */
1020 #endif /* HAVE_GETRLIMIT */
1025 /* Heuristic to set a default for GGC_MIN_EXPAND. */
1027 ggc_min_expand_heuristic (void)
1029 double min_expand
= physmem_total ();
1031 /* Adjust for rlimits. */
1032 min_expand
= ggc_rlimit_bound (min_expand
);
1034 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
1035 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
1036 min_expand
/= ONE_G
;
1038 min_expand
= MIN (min_expand
, 70);
1044 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
1046 ggc_min_heapsize_heuristic (void)
1048 double phys_kbytes
= physmem_total ();
1049 double limit_kbytes
= ggc_rlimit_bound (phys_kbytes
* 2);
1051 phys_kbytes
/= ONE_K
; /* Convert to Kbytes. */
1052 limit_kbytes
/= ONE_K
;
1054 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
1055 bound of 128M (when RAM >= 1GB). */
1058 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
1059 /* Try not to overrun the RSS limit while doing garbage collection.
1060 The RSS limit is only advisory, so no margin is subtracted. */
1063 if (getrlimit (RLIMIT_RSS
, &rlim
) == 0
1064 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
)
1065 phys_kbytes
= MIN (phys_kbytes
, rlim
.rlim_cur
/ ONE_K
);
1069 /* Don't blindly run over our data limit; do GC at least when the
1070 *next* GC would be within 20Mb of the limit or within a quarter of
1071 the limit, whichever is larger. If GCC does hit the data limit,
1072 compilation will fail, so this tries to be conservative. */
1073 limit_kbytes
= MAX (0, limit_kbytes
- MAX (limit_kbytes
/ 4, 20 * ONE_K
));
1074 limit_kbytes
= (limit_kbytes
* 100) / (110 + ggc_min_expand_heuristic ());
1075 phys_kbytes
= MIN (phys_kbytes
, limit_kbytes
);
1077 phys_kbytes
= MAX (phys_kbytes
, 4 * ONE_K
);
1078 phys_kbytes
= MIN (phys_kbytes
, 128 * ONE_K
);
1085 init_ggc_heuristics (void)
1087 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
1088 param_ggc_min_expand
= ggc_min_expand_heuristic ();
1089 param_ggc_min_heapsize
= ggc_min_heapsize_heuristic ();
1093 /* GGC memory usage. */
1094 class ggc_usage
: public mem_usage
1097 /* Default constructor. */
1098 ggc_usage (): m_freed (0), m_collected (0), m_overhead (0) {}
1100 ggc_usage (size_t allocated
, size_t times
, size_t peak
,
1101 size_t freed
, size_t collected
, size_t overhead
)
1102 : mem_usage (allocated
, times
, peak
),
1103 m_freed (freed
), m_collected (collected
), m_overhead (overhead
) {}
1105 /* Equality operator. */
1107 operator== (const ggc_usage
&second
) const
1109 return (get_balance () == second
.get_balance ()
1110 && m_peak
== second
.m_peak
1111 && m_times
== second
.m_times
);
1114 /* Comparison operator. */
1116 operator< (const ggc_usage
&second
) const
1118 if (*this == second
)
1121 return (get_balance () == second
.get_balance () ?
1122 (m_peak
== second
.m_peak
? m_times
< second
.m_times
1123 : m_peak
< second
.m_peak
)
1124 : get_balance () < second
.get_balance ());
1127 /* Register overhead of ALLOCATED and OVERHEAD bytes. */
1129 register_overhead (size_t allocated
, size_t overhead
)
1131 m_allocated
+= allocated
;
1132 m_overhead
+= overhead
;
1136 /* Release overhead of SIZE bytes. */
1138 release_overhead (size_t size
)
1143 /* Sum the usage with SECOND usage. */
1145 operator+ (const ggc_usage
&second
)
1147 return ggc_usage (m_allocated
+ second
.m_allocated
,
1148 m_times
+ second
.m_times
,
1149 m_peak
+ second
.m_peak
,
1150 m_freed
+ second
.m_freed
,
1151 m_collected
+ second
.m_collected
,
1152 m_overhead
+ second
.m_overhead
);
1155 /* Dump usage with PREFIX, where TOTAL is sum of all rows. */
1157 dump (const char *prefix
, ggc_usage
&total
) const
1159 size_t balance
= get_balance ();
1161 "%-48s " PRsa (9) ":%5.1f%%" PRsa (9) ":%5.1f%%"
1162 PRsa (9) ":%5.1f%%" PRsa (9) ":%5.1f%%" PRsa (9) "\n",
1164 SIZE_AMOUNT (balance
), get_percent (balance
, total
.get_balance ()),
1165 SIZE_AMOUNT (m_collected
),
1166 get_percent (m_collected
, total
.m_collected
),
1167 SIZE_AMOUNT (m_freed
), get_percent (m_freed
, total
.m_freed
),
1168 SIZE_AMOUNT (m_overhead
),
1169 get_percent (m_overhead
, total
.m_overhead
),
1170 SIZE_AMOUNT (m_times
));
1173 /* Dump usage coupled to LOC location, where TOTAL is sum of all rows. */
1175 dump (mem_location
*loc
, ggc_usage
&total
) const
1177 char *location_string
= loc
->to_string ();
1179 dump (location_string
, total
);
1181 free (location_string
);
1188 dump ("Total", *this);
1191 /* Get balance which is GGC allocation leak. */
1193 get_balance () const
1195 return m_allocated
+ m_overhead
- m_collected
- m_freed
;
1198 typedef std::pair
<mem_location
*, ggc_usage
*> mem_pair_t
;
1200 /* Compare wrapper used by qsort method. */
1202 compare (const void *first
, const void *second
)
1204 const mem_pair_t mem1
= *(const mem_pair_t
*) first
;
1205 const mem_pair_t mem2
= *(const mem_pair_t
*) second
;
1207 size_t balance1
= mem1
.second
->get_balance ();
1208 size_t balance2
= mem2
.second
->get_balance ();
1210 return balance1
== balance2
? 0 : (balance1
< balance2
? 1 : -1);
1213 /* Dump header with NAME. */
1215 dump_header (const char *name
)
1217 fprintf (stderr
, "%-48s %11s%17s%17s%16s%17s\n", name
, "Leak", "Garbage",
1218 "Freed", "Overhead", "Times");
1221 /* Freed memory in bytes. */
1223 /* Collected memory in bytes. */
1225 /* Overhead memory in bytes. */
1229 /* GCC memory description. */
1230 static mem_alloc_description
<ggc_usage
> ggc_mem_desc
;
1232 /* Dump per-site memory statistics. */
1235 dump_ggc_loc_statistics ()
1237 if (! GATHER_STATISTICS
)
1240 ggc_collect (GGC_COLLECT_FORCE
);
1242 ggc_mem_desc
.dump (GGC_ORIGIN
);
1245 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
1247 ggc_record_overhead (size_t allocated
, size_t overhead
, void *ptr MEM_STAT_DECL
)
1249 ggc_usage
*usage
= ggc_mem_desc
.register_descriptor (ptr
, GGC_ORIGIN
, false
1250 FINAL_PASS_MEM_STAT
);
1252 ggc_mem_desc
.register_object_overhead (usage
, allocated
+ overhead
, ptr
);
1253 usage
->register_overhead (allocated
, overhead
);
1256 /* Notice that the pointer has been freed. */
1258 ggc_free_overhead (void *ptr
)
1260 ggc_mem_desc
.release_object_overhead (ptr
);
1263 /* After live values has been marked, walk all recorded pointers and see if
1264 they are still live. */
1266 ggc_prune_overhead_list (void)
1268 typedef hash_map
<const void *, std::pair
<ggc_usage
*, size_t > > map_t
;
1270 map_t::iterator it
= ggc_mem_desc
.m_reverse_object_map
->begin ();
1272 for (; it
!= ggc_mem_desc
.m_reverse_object_map
->end (); ++it
)
1273 if (!ggc_marked_p ((*it
).first
))
1275 (*it
).second
.first
->m_collected
+= (*it
).second
.second
;
1276 ggc_mem_desc
.m_reverse_object_map
->remove ((*it
).first
);
1280 /* Print memory used by heap if this info is available. */
1283 report_heap_memory_use ()
1285 #if defined(HAVE_MALLINFO) || defined(HAVE_MALLINFO2)
1286 #ifdef HAVE_MALLINFO2
1287 #define MALLINFO_FN mallinfo2
1289 #define MALLINFO_FN mallinfo
1292 fprintf (stderr
, " {heap " PRsa (0) "}",
1293 SIZE_AMOUNT (MALLINFO_FN ().arena
));