1/* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999-2023 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20/* Generic garbage collection (GC) functions and data, not specific to
21 any particular GC implementation. */
22
23#include "config.h"
24#define INCLUDE_MALLOC_H
25#include "system.h"
26#include "coretypes.h"
27#include "timevar.h"
28#include "diagnostic-core.h"
29#include "ggc-internal.h"
30#include "hosthooks.h"
31#include "plugin.h"
32#include "options.h"
33
34/* When true, protect the contents of the identifier hash table. */
35bool ggc_protect_identifiers = true;
36
37/* Statistics about the allocation. */
38static ggc_statistics *ggc_stats;
39
40struct traversal_state;
41
42static int compare_ptr_data (const void *, const void *);
43static void relocate_ptrs (void *, void *, void *);
44static void write_pch_globals (const struct ggc_root_tab * const *tab,
45 struct traversal_state *state);
46
47/* Maintain global roots that are preserved during GC. */
48
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. */
53typedef const struct ggc_root_tab *const_ggc_root_tab_t;
54static vec<const_ggc_root_tab_t> extra_root_vec;
55
56/* Dynamically register a new GGC root table RT. This is useful for
57 plugins. */
58
59void
60ggc_register_root_tab (const struct ggc_root_tab* rt)
61{
62 if (rt)
63 extra_root_vec.safe_push (obj: rt);
64}
65
66/* Mark all the roots in the table RT. */
67
68static void
69ggc_mark_root_tab (const_ggc_root_tab_t rt)
70{
71 size_t i;
72
73 for ( ; rt->base != NULL; rt++)
74 for (i = 0; i < rt->nelt; i++)
75 (*rt->cb) (*(void **) ((char *)rt->base + rt->stride * i));
76}
77
78/* Zero out all the roots in the table RT. */
79
80static void
81ggc_zero_rtab_roots (const_ggc_root_tab_t rt)
82{
83 size_t i;
84
85 for ( ; rt->base != NULL; rt++)
86 for (i = 0; i < rt->nelt; i++)
87 (*(void **) ((char *)rt->base + rt->stride * i)) = (void*)0;
88}
89
90/* Iterate through all registered roots and mark each element. */
91
92void
93ggc_mark_roots (void)
94{
95 const struct ggc_root_tab *const *rt;
96 const_ggc_root_tab_t rtp, rti;
97 size_t i;
98
99 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
100 for (rti = *rt; rti->base != NULL; rti++)
101 memset (s: rti->base, c: 0, n: rti->stride * rti->nelt);
102
103 for (rt = gt_ggc_rtab; *rt; rt++)
104 ggc_mark_root_tab (rt: *rt);
105
106 FOR_EACH_VEC_ELT (extra_root_vec, i, rtp)
107 ggc_mark_root_tab (rt: rtp);
108
109 if (ggc_protect_identifiers)
110 ggc_mark_stringpool ();
111
112 gt_clear_caches ();
113
114 if (! ggc_protect_identifiers)
115 ggc_purge_stringpool ();
116
117 /* Some plugins may call ggc_set_mark from here. */
118 invoke_plugin_callbacks (event: PLUGIN_GGC_MARKING, NULL);
119}
120
121/* Allocate a block of memory, then clear it. */
122void *
123ggc_internal_cleared_alloc (size_t size, void (*f)(void *), size_t s, size_t n
124 MEM_STAT_DECL)
125{
126 void *buf = ggc_internal_alloc (size, f, s, n PASS_MEM_STAT);
127 memset (s: buf, c: 0, n: size);
128 return buf;
129}
130
131/* Resize a block of memory, possibly re-allocating it. */
132void *
133ggc_realloc (void *x, size_t size MEM_STAT_DECL)
134{
135 void *r;
136 size_t old_size;
137
138 if (x == NULL)
139 return ggc_internal_alloc (s: size PASS_MEM_STAT);
140
141 old_size = ggc_get_size (x);
142
143 if (size <= old_size)
144 {
145 /* Mark the unwanted memory as unaccessible. We also need to make
146 the "new" size accessible, since ggc_get_size returns the size of
147 the pool, not the size of the individually allocated object, the
148 size which was previously made accessible. Unfortunately, we
149 don't know that previously allocated size. Without that
150 knowledge we have to lose some initialization-tracking for the
151 old parts of the object. An alternative is to mark the whole
152 old_size as reachable, but that would lose tracking of writes
153 after the end of the object (by small offsets). Discard the
154 handle to avoid handle leak. */
155 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x + size,
156 old_size - size));
157 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
158 return x;
159 }
160
161 r = ggc_internal_alloc (s: size PASS_MEM_STAT);
162
163 /* Since ggc_get_size returns the size of the pool, not the size of the
164 individually allocated object, we'd access parts of the old object
165 that were marked invalid with the memcpy below. We lose a bit of the
166 initialization-tracking since some of it may be uninitialized. */
167 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, old_size));
168
169 memcpy (dest: r, src: x, n: old_size);
170
171 /* The old object is not supposed to be used anymore. */
172 ggc_free (x);
173
174 return r;
175}
176
177void *
178ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED,
179 size_t n ATTRIBUTE_UNUSED)
180{
181 gcc_assert (c * n == sizeof (struct htab));
182 return ggc_cleared_alloc<htab> ();
183}
184
185/* TODO: once we actually use type information in GGC, create a new tag
186 gt_gcc_ptr_array and use it for pointer arrays. */
187void *
188ggc_cleared_alloc_ptr_array_two_args (size_t c, size_t n)
189{
190 gcc_assert (sizeof (void **) == n);
191 return ggc_cleared_vec_alloc<void **> (c);
192}
193
194/* These are for splay_tree_new_ggc. */
195void *
196ggc_splay_alloc (int sz, void *nl)
197{
198 gcc_assert (!nl);
199 return ggc_internal_alloc (s: sz);
200}
201
202void
203ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
204{
205 gcc_assert (!nl);
206}
207
208void
209ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
210 ggc_statistics *stats)
211{
212 /* Set the pointer so that during collection we will actually gather
213 the statistics. */
214 ggc_stats = stats;
215
216 /* Then do one collection to fill in the statistics. */
217 ggc_collect ();
218
219 /* At present, we don't really gather any interesting statistics. */
220
221 /* Don't gather statistics any more. */
222 ggc_stats = NULL;
223}
224
225/* Functions for saving and restoring GCable memory to disk. */
226
227struct ptr_data
228{
229 void *obj;
230 void *note_ptr_cookie;
231 gt_note_pointers note_ptr_fn;
232 gt_handle_reorder reorder_fn;
233 size_t size;
234 void *new_addr;
235};
236
237#define POINTER_HASH(x) (hashval_t)((intptr_t)x >> 3)
238
239/* Helper for hashing saving_htab. */
240
241struct saving_hasher : free_ptr_hash <ptr_data>
242{
243 typedef void *compare_type;
244 static inline hashval_t hash (const ptr_data *);
245 static inline bool equal (const ptr_data *, const void *);
246};
247
248inline hashval_t
249saving_hasher::hash (const ptr_data *p)
250{
251 return POINTER_HASH (p->obj);
252}
253
254inline bool
255saving_hasher::equal (const ptr_data *p1, const void *p2)
256{
257 return p1->obj == p2;
258}
259
260static hash_table<saving_hasher> *saving_htab;
261static vec<void *> callback_vec;
262static vec<void *> reloc_addrs_vec;
263
264/* Register an object in the hash table. */
265
266int
267gt_pch_note_object (void *obj, void *note_ptr_cookie,
268 gt_note_pointers note_ptr_fn,
269 size_t length_override)
270{
271 struct ptr_data **slot;
272
273 if (obj == NULL || obj == (void *) 1)
274 return 0;
275
276 slot = (struct ptr_data **)
277 saving_htab->find_slot_with_hash (comparable: obj, POINTER_HASH (obj), insert: INSERT);
278 if (*slot != NULL)
279 {
280 gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
281 && (*slot)->note_ptr_cookie == note_ptr_cookie);
282 return 0;
283 }
284
285 *slot = XCNEW (struct ptr_data);
286 (*slot)->obj = obj;
287 (*slot)->note_ptr_fn = note_ptr_fn;
288 (*slot)->note_ptr_cookie = note_ptr_cookie;
289 if (length_override != (size_t)-1)
290 (*slot)->size = length_override;
291 else if (note_ptr_fn == gt_pch_p_S)
292 (*slot)->size = strlen (s: (const char *)obj) + 1;
293 else
294 (*slot)->size = ggc_get_size (obj);
295 return 1;
296}
297
298/* Register address of a callback pointer. */
299void
300gt_pch_note_callback (void *obj, void *base)
301{
302 void *ptr;
303 memcpy (dest: &ptr, src: obj, n: sizeof (void *));
304 if (ptr != NULL)
305 {
306 struct ptr_data *data
307 = (struct ptr_data *)
308 saving_htab->find_with_hash (comparable: base, POINTER_HASH (base));
309 gcc_assert (data);
310 callback_vec.safe_push (obj: (char *) data->new_addr
311 + ((char *) obj - (char *) base));
312 }
313}
314
315/* Register an object in the hash table. */
316
317void
318gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
319 gt_handle_reorder reorder_fn)
320{
321 struct ptr_data *data;
322
323 if (obj == NULL || obj == (void *) 1)
324 return;
325
326 data = (struct ptr_data *)
327 saving_htab->find_with_hash (comparable: obj, POINTER_HASH (obj));
328 gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
329 /* The GTY 'reorder' option doesn't make sense if we don't walk pointers,
330 such as for strings. */
331 gcc_checking_assert (data->note_ptr_fn != gt_pch_p_S);
332
333 data->reorder_fn = reorder_fn;
334}
335
336/* Handy state for the traversal functions. */
337
338struct traversal_state
339{
340 FILE *f;
341 struct ggc_pch_data *d;
342 size_t count;
343 struct ptr_data **ptrs;
344 size_t ptrs_i;
345};
346
347/* Callbacks for htab_traverse. */
348
349int
350ggc_call_count (ptr_data **slot, traversal_state *state)
351{
352 struct ptr_data *d = *slot;
353
354 ggc_pch_count_object (state->d, d->obj, d->size);
355 state->count++;
356 return 1;
357}
358
359int
360ggc_call_alloc (ptr_data **slot, traversal_state *state)
361{
362 struct ptr_data *d = *slot;
363
364 d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size);
365 state->ptrs[state->ptrs_i++] = d;
366 return 1;
367}
368
369/* Callback for qsort. */
370
371static int
372compare_ptr_data (const void *p1_p, const void *p2_p)
373{
374 const struct ptr_data *const p1 = *(const struct ptr_data *const *)p1_p;
375 const struct ptr_data *const p2 = *(const struct ptr_data *const *)p2_p;
376 return (((size_t)p1->new_addr > (size_t)p2->new_addr)
377 - ((size_t)p1->new_addr < (size_t)p2->new_addr));
378}
379
380/* Callbacks for note_ptr_fn. */
381
382static void
383relocate_ptrs (void *ptr_p, void *real_ptr_p, void *state_p)
384{
385 void **ptr = (void **)ptr_p;
386 struct traversal_state *state
387 = (struct traversal_state *)state_p;
388 struct ptr_data *result;
389
390 if (*ptr == NULL || *ptr == (void *)1)
391 return;
392
393 result = (struct ptr_data *)
394 saving_htab->find_with_hash (comparable: *ptr, POINTER_HASH (*ptr));
395 gcc_assert (result);
396 *ptr = result->new_addr;
397 if (ptr_p == real_ptr_p)
398 return;
399 if (real_ptr_p == NULL)
400 real_ptr_p = ptr_p;
401 gcc_assert (real_ptr_p >= state->ptrs[state->ptrs_i]->obj
402 && ((char *) real_ptr_p + sizeof (void *)
403 <= ((char *) state->ptrs[state->ptrs_i]->obj
404 + state->ptrs[state->ptrs_i]->size)));
405 void *addr
406 = (void *) ((char *) state->ptrs[state->ptrs_i]->new_addr
407 + ((char *) real_ptr_p
408 - (char *) state->ptrs[state->ptrs_i]->obj));
409 reloc_addrs_vec.safe_push (obj: addr);
410}
411
412/* Write out, after relocation, the pointers in TAB. */
413static void
414write_pch_globals (const struct ggc_root_tab * const *tab,
415 struct traversal_state *state)
416{
417 const struct ggc_root_tab *const *rt;
418 const struct ggc_root_tab *rti;
419 size_t i;
420
421 for (rt = tab; *rt; rt++)
422 for (rti = *rt; rti->base != NULL; rti++)
423 for (i = 0; i < rti->nelt; i++)
424 {
425 void *ptr = *(void **)((char *)rti->base + rti->stride * i);
426 struct ptr_data *new_ptr;
427 if (ptr == NULL || ptr == (void *)1)
428 {
429 if (fwrite (ptr: &ptr, size: sizeof (void *), n: 1, s: state->f)
430 != 1)
431 fatal_error (input_location, "cannot write PCH file: %m");
432 }
433 else
434 {
435 new_ptr = (struct ptr_data *)
436 saving_htab->find_with_hash (comparable: ptr, POINTER_HASH (ptr));
437 if (fwrite (ptr: &new_ptr->new_addr, size: sizeof (void *), n: 1, s: state->f)
438 != 1)
439 fatal_error (input_location, "cannot write PCH file: %m");
440 }
441 }
442}
443
444/* Callback for qsort. */
445
446static int
447compare_ptr (const void *p1_p, const void *p2_p)
448{
449 void *p1 = *(void *const *)p1_p;
450 void *p2 = *(void *const *)p2_p;
451 return (((uintptr_t)p1 > (uintptr_t)p2)
452 - ((uintptr_t)p1 < (uintptr_t)p2));
453}
454
455/* Decode one uleb128 from P, return first byte after it, store
456 decoded value into *VAL. */
457
458static unsigned char *
459read_uleb128 (unsigned char *p, size_t *val)
460{
461 unsigned int shift = 0;
462 unsigned char byte;
463 size_t result;
464
465 result = 0;
466 do
467 {
468 byte = *p++;
469 result |= ((size_t) byte & 0x7f) << shift;
470 shift += 7;
471 }
472 while (byte & 0x80);
473
474 *val = result;
475 return p;
476}
477
478/* Store VAL as uleb128 at P, return length in bytes. */
479
480static size_t
481write_uleb128 (unsigned char *p, size_t val)
482{
483 size_t len = 0;
484 do
485 {
486 unsigned char byte = (val & 0x7f);
487 val >>= 7;
488 if (val != 0)
489 /* More bytes to follow. */
490 byte |= 0x80;
491
492 *p++ = byte;
493 ++len;
494 }
495 while (val != 0);
496 return len;
497}
498
499/* Hold the information we need to mmap the file back in. */
500
501struct mmap_info
502{
503 size_t offset;
504 size_t size;
505 void *preferred_base;
506};
507
508/* Write out the state of the compiler to F. */
509
510void
511gt_pch_save (FILE *f)
512{
513 const struct ggc_root_tab *const *rt;
514 const struct ggc_root_tab *rti;
515 size_t i;
516 struct traversal_state state;
517 char *this_object = NULL;
518 size_t this_object_size = 0;
519 struct mmap_info mmi;
520 const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity ();
521
522 gt_pch_save_stringpool ();
523
524 timevar_push (tv: TV_PCH_PTR_REALLOC);
525 saving_htab = new hash_table<saving_hasher> (50000);
526
527 for (rt = gt_ggc_rtab; *rt; rt++)
528 for (rti = *rt; rti->base != NULL; rti++)
529 for (i = 0; i < rti->nelt; i++)
530 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
531
532 /* Prepare the objects for writing, determine addresses and such. */
533 state.f = f;
534 state.d = init_ggc_pch ();
535 state.count = 0;
536 saving_htab->traverse <traversal_state *, ggc_call_count> (argument: &state);
537
538 mmi.size = ggc_pch_total_size (state.d);
539
540 /* Try to arrange things so that no relocation is necessary, but
541 don't try very hard. On most platforms, this will always work,
542 and on the rest it's a lot of work to do better.
543 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
544 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
545 mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
546 /* If the host cannot supply any suitable address for this, we are stuck. */
547 if (mmi.preferred_base == NULL)
548 fatal_error (input_location,
549 "cannot write PCH file: required memory segment unavailable");
550
551 ggc_pch_this_base (state.d, mmi.preferred_base);
552
553 state.ptrs = XNEWVEC (struct ptr_data *, state.count);
554 state.ptrs_i = 0;
555
556 saving_htab->traverse <traversal_state *, ggc_call_alloc> (argument: &state);
557 timevar_pop (tv: TV_PCH_PTR_REALLOC);
558
559 timevar_push (tv: TV_PCH_PTR_SORT);
560 qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
561 timevar_pop (tv: TV_PCH_PTR_SORT);
562
563 /* Write out all the scalar variables. */
564 for (rt = gt_pch_scalar_rtab; *rt; rt++)
565 for (rti = *rt; rti->base != NULL; rti++)
566 if (fwrite (ptr: rti->base, size: rti->stride, n: 1, s: f) != 1)
567 fatal_error (input_location, "cannot write PCH file: %m");
568
569 /* Write out all the global pointers, after translation. */
570 write_pch_globals (tab: gt_ggc_rtab, state: &state);
571
572 /* Pad the PCH file so that the mmapped area starts on an allocation
573 granularity (usually page) boundary. */
574 {
575 long o;
576 o = ftell (stream: state.f) + sizeof (mmi);
577 if (o == -1)
578 fatal_error (input_location, "cannot get position in PCH file: %m");
579 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
580 if (mmi.offset == mmap_offset_alignment)
581 mmi.offset = 0;
582 mmi.offset += o;
583 }
584 if (fwrite (ptr: &mmi, size: sizeof (mmi), n: 1, s: state.f) != 1)
585 fatal_error (input_location, "cannot write PCH file: %m");
586 if (mmi.offset != 0
587 && fseek (stream: state.f, off: mmi.offset, SEEK_SET) != 0)
588 fatal_error (input_location, "cannot write padding to PCH file: %m");
589
590 ggc_pch_prepare_write (state.d, state.f);
591
592#if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
593 vec<char> vbits = vNULL;
594#endif
595
596 /* Actually write out the objects. */
597 for (i = 0; i < state.count; i++)
598 {
599 state.ptrs_i = i;
600 if (this_object_size < state.ptrs[i]->size)
601 {
602 this_object_size = state.ptrs[i]->size;
603 this_object = XRESIZEVAR (char, this_object, this_object_size);
604 }
605#if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
606 /* obj might contain uninitialized bytes, e.g. in the trailing
607 padding of the object. Avoid warnings by making the memory
608 temporarily defined and then restoring previous state. */
609 int get_vbits = 0;
610 size_t valid_size = state.ptrs[i]->size;
611 if (UNLIKELY (RUNNING_ON_VALGRIND))
612 {
613 if (vbits.length () < valid_size)
614 vbits.safe_grow (valid_size, true);
615 get_vbits = VALGRIND_GET_VBITS (state.ptrs[i]->obj,
616 vbits.address (), valid_size);
617 if (get_vbits == 3)
618 {
619 /* We assume that first part of obj is addressable, and
620 the rest is unaddressable. Find out where the boundary is
621 using binary search. */
622 size_t lo = 0, hi = valid_size;
623 while (hi > lo)
624 {
625 size_t mid = (lo + hi) / 2;
626 get_vbits = VALGRIND_GET_VBITS ((char *) state.ptrs[i]->obj
627 + mid, vbits.address (),
628 1);
629 if (get_vbits == 3)
630 hi = mid;
631 else if (get_vbits == 1)
632 lo = mid + 1;
633 else
634 break;
635 }
636 if (get_vbits == 1 || get_vbits == 3)
637 {
638 valid_size = lo;
639 get_vbits = VALGRIND_GET_VBITS (state.ptrs[i]->obj,
640 vbits.address (),
641 valid_size);
642 }
643 }
644 if (get_vbits == 1)
645 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (state.ptrs[i]->obj,
646 state.ptrs[i]->size));
647 }
648#endif
649 memcpy (dest: this_object, src: state.ptrs[i]->obj, n: state.ptrs[i]->size);
650 if (state.ptrs[i]->reorder_fn != NULL)
651 state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,
652 state.ptrs[i]->note_ptr_cookie,
653 relocate_ptrs, &state);
654 gt_note_pointers note_ptr_fn = state.ptrs[i]->note_ptr_fn;
655 gcc_checking_assert (note_ptr_fn != NULL);
656 /* 'gt_pch_p_S' enables certain special handling, but otherwise
657 corresponds to no 'note_ptr_fn'. */
658 if (note_ptr_fn == gt_pch_p_S)
659 note_ptr_fn = NULL;
660 if (note_ptr_fn != NULL)
661 note_ptr_fn (state.ptrs[i]->obj, state.ptrs[i]->note_ptr_cookie,
662 relocate_ptrs, &state);
663 ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
664 state.ptrs[i]->new_addr, state.ptrs[i]->size);
665 if (state.ptrs[i]->reorder_fn != NULL
666 || note_ptr_fn != NULL)
667 memcpy (dest: state.ptrs[i]->obj, src: this_object, n: state.ptrs[i]->size);
668#if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
669 if (UNLIKELY (get_vbits == 1))
670 {
671 (void) VALGRIND_SET_VBITS (state.ptrs[i]->obj, vbits.address (),
672 valid_size);
673 if (valid_size != state.ptrs[i]->size)
674 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *)
675 state.ptrs[i]->obj
676 + valid_size,
677 state.ptrs[i]->size
678 - valid_size));
679 }
680#endif
681 }
682#if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
683 vbits.release ();
684#endif
685
686 reloc_addrs_vec.qsort (compare_ptr);
687
688 size_t reloc_addrs_size = 0;
689 void *last_addr = NULL;
690 unsigned char uleb128_buf[sizeof (size_t) * 2];
691 for (void *addr : reloc_addrs_vec)
692 {
693 gcc_assert ((uintptr_t) addr >= (uintptr_t) mmi.preferred_base
694 && ((uintptr_t) addr + sizeof (void *)
695 < (uintptr_t) mmi.preferred_base + mmi.size));
696 if (addr == last_addr)
697 continue;
698 if (last_addr == NULL)
699 last_addr = mmi.preferred_base;
700 size_t diff = (uintptr_t) addr - (uintptr_t) last_addr;
701 reloc_addrs_size += write_uleb128 (p: uleb128_buf, val: diff);
702 last_addr = addr;
703 }
704 if (fwrite (ptr: &reloc_addrs_size, size: sizeof (reloc_addrs_size), n: 1, s: f) != 1)
705 fatal_error (input_location, "cannot write PCH file: %m");
706 last_addr = NULL;
707 for (void *addr : reloc_addrs_vec)
708 {
709 if (addr == last_addr)
710 continue;
711 if (last_addr == NULL)
712 last_addr = mmi.preferred_base;
713 size_t diff = (uintptr_t) addr - (uintptr_t) last_addr;
714 reloc_addrs_size = write_uleb128 (p: uleb128_buf, val: diff);
715 if (fwrite (ptr: uleb128_buf, size: 1, n: reloc_addrs_size, s: f) != reloc_addrs_size)
716 fatal_error (input_location, "cannot write PCH file: %m");
717 last_addr = addr;
718 }
719
720 ggc_pch_finish (state.d, state.f);
721
722 gt_pch_fixup_stringpool ();
723
724 unsigned num_callbacks = callback_vec.length ();
725 void (*pch_save) (FILE *) = &gt_pch_save;
726 if (fwrite (ptr: &pch_save, size: sizeof (pch_save), n: 1, s: f) != 1
727 || fwrite (ptr: &num_callbacks, size: sizeof (num_callbacks), n: 1, s: f) != 1
728 || (num_callbacks
729 && fwrite (ptr: callback_vec.address (), size: sizeof (void *), n: num_callbacks,
730 s: f) != num_callbacks))
731 fatal_error (input_location, "cannot write PCH file: %m");
732
733 XDELETE (state.ptrs);
734 XDELETE (this_object);
735 delete saving_htab;
736 saving_htab = NULL;
737 callback_vec.release ();
738 reloc_addrs_vec.release ();
739}
740
741/* Read the state of the compiler back in from F. */
742
743void
744gt_pch_restore (FILE *f)
745{
746 const struct ggc_root_tab *const *rt;
747 const struct ggc_root_tab *rti;
748 size_t i;
749 struct mmap_info mmi;
750 int result;
751
752 /* We are about to reload the line maps along with the rest of the PCH
753 data, which means that the (loaded) ones cannot be guaranteed to be
754 in any valid state for reporting diagnostics that happen during the
755 load. Save the current table (and use it during the loading process
756 below). */
757 class line_maps *save_line_table = line_table;
758
759 /* Delete any deletable objects. This makes ggc_pch_read much
760 faster, as it can be sure that no GCable objects remain other
761 than the ones just read in. */
762 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
763 for (rti = *rt; rti->base != NULL; rti++)
764 memset (s: rti->base, c: 0, n: rti->stride);
765
766 /* Read in all the scalar variables. */
767 for (rt = gt_pch_scalar_rtab; *rt; rt++)
768 for (rti = *rt; rti->base != NULL; rti++)
769 if (fread (ptr: rti->base, size: rti->stride, n: 1, stream: f) != 1)
770 fatal_error (input_location, "cannot read PCH file: %m");
771
772 /* Read in all the global pointers, in 6 easy loops. */
773 bool error_reading_pointers = false;
774 for (rt = gt_ggc_rtab; *rt; rt++)
775 for (rti = *rt; rti->base != NULL; rti++)
776 for (i = 0; i < rti->nelt; i++)
777 if (fread (ptr: (char *)rti->base + rti->stride * i,
778 size: sizeof (void *), n: 1, stream: f) != 1)
779 error_reading_pointers = true;
780
781 /* Stash the newly read-in line table pointer - it does not point to
782 anything meaningful yet, so swap the old one back in. */
783 class line_maps *new_line_table = line_table;
784 line_table = save_line_table;
785 if (error_reading_pointers)
786 fatal_error (input_location, "cannot read PCH file: %m");
787
788 if (fread (ptr: &mmi, size: sizeof (mmi), n: 1, stream: f) != 1)
789 fatal_error (input_location, "cannot read PCH file: %m");
790
791 void *orig_preferred_base = mmi.preferred_base;
792 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
793 fileno (f), mmi.offset);
794
795 /* We could not mmap or otherwise allocate the required memory at the
796 address needed. */
797 if (result < 0)
798 {
799 sorry_at (input_location, "PCH allocation failure");
800 /* There is no point in continuing from here, we will only end up
801 with a crashed (most likely hanging) compiler. */
802 exit (status: -1);
803 }
804
805 /* (0) We allocated memory, but did not mmap the file, so we need to read
806 the data in manually. (>0) Otherwise the mmap succeed for the address
807 we wanted. */
808 if (result == 0)
809 {
810 if (fseek (stream: f, off: mmi.offset, SEEK_SET) != 0
811 || fread (ptr: mmi.preferred_base, size: mmi.size, n: 1, stream: f) != 1)
812 fatal_error (input_location, "cannot read PCH file: %m");
813 }
814 else if (fseek (stream: f, off: mmi.offset + mmi.size, SEEK_SET) != 0)
815 fatal_error (input_location, "cannot read PCH file: %m");
816
817 size_t reloc_addrs_size;
818 if (fread (ptr: &reloc_addrs_size, size: sizeof (reloc_addrs_size), n: 1, stream: f) != 1)
819 fatal_error (input_location, "cannot read PCH file: %m");
820
821 if (orig_preferred_base != mmi.preferred_base)
822 {
823 uintptr_t bias
824 = (uintptr_t) mmi.preferred_base - (uintptr_t) orig_preferred_base;
825
826 /* Adjust all the global pointers by bias. */
827 line_table = new_line_table;
828 for (rt = gt_ggc_rtab; *rt; rt++)
829 for (rti = *rt; rti->base != NULL; rti++)
830 for (i = 0; i < rti->nelt; i++)
831 {
832 char *addr = (char *)rti->base + rti->stride * i;
833 char *p;
834 memcpy (dest: &p, src: addr, n: sizeof (void *));
835 if ((uintptr_t) p >= (uintptr_t) orig_preferred_base
836 && (uintptr_t) p < (uintptr_t) orig_preferred_base + mmi.size)
837 {
838 p = (char *) ((uintptr_t) p + bias);
839 memcpy (dest: addr, src: &p, n: sizeof (void *));
840 }
841 }
842 new_line_table = line_table;
843 line_table = save_line_table;
844
845 /* And adjust all the pointers in the image by bias too. */
846 char *addr = (char *) mmi.preferred_base;
847 unsigned char uleb128_buf[4096], *uleb128_ptr = uleb128_buf;
848 while (reloc_addrs_size != 0)
849 {
850 size_t this_size
851 = MIN (reloc_addrs_size,
852 (size_t) (4096 - (uleb128_ptr - uleb128_buf)));
853 if (fread (ptr: uleb128_ptr, size: 1, n: this_size, stream: f) != this_size)
854 fatal_error (input_location, "cannot read PCH file: %m");
855 unsigned char *uleb128_end = uleb128_ptr + this_size;
856 if (this_size != reloc_addrs_size)
857 uleb128_end -= 2 * sizeof (size_t);
858 uleb128_ptr = uleb128_buf;
859 while (uleb128_ptr < uleb128_end)
860 {
861 size_t diff;
862 uleb128_ptr = read_uleb128 (p: uleb128_ptr, val: &diff);
863 addr = (char *) ((uintptr_t) addr + diff);
864
865 char *p;
866 memcpy (dest: &p, src: addr, n: sizeof (void *));
867 gcc_assert ((uintptr_t) p >= (uintptr_t) orig_preferred_base
868 && ((uintptr_t) p
869 < (uintptr_t) orig_preferred_base + mmi.size));
870 p = (char *) ((uintptr_t) p + bias);
871 memcpy (dest: addr, src: &p, n: sizeof (void *));
872 }
873 reloc_addrs_size -= this_size;
874 if (reloc_addrs_size == 0)
875 break;
876 this_size = uleb128_end + 2 * sizeof (size_t) - uleb128_ptr;
877 memcpy (dest: uleb128_buf, src: uleb128_ptr, n: this_size);
878 uleb128_ptr = uleb128_buf + this_size;
879 }
880 }
881 else if (fseek (stream: f, off: (mmi.offset + mmi.size + sizeof (reloc_addrs_size)
882 + reloc_addrs_size), SEEK_SET) != 0)
883 fatal_error (input_location, "cannot read PCH file: %m");
884
885 ggc_pch_read (f, mmi.preferred_base);
886
887 void (*pch_save) (FILE *);
888 unsigned num_callbacks;
889 if (fread (ptr: &pch_save, size: sizeof (pch_save), n: 1, stream: f) != 1
890 || fread (ptr: &num_callbacks, size: sizeof (num_callbacks), n: 1, stream: f) != 1)
891 fatal_error (input_location, "cannot read PCH file: %m");
892 if (pch_save != &gt_pch_save)
893 {
894 uintptr_t binbias = (uintptr_t) &gt_pch_save - (uintptr_t) pch_save;
895 void **ptrs = XNEWVEC (void *, num_callbacks);
896 unsigned i;
897 uintptr_t bias
898 = (uintptr_t) mmi.preferred_base - (uintptr_t) orig_preferred_base;
899
900 if (fread (ptr: ptrs, size: sizeof (void *), n: num_callbacks, stream: f) != num_callbacks)
901 fatal_error (input_location, "cannot read PCH file: %m");
902 for (i = 0; i < num_callbacks; ++i)
903 {
904 void *ptr = (void *) ((uintptr_t) ptrs[i] + bias);
905 memcpy (dest: &pch_save, src: ptr, n: sizeof (pch_save));
906 pch_save = (void (*) (FILE *)) ((uintptr_t) pch_save + binbias);
907 memcpy (dest: ptr, src: &pch_save, n: sizeof (pch_save));
908 }
909 XDELETE (ptrs);
910 }
911 else if (fseek (stream: f, off: num_callbacks * sizeof (void *), SEEK_CUR) != 0)
912 fatal_error (input_location, "cannot read PCH file: %m");
913
914 gt_pch_restore_stringpool ();
915
916 /* Barring corruption of the PCH file, the restored line table should be
917 complete and usable. */
918 line_table = new_line_table;
919}
920
921/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
922 Select no address whatsoever, and let gt_pch_save choose what it will with
923 malloc, presumably. */
924
925void *
926default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
927 int fd ATTRIBUTE_UNUSED)
928{
929 return NULL;
930}
931
932/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
933 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
934 same as base, indicating that the memory has been allocated but needs to
935 be read in from the file. Return -1 if the address differs, to relocation
936 of the PCH file would be required. */
937
938int
939default_gt_pch_use_address (void *&base, size_t size, int fd ATTRIBUTE_UNUSED,
940 size_t offset ATTRIBUTE_UNUSED)
941{
942 void *addr = xmalloc (size);
943 return (addr == base) - 1;
944}
945
946/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
947 alignment required for allocating virtual memory. Usually this is the
948 same as pagesize. */
949
950size_t
951default_gt_pch_alloc_granularity (void)
952{
953 return getpagesize ();
954}
955
956#if HAVE_MMAP_FILE
957/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
958 We temporarily allocate SIZE bytes, and let the kernel place the data
959 wherever it will. If it worked, that's our spot, if not we're likely
960 to be in trouble. */
961
962void *
963mmap_gt_pch_get_address (size_t size, int fd)
964{
965 void *ret;
966
967 ret = mmap (NULL, len: size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd: fd, offset: 0);
968 if (ret == (void *) MAP_FAILED)
969 ret = NULL;
970 else
971 munmap (addr: (caddr_t) ret, len: size);
972
973 return ret;
974}
975
976/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
977 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
978 mapping the data at BASE, -1 if we couldn't.
979
980 This version assumes that the kernel honors the START operand of mmap
981 even without MAP_FIXED if START through START+SIZE are not currently
982 mapped with something. */
983
984int
985mmap_gt_pch_use_address (void *&base, size_t size, int fd, size_t offset)
986{
987 void *addr;
988
989 /* We're called with size == 0 if we're not planning to load a PCH
990 file at all. This allows the hook to free any static space that
991 we might have allocated at link time. */
992 if (size == 0)
993 return -1;
994
995 addr = mmap (addr: (caddr_t) base, len: size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
996 fd: fd, offset: offset);
997
998 return addr == base ? 1 : -1;
999}
1000#endif /* HAVE_MMAP_FILE */
1001
1002#if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
1003
1004/* Modify the bound based on rlimits. */
1005static double
1006ggc_rlimit_bound (double limit)
1007{
1008#if defined(HAVE_GETRLIMIT)
1009 struct rlimit rlim;
1010# if defined (RLIMIT_AS)
1011 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
1012 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
1013 if (getrlimit (RLIMIT_AS, &rlim) == 0
1014 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
1015 && rlim.rlim_cur < limit)
1016 limit = rlim.rlim_cur;
1017# elif defined (RLIMIT_DATA)
1018 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
1019 might be on an OS that has a broken mmap. (Others don't bound
1020 mmap at all, apparently.) */
1021 if (getrlimit (RLIMIT_DATA, &rlim) == 0
1022 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
1023 && rlim.rlim_cur < limit
1024 /* Darwin has this horribly bogus default setting of
1025 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
1026 appears to be ignored. Ignore such silliness. If a limit
1027 this small was actually effective for mmap, GCC wouldn't even
1028 start up. */
1029 && rlim.rlim_cur >= 8 * ONE_M)
1030 limit = rlim.rlim_cur;
1031# endif /* RLIMIT_AS or RLIMIT_DATA */
1032#endif /* HAVE_GETRLIMIT */
1033
1034 return limit;
1035}
1036
1037/* Heuristic to set a default for GGC_MIN_EXPAND. */
1038static int
1039ggc_min_expand_heuristic (void)
1040{
1041 double min_expand = physmem_total ();
1042
1043 /* Adjust for rlimits. */
1044 min_expand = ggc_rlimit_bound (min_expand);
1045
1046 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
1047 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
1048 min_expand /= ONE_G;
1049 min_expand *= 70;
1050 min_expand = MIN (min_expand, 70);
1051 min_expand += 30;
1052
1053 return min_expand;
1054}
1055
1056/* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
1057static int
1058ggc_min_heapsize_heuristic (void)
1059{
1060 double phys_kbytes = physmem_total ();
1061 double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
1062
1063 phys_kbytes /= ONE_K; /* Convert to Kbytes. */
1064 limit_kbytes /= ONE_K;
1065
1066 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
1067 bound of 128M (when RAM >= 1GB). */
1068 phys_kbytes /= 8;
1069
1070#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
1071 /* Try not to overrun the RSS limit while doing garbage collection.
1072 The RSS limit is only advisory, so no margin is subtracted. */
1073 {
1074 struct rlimit rlim;
1075 if (getrlimit (RLIMIT_RSS, &rlim) == 0
1076 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
1077 phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / ONE_K);
1078 }
1079# endif
1080
1081 /* Don't blindly run over our data limit; do GC at least when the
1082 *next* GC would be within 20Mb of the limit or within a quarter of
1083 the limit, whichever is larger. If GCC does hit the data limit,
1084 compilation will fail, so this tries to be conservative. */
1085 limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * ONE_K));
1086 limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic ());
1087 phys_kbytes = MIN (phys_kbytes, limit_kbytes);
1088
1089 phys_kbytes = MAX (phys_kbytes, 4 * ONE_K);
1090 phys_kbytes = MIN (phys_kbytes, 128 * ONE_K);
1091
1092 return phys_kbytes;
1093}
1094#endif
1095
1096void
1097init_ggc_heuristics (void)
1098{
1099#if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
1100 param_ggc_min_expand = ggc_min_expand_heuristic ();
1101 param_ggc_min_heapsize = ggc_min_heapsize_heuristic ();
1102#endif
1103}
1104
1105/* GGC memory usage. */
1106class ggc_usage: public mem_usage
1107{
1108public:
1109 /* Default constructor. */
1110 ggc_usage (): m_freed (0), m_collected (0), m_overhead (0) {}
1111 /* Constructor. */
1112 ggc_usage (size_t allocated, size_t times, size_t peak,
1113 size_t freed, size_t collected, size_t overhead)
1114 : mem_usage (allocated, times, peak),
1115 m_freed (freed), m_collected (collected), m_overhead (overhead) {}
1116
1117 /* Equality operator. */
1118 inline bool
1119 operator== (const ggc_usage &second) const
1120 {
1121 return (get_balance () == second.get_balance ()
1122 && m_peak == second.m_peak
1123 && m_times == second.m_times);
1124 }
1125
1126 /* Comparison operator. */
1127 inline bool
1128 operator< (const ggc_usage &second) const
1129 {
1130 if (*this == second)
1131 return false;
1132
1133 return (get_balance () == second.get_balance () ?
1134 (m_peak == second.m_peak ? m_times < second.m_times
1135 : m_peak < second.m_peak)
1136 : get_balance () < second.get_balance ());
1137 }
1138
1139 /* Register overhead of ALLOCATED and OVERHEAD bytes. */
1140 inline void
1141 register_overhead (size_t allocated, size_t overhead)
1142 {
1143 m_allocated += allocated;
1144 m_overhead += overhead;
1145 m_times++;
1146 }
1147
1148 /* Release overhead of SIZE bytes. */
1149 inline void
1150 release_overhead (size_t size)
1151 {
1152 m_freed += size;
1153 }
1154
1155 /* Sum the usage with SECOND usage. */
1156 ggc_usage
1157 operator+ (const ggc_usage &second)
1158 {
1159 return ggc_usage (m_allocated + second.m_allocated,
1160 m_times + second.m_times,
1161 m_peak + second.m_peak,
1162 m_freed + second.m_freed,
1163 m_collected + second.m_collected,
1164 m_overhead + second.m_overhead);
1165 }
1166
1167 /* Dump usage with PREFIX, where TOTAL is sum of all rows. */
1168 inline void
1169 dump (const char *prefix, ggc_usage &total) const
1170 {
1171 size_t balance = get_balance ();
1172 fprintf (stderr,
1173 format: "%-48s " PRsa (9) ":%5.1f%%" PRsa (9) ":%5.1f%%"
1174 PRsa (9) ":%5.1f%%" PRsa (9) ":%5.1f%%" PRsa (9) "\n",
1175 prefix,
1176 SIZE_AMOUNT (balance), get_percent (nominator: balance, denominator: total.get_balance ()),
1177 SIZE_AMOUNT (m_collected),
1178 get_percent (nominator: m_collected, denominator: total.m_collected),
1179 SIZE_AMOUNT (m_freed), get_percent (nominator: m_freed, denominator: total.m_freed),
1180 SIZE_AMOUNT (m_overhead),
1181 get_percent (nominator: m_overhead, denominator: total.m_overhead),
1182 SIZE_AMOUNT (m_times));
1183 }
1184
1185 /* Dump usage coupled to LOC location, where TOTAL is sum of all rows. */
1186 inline void
1187 dump (mem_location *loc, ggc_usage &total) const
1188 {
1189 char *location_string = loc->to_string ();
1190
1191 dump (prefix: location_string, total);
1192
1193 free (ptr: location_string);
1194 }
1195
1196 /* Dump footer. */
1197 inline void
1198 dump_footer ()
1199 {
1200 dump (prefix: "Total", total&: *this);
1201 }
1202
1203 /* Get balance which is GGC allocation leak. */
1204 inline size_t
1205 get_balance () const
1206 {
1207 return m_allocated + m_overhead - m_collected - m_freed;
1208 }
1209
1210 typedef std::pair<mem_location *, ggc_usage *> mem_pair_t;
1211
1212 /* Compare wrapper used by qsort method. */
1213 static int
1214 compare (const void *first, const void *second)
1215 {
1216 const mem_pair_t mem1 = *(const mem_pair_t *) first;
1217 const mem_pair_t mem2 = *(const mem_pair_t *) second;
1218
1219 size_t balance1 = mem1.second->get_balance ();
1220 size_t balance2 = mem2.second->get_balance ();
1221
1222 return balance1 == balance2 ? 0 : (balance1 < balance2 ? 1 : -1);
1223 }
1224
1225 /* Dump header with NAME. */
1226 static inline void
1227 dump_header (const char *name)
1228 {
1229 fprintf (stderr, format: "%-48s %11s%17s%17s%16s%17s\n", name, "Leak", "Garbage",
1230 "Freed", "Overhead", "Times");
1231 }
1232
1233 /* Freed memory in bytes. */
1234 size_t m_freed;
1235 /* Collected memory in bytes. */
1236 size_t m_collected;
1237 /* Overhead memory in bytes. */
1238 size_t m_overhead;
1239};
1240
1241/* GCC memory description. */
1242static mem_alloc_description<ggc_usage> ggc_mem_desc;
1243
1244/* Dump per-site memory statistics. */
1245
1246void
1247dump_ggc_loc_statistics ()
1248{
1249 if (! GATHER_STATISTICS)
1250 return;
1251
1252 ggc_collect (mode: GGC_COLLECT_FORCE);
1253
1254 ggc_mem_desc.dump (origin: GGC_ORIGIN);
1255}
1256
1257/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
1258void
1259ggc_record_overhead (size_t allocated, size_t overhead, void *ptr MEM_STAT_DECL)
1260{
1261 ggc_usage *usage = ggc_mem_desc.register_descriptor (ptr, origin: GGC_ORIGIN, ggc: false
1262 FINAL_PASS_MEM_STAT);
1263
1264 ggc_mem_desc.register_object_overhead (usage, size: allocated + overhead, ptr);
1265 usage->register_overhead (allocated, overhead);
1266}
1267
1268/* Notice that the pointer has been freed. */
1269void
1270ggc_free_overhead (void *ptr)
1271{
1272 ggc_mem_desc.release_object_overhead (ptr);
1273}
1274
1275/* After live values has been marked, walk all recorded pointers and see if
1276 they are still live. */
1277void
1278ggc_prune_overhead_list (void)
1279{
1280 typedef hash_map<const void *, std::pair<ggc_usage *, size_t > > map_t;
1281
1282 map_t::iterator it = ggc_mem_desc.m_reverse_object_map->begin ();
1283
1284 for (; it != ggc_mem_desc.m_reverse_object_map->end (); ++it)
1285 if (!ggc_marked_p ((*it).first))
1286 {
1287 (*it).second.first->m_collected += (*it).second.second;
1288 ggc_mem_desc.m_reverse_object_map->remove (k: (*it).first);
1289 }
1290}
1291
1292/* Print memory used by heap if this info is available. */
1293
1294void
1295report_heap_memory_use ()
1296{
1297#if defined(HAVE_MALLINFO) || defined(HAVE_MALLINFO2)
1298#ifdef HAVE_MALLINFO2
1299 #define MALLINFO_FN mallinfo2
1300#else
1301 #define MALLINFO_FN mallinfo
1302#endif
1303 if (!quiet_flag)
1304 fprintf (stderr, format: " {heap " PRsa (0) "}",
1305 SIZE_AMOUNT (MALLINFO_FN ().arena));
1306#endif
1307}
1308
1309/* Forcibly clear all GTY roots. */
1310
1311void
1312ggc_common_finalize ()
1313{
1314 const struct ggc_root_tab *const *rt;
1315 const_ggc_root_tab_t rti;
1316
1317 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
1318 for (rti = *rt; rti->base != NULL; rti++)
1319 memset (s: rti->base, c: 0, n: rti->stride * rti->nelt);
1320
1321 for (rt = gt_ggc_rtab; *rt; rt++)
1322 ggc_zero_rtab_roots (rt: *rt);
1323
1324 for (rt = gt_pch_scalar_rtab; *rt; rt++)
1325 for (rti = *rt; rti->base != NULL; rti++)
1326 memset (s: rti->base, c: 0, n: rti->stride * rti->nelt);
1327}
1328

source code of gcc/ggc-common.cc