1 /* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* Generic garbage collection (GC) functions and data, not specific to
22 any particular GC implementation. */
26 #include "coretypes.h"
29 #include "ggc-internal.h"
32 #include "hosthooks.h"
33 #include "hosthooks-def.h"
38 #ifdef HAVE_SYS_RESOURCE_H
39 # include <sys/resource.h>
43 # include <sys/mman.h>
45 /* This is on Solaris. */
46 # include <sys/types.h>
51 # define MAP_FAILED ((void *)-1)
54 /* When set, ggc_collect will do collection. */
55 bool ggc_force_collect
;
57 /* When true, protect the contents of the identifier hash table. */
58 bool ggc_protect_identifiers
= true;
60 /* Statistics about the allocation. */
61 static ggc_statistics
*ggc_stats
;
63 struct traversal_state
;
65 static int ggc_htab_delete (void **, void *);
66 static hashval_t
saving_htab_hash (const void *);
67 static int saving_htab_eq (const void *, const void *);
68 static int call_count (void **, void *);
69 static int call_alloc (void **, void *);
70 static int compare_ptr_data (const void *, const void *);
71 static void relocate_ptrs (void *, void *);
72 static void write_pch_globals (const struct ggc_root_tab
* const *tab
,
73 struct traversal_state
*state
);
75 /* Maintain global roots that are preserved during GC. */
77 /* Process a slot of an htab by deleting it if it has not been marked. */
80 ggc_htab_delete (void **slot
, void *info
)
82 const struct ggc_cache_tab
*r
= (const struct ggc_cache_tab
*) info
;
84 if (! (*r
->marked_p
) (*slot
))
85 htab_clear_slot (*r
->base
, slot
);
93 /* This extra vector of dynamically registered root_tab-s is used by
94 ggc_mark_roots and gives the ability to dynamically add new GGC root
95 tables, for instance from some plugins; this vector is on the heap
96 since it is used by GGC internally. */
97 typedef const struct ggc_root_tab
*const_ggc_root_tab_t
;
98 DEF_VEC_P(const_ggc_root_tab_t
);
99 DEF_VEC_ALLOC_P(const_ggc_root_tab_t
, heap
);
100 static VEC(const_ggc_root_tab_t
, heap
) *extra_root_vec
;
102 /* Dynamically register a new GGC root table RT. This is useful for
106 ggc_register_root_tab (const struct ggc_root_tab
* rt
)
109 VEC_safe_push (const_ggc_root_tab_t
, heap
, extra_root_vec
, rt
);
112 /* This extra vector of dynamically registered cache_tab-s is used by
113 ggc_mark_roots and gives the ability to dynamically add new GGC cache
114 tables, for instance from some plugins; this vector is on the heap
115 since it is used by GGC internally. */
116 typedef const struct ggc_cache_tab
*const_ggc_cache_tab_t
;
117 DEF_VEC_P(const_ggc_cache_tab_t
);
118 DEF_VEC_ALLOC_P(const_ggc_cache_tab_t
, heap
);
119 static VEC(const_ggc_cache_tab_t
, heap
) *extra_cache_vec
;
121 /* Dynamically register a new GGC cache table CT. This is useful for
125 ggc_register_cache_tab (const struct ggc_cache_tab
* ct
)
128 VEC_safe_push (const_ggc_cache_tab_t
, heap
, extra_cache_vec
, ct
);
131 /* Scan a hash table that has objects which are to be deleted if they are not
135 ggc_scan_cache_tab (const_ggc_cache_tab_t ctp
)
137 const struct ggc_cache_tab
*cti
;
139 for (cti
= ctp
; cti
->base
!= NULL
; cti
++)
142 ggc_set_mark (*cti
->base
);
143 htab_traverse_noresize (*cti
->base
, ggc_htab_delete
,
144 CONST_CAST (void *, (const void *)cti
));
145 ggc_set_mark ((*cti
->base
)->entries
);
149 /* Iterate through all registered roots and mark each element. */
152 ggc_mark_roots (void)
154 const struct ggc_root_tab
*const *rt
;
155 const struct ggc_root_tab
*rti
;
156 const_ggc_root_tab_t rtp
;
157 const struct ggc_cache_tab
*const *ct
;
158 const_ggc_cache_tab_t ctp
;
161 for (rt
= gt_ggc_deletable_rtab
; *rt
; rt
++)
162 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
163 memset (rti
->base
, 0, rti
->stride
);
165 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
166 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
167 for (i
= 0; i
< rti
->nelt
; i
++)
168 (*rti
->cb
) (*(void **)((char *)rti
->base
+ rti
->stride
* i
));
170 for (i
= 0; VEC_iterate (const_ggc_root_tab_t
, extra_root_vec
, i
, rtp
); i
++)
172 for (rti
= rtp
; rti
->base
!= NULL
; rti
++)
173 for (i
= 0; i
< rti
->nelt
; i
++)
174 (*rti
->cb
) (*(void **) ((char *)rti
->base
+ rti
->stride
* i
));
177 if (ggc_protect_identifiers
)
178 ggc_mark_stringpool ();
180 /* Now scan all hash tables that have objects which are to be deleted if
181 they are not already marked. */
182 for (ct
= gt_ggc_cache_rtab
; *ct
; ct
++)
183 ggc_scan_cache_tab (*ct
);
185 for (i
= 0; VEC_iterate (const_ggc_cache_tab_t
, extra_cache_vec
, i
, ctp
); i
++)
186 ggc_scan_cache_tab (ctp
);
188 if (! ggc_protect_identifiers
)
189 ggc_purge_stringpool ();
191 /* Some plugins may call ggc_set_mark from here. */
192 invoke_plugin_callbacks (PLUGIN_GGC_MARKING
, NULL
);
195 /* Allocate a block of memory, then clear it. */
197 ggc_internal_cleared_alloc_stat (size_t size MEM_STAT_DECL
)
199 void *buf
= ggc_internal_alloc_stat (size PASS_MEM_STAT
);
200 memset (buf
, 0, size
);
204 /* Resize a block of memory, possibly re-allocating it. */
206 ggc_realloc_stat (void *x
, size_t size MEM_STAT_DECL
)
212 return ggc_internal_alloc_stat (size PASS_MEM_STAT
);
214 old_size
= ggc_get_size (x
);
216 if (size
<= old_size
)
218 /* Mark the unwanted memory as unaccessible. We also need to make
219 the "new" size accessible, since ggc_get_size returns the size of
220 the pool, not the size of the individually allocated object, the
221 size which was previously made accessible. Unfortunately, we
222 don't know that previously allocated size. Without that
223 knowledge we have to lose some initialization-tracking for the
224 old parts of the object. An alternative is to mark the whole
225 old_size as reachable, but that would lose tracking of writes
226 after the end of the object (by small offsets). Discard the
227 handle to avoid handle leak. */
228 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x
+ size
,
230 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x
, size
));
234 r
= ggc_internal_alloc_stat (size PASS_MEM_STAT
);
236 /* Since ggc_get_size returns the size of the pool, not the size of the
237 individually allocated object, we'd access parts of the old object
238 that were marked invalid with the memcpy below. We lose a bit of the
239 initialization-tracking since some of it may be uninitialized. */
240 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x
, old_size
));
242 memcpy (r
, x
, old_size
);
244 /* The old object is not supposed to be used anymore. */
251 ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED
,
252 size_t n ATTRIBUTE_UNUSED
)
254 gcc_assert (c
* n
== sizeof (struct htab
));
255 return ggc_alloc_cleared_htab ();
258 /* TODO: once we actually use type information in GGC, create a new tag
259 gt_gcc_ptr_array and use it for pointer arrays. */
261 ggc_cleared_alloc_ptr_array_two_args (size_t c
, size_t n
)
263 gcc_assert (sizeof (PTR
*) == n
);
264 return ggc_internal_cleared_vec_alloc (sizeof (PTR
*), c
);
267 /* These are for splay_tree_new_ggc. */
269 ggc_splay_alloc (enum gt_types_enum obj_type ATTRIBUTE_UNUSED
, int sz
,
273 return ggc_internal_alloc (sz
);
277 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED
, void *nl
)
282 /* Print statistics that are independent of the collector in use. */
283 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
285 : ((x) < 1024*1024*10 \
287 : (x) / (1024*1024))))
288 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
291 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED
,
292 ggc_statistics
*stats
)
294 /* Set the pointer so that during collection we will actually gather
298 /* Then do one collection to fill in the statistics. */
301 /* At present, we don't really gather any interesting statistics. */
303 /* Don't gather statistics any more. */
307 /* Functions for saving and restoring GCable memory to disk. */
309 static htab_t saving_htab
;
314 void *note_ptr_cookie
;
315 gt_note_pointers note_ptr_fn
;
316 gt_handle_reorder reorder_fn
;
319 enum gt_types_enum type
;
322 #define POINTER_HASH(x) (hashval_t)((long)x >> 3)
324 /* Register an object in the hash table. */
327 gt_pch_note_object (void *obj
, void *note_ptr_cookie
,
328 gt_note_pointers note_ptr_fn
,
329 enum gt_types_enum type
)
331 struct ptr_data
**slot
;
333 if (obj
== NULL
|| obj
== (void *) 1)
336 slot
= (struct ptr_data
**)
337 htab_find_slot_with_hash (saving_htab
, obj
, POINTER_HASH (obj
),
341 gcc_assert ((*slot
)->note_ptr_fn
== note_ptr_fn
342 && (*slot
)->note_ptr_cookie
== note_ptr_cookie
);
346 *slot
= XCNEW (struct ptr_data
);
348 (*slot
)->note_ptr_fn
= note_ptr_fn
;
349 (*slot
)->note_ptr_cookie
= note_ptr_cookie
;
350 if (note_ptr_fn
== gt_pch_p_S
)
351 (*slot
)->size
= strlen ((const char *)obj
) + 1;
353 (*slot
)->size
= ggc_get_size (obj
);
354 (*slot
)->type
= type
;
358 /* Register an object in the hash table. */
361 gt_pch_note_reorder (void *obj
, void *note_ptr_cookie
,
362 gt_handle_reorder reorder_fn
)
364 struct ptr_data
*data
;
366 if (obj
== NULL
|| obj
== (void *) 1)
369 data
= (struct ptr_data
*)
370 htab_find_with_hash (saving_htab
, obj
, POINTER_HASH (obj
));
371 gcc_assert (data
&& data
->note_ptr_cookie
== note_ptr_cookie
);
373 data
->reorder_fn
= reorder_fn
;
376 /* Hash and equality functions for saving_htab, callbacks for htab_create. */
379 saving_htab_hash (const void *p
)
381 return POINTER_HASH (((const struct ptr_data
*)p
)->obj
);
385 saving_htab_eq (const void *p1
, const void *p2
)
387 return ((const struct ptr_data
*)p1
)->obj
== p2
;
390 /* Handy state for the traversal functions. */
392 struct traversal_state
395 struct ggc_pch_data
*d
;
397 struct ptr_data
**ptrs
;
401 /* Callbacks for htab_traverse. */
404 call_count (void **slot
, void *state_p
)
406 struct ptr_data
*d
= (struct ptr_data
*)*slot
;
407 struct traversal_state
*state
= (struct traversal_state
*)state_p
;
409 ggc_pch_count_object (state
->d
, d
->obj
, d
->size
,
410 d
->note_ptr_fn
== gt_pch_p_S
,
417 call_alloc (void **slot
, void *state_p
)
419 struct ptr_data
*d
= (struct ptr_data
*)*slot
;
420 struct traversal_state
*state
= (struct traversal_state
*)state_p
;
422 d
->new_addr
= ggc_pch_alloc_object (state
->d
, d
->obj
, d
->size
,
423 d
->note_ptr_fn
== gt_pch_p_S
,
425 state
->ptrs
[state
->ptrs_i
++] = d
;
429 /* Callback for qsort. */
432 compare_ptr_data (const void *p1_p
, const void *p2_p
)
434 const struct ptr_data
*const p1
= *(const struct ptr_data
*const *)p1_p
;
435 const struct ptr_data
*const p2
= *(const struct ptr_data
*const *)p2_p
;
436 return (((size_t)p1
->new_addr
> (size_t)p2
->new_addr
)
437 - ((size_t)p1
->new_addr
< (size_t)p2
->new_addr
));
440 /* Callbacks for note_ptr_fn. */
443 relocate_ptrs (void *ptr_p
, void *state_p
)
445 void **ptr
= (void **)ptr_p
;
446 struct traversal_state
*state ATTRIBUTE_UNUSED
447 = (struct traversal_state
*)state_p
;
448 struct ptr_data
*result
;
450 if (*ptr
== NULL
|| *ptr
== (void *)1)
453 result
= (struct ptr_data
*)
454 htab_find_with_hash (saving_htab
, *ptr
, POINTER_HASH (*ptr
));
456 *ptr
= result
->new_addr
;
459 /* Write out, after relocation, the pointers in TAB. */
461 write_pch_globals (const struct ggc_root_tab
* const *tab
,
462 struct traversal_state
*state
)
464 const struct ggc_root_tab
*const *rt
;
465 const struct ggc_root_tab
*rti
;
468 for (rt
= tab
; *rt
; rt
++)
469 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
470 for (i
= 0; i
< rti
->nelt
; i
++)
472 void *ptr
= *(void **)((char *)rti
->base
+ rti
->stride
* i
);
473 struct ptr_data
*new_ptr
;
474 if (ptr
== NULL
|| ptr
== (void *)1)
476 if (fwrite (&ptr
, sizeof (void *), 1, state
->f
)
478 fatal_error ("can't write PCH file: %m");
482 new_ptr
= (struct ptr_data
*)
483 htab_find_with_hash (saving_htab
, ptr
, POINTER_HASH (ptr
));
484 if (fwrite (&new_ptr
->new_addr
, sizeof (void *), 1, state
->f
)
486 fatal_error ("can't write PCH file: %m");
491 /* Hold the information we need to mmap the file back in. */
497 void *preferred_base
;
500 /* Write out the state of the compiler to F. */
503 gt_pch_save (FILE *f
)
505 const struct ggc_root_tab
*const *rt
;
506 const struct ggc_root_tab
*rti
;
508 struct traversal_state state
;
509 char *this_object
= NULL
;
510 size_t this_object_size
= 0;
511 struct mmap_info mmi
;
512 const size_t mmap_offset_alignment
= host_hooks
.gt_pch_alloc_granularity();
514 gt_pch_save_stringpool ();
516 timevar_push (TV_PCH_PTR_REALLOC
);
517 saving_htab
= htab_create (50000, saving_htab_hash
, saving_htab_eq
, free
);
519 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
520 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
521 for (i
= 0; i
< rti
->nelt
; i
++)
522 (*rti
->pchw
)(*(void **)((char *)rti
->base
+ rti
->stride
* i
));
524 for (rt
= gt_pch_cache_rtab
; *rt
; rt
++)
525 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
526 for (i
= 0; i
< rti
->nelt
; i
++)
527 (*rti
->pchw
)(*(void **)((char *)rti
->base
+ rti
->stride
* i
));
529 /* Prepare the objects for writing, determine addresses and such. */
531 state
.d
= init_ggc_pch ();
533 htab_traverse (saving_htab
, call_count
, &state
);
535 mmi
.size
= ggc_pch_total_size (state
.d
);
537 /* Try to arrange things so that no relocation is necessary, but
538 don't try very hard. On most platforms, this will always work,
539 and on the rest it's a lot of work to do better.
540 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
541 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
542 mmi
.preferred_base
= host_hooks
.gt_pch_get_address (mmi
.size
, fileno (f
));
544 ggc_pch_this_base (state
.d
, mmi
.preferred_base
);
546 state
.ptrs
= XNEWVEC (struct ptr_data
*, state
.count
);
549 htab_traverse (saving_htab
, call_alloc
, &state
);
550 timevar_pop (TV_PCH_PTR_REALLOC
);
552 timevar_push (TV_PCH_PTR_SORT
);
553 qsort (state
.ptrs
, state
.count
, sizeof (*state
.ptrs
), compare_ptr_data
);
554 timevar_pop (TV_PCH_PTR_SORT
);
556 /* Write out all the scalar variables. */
557 for (rt
= gt_pch_scalar_rtab
; *rt
; rt
++)
558 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
559 if (fwrite (rti
->base
, rti
->stride
, 1, f
) != 1)
560 fatal_error ("can't write PCH file: %m");
562 /* Write out all the global pointers, after translation. */
563 write_pch_globals (gt_ggc_rtab
, &state
);
564 write_pch_globals (gt_pch_cache_rtab
, &state
);
566 /* Pad the PCH file so that the mmapped area starts on an allocation
567 granularity (usually page) boundary. */
570 o
= ftell (state
.f
) + sizeof (mmi
);
572 fatal_error ("can't get position in PCH file: %m");
573 mmi
.offset
= mmap_offset_alignment
- o
% mmap_offset_alignment
;
574 if (mmi
.offset
== mmap_offset_alignment
)
578 if (fwrite (&mmi
, sizeof (mmi
), 1, state
.f
) != 1)
579 fatal_error ("can't write PCH file: %m");
581 && fseek (state
.f
, mmi
.offset
, SEEK_SET
) != 0)
582 fatal_error ("can't write padding to PCH file: %m");
584 ggc_pch_prepare_write (state
.d
, state
.f
);
586 /* Actually write out the objects. */
587 for (i
= 0; i
< state
.count
; i
++)
589 if (this_object_size
< state
.ptrs
[i
]->size
)
591 this_object_size
= state
.ptrs
[i
]->size
;
592 this_object
= XRESIZEVAR (char, this_object
, this_object_size
);
594 memcpy (this_object
, state
.ptrs
[i
]->obj
, state
.ptrs
[i
]->size
);
595 if (state
.ptrs
[i
]->reorder_fn
!= NULL
)
596 state
.ptrs
[i
]->reorder_fn (state
.ptrs
[i
]->obj
,
597 state
.ptrs
[i
]->note_ptr_cookie
,
598 relocate_ptrs
, &state
);
599 state
.ptrs
[i
]->note_ptr_fn (state
.ptrs
[i
]->obj
,
600 state
.ptrs
[i
]->note_ptr_cookie
,
601 relocate_ptrs
, &state
);
602 ggc_pch_write_object (state
.d
, state
.f
, state
.ptrs
[i
]->obj
,
603 state
.ptrs
[i
]->new_addr
, state
.ptrs
[i
]->size
,
604 state
.ptrs
[i
]->note_ptr_fn
== gt_pch_p_S
);
605 if (state
.ptrs
[i
]->note_ptr_fn
!= gt_pch_p_S
)
606 memcpy (state
.ptrs
[i
]->obj
, this_object
, state
.ptrs
[i
]->size
);
608 ggc_pch_finish (state
.d
, state
.f
);
609 gt_pch_fixup_stringpool ();
612 htab_delete (saving_htab
);
615 /* Read the state of the compiler back in from F. */
618 gt_pch_restore (FILE *f
)
620 const struct ggc_root_tab
*const *rt
;
621 const struct ggc_root_tab
*rti
;
623 struct mmap_info mmi
;
626 /* Delete any deletable objects. This makes ggc_pch_read much
627 faster, as it can be sure that no GCable objects remain other
628 than the ones just read in. */
629 for (rt
= gt_ggc_deletable_rtab
; *rt
; rt
++)
630 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
631 memset (rti
->base
, 0, rti
->stride
);
633 /* Read in all the scalar variables. */
634 for (rt
= gt_pch_scalar_rtab
; *rt
; rt
++)
635 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
636 if (fread (rti
->base
, rti
->stride
, 1, f
) != 1)
637 fatal_error ("can't read PCH file: %m");
639 /* Read in all the global pointers, in 6 easy loops. */
640 for (rt
= gt_ggc_rtab
; *rt
; rt
++)
641 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
642 for (i
= 0; i
< rti
->nelt
; i
++)
643 if (fread ((char *)rti
->base
+ rti
->stride
* i
,
644 sizeof (void *), 1, f
) != 1)
645 fatal_error ("can't read PCH file: %m");
647 for (rt
= gt_pch_cache_rtab
; *rt
; rt
++)
648 for (rti
= *rt
; rti
->base
!= NULL
; rti
++)
649 for (i
= 0; i
< rti
->nelt
; i
++)
650 if (fread ((char *)rti
->base
+ rti
->stride
* i
,
651 sizeof (void *), 1, f
) != 1)
652 fatal_error ("can't read PCH file: %m");
654 if (fread (&mmi
, sizeof (mmi
), 1, f
) != 1)
655 fatal_error ("can't read PCH file: %m");
657 result
= host_hooks
.gt_pch_use_address (mmi
.preferred_base
, mmi
.size
,
658 fileno (f
), mmi
.offset
);
660 fatal_error ("had to relocate PCH");
663 if (fseek (f
, mmi
.offset
, SEEK_SET
) != 0
664 || fread (mmi
.preferred_base
, mmi
.size
, 1, f
) != 1)
665 fatal_error ("can't read PCH file: %m");
667 else if (fseek (f
, mmi
.offset
+ mmi
.size
, SEEK_SET
) != 0)
668 fatal_error ("can't read PCH file: %m");
670 ggc_pch_read (f
, mmi
.preferred_base
);
672 gt_pch_restore_stringpool ();
675 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
676 Select no address whatsoever, and let gt_pch_save choose what it will with
677 malloc, presumably. */
680 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED
,
681 int fd ATTRIBUTE_UNUSED
)
686 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
687 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
688 same as base, indicating that the memory has been allocated but needs to
689 be read in from the file. Return -1 if the address differs, to relocation
690 of the PCH file would be required. */
693 default_gt_pch_use_address (void *base
, size_t size
, int fd ATTRIBUTE_UNUSED
,
694 size_t offset ATTRIBUTE_UNUSED
)
696 void *addr
= xmalloc (size
);
697 return (addr
== base
) - 1;
700 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
701 alignment required for allocating virtual memory. Usually this is the
705 default_gt_pch_alloc_granularity (void)
707 return getpagesize();
711 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
712 We temporarily allocate SIZE bytes, and let the kernel place the data
713 wherever it will. If it worked, that's our spot, if not we're likely
717 mmap_gt_pch_get_address (size_t size
, int fd
)
721 ret
= mmap (NULL
, size
, PROT_READ
| PROT_WRITE
, MAP_PRIVATE
, fd
, 0);
722 if (ret
== (void *) MAP_FAILED
)
725 munmap ((caddr_t
) ret
, size
);
730 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
731 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
732 mapping the data at BASE, -1 if we couldn't.
734 This version assumes that the kernel honors the START operand of mmap
735 even without MAP_FIXED if START through START+SIZE are not currently
736 mapped with something. */
739 mmap_gt_pch_use_address (void *base
, size_t size
, int fd
, size_t offset
)
743 /* We're called with size == 0 if we're not planning to load a PCH
744 file at all. This allows the hook to free any static space that
745 we might have allocated at link time. */
749 addr
= mmap ((caddr_t
) base
, size
, PROT_READ
| PROT_WRITE
, MAP_PRIVATE
,
752 return addr
== base
? 1 : -1;
754 #endif /* HAVE_MMAP_FILE */
756 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
758 /* Modify the bound based on rlimits. */
760 ggc_rlimit_bound (double limit
)
762 #if defined(HAVE_GETRLIMIT)
764 # if defined (RLIMIT_AS)
765 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
766 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
767 if (getrlimit (RLIMIT_AS
, &rlim
) == 0
768 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
769 && rlim
.rlim_cur
< limit
)
770 limit
= rlim
.rlim_cur
;
771 # elif defined (RLIMIT_DATA)
772 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
773 might be on an OS that has a broken mmap. (Others don't bound
774 mmap at all, apparently.) */
775 if (getrlimit (RLIMIT_DATA
, &rlim
) == 0
776 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
777 && rlim
.rlim_cur
< limit
778 /* Darwin has this horribly bogus default setting of
779 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
780 appears to be ignored. Ignore such silliness. If a limit
781 this small was actually effective for mmap, GCC wouldn't even
783 && rlim
.rlim_cur
>= 8 * 1024 * 1024)
784 limit
= rlim
.rlim_cur
;
785 # endif /* RLIMIT_AS or RLIMIT_DATA */
786 #endif /* HAVE_GETRLIMIT */
791 /* Heuristic to set a default for GGC_MIN_EXPAND. */
793 ggc_min_expand_heuristic (void)
795 double min_expand
= physmem_total();
797 /* Adjust for rlimits. */
798 min_expand
= ggc_rlimit_bound (min_expand
);
800 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
801 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
802 min_expand
/= 1024*1024*1024;
804 min_expand
= MIN (min_expand
, 70);
810 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
812 ggc_min_heapsize_heuristic (void)
814 double phys_kbytes
= physmem_total();
815 double limit_kbytes
= ggc_rlimit_bound (phys_kbytes
* 2);
817 phys_kbytes
/= 1024; /* Convert to Kbytes. */
818 limit_kbytes
/= 1024;
820 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
821 bound of 128M (when RAM >= 1GB). */
824 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
825 /* Try not to overrun the RSS limit while doing garbage collection.
826 The RSS limit is only advisory, so no margin is subtracted. */
829 if (getrlimit (RLIMIT_RSS
, &rlim
) == 0
830 && rlim
.rlim_cur
!= (rlim_t
) RLIM_INFINITY
)
831 phys_kbytes
= MIN (phys_kbytes
, rlim
.rlim_cur
/ 1024);
835 /* Don't blindly run over our data limit; do GC at least when the
836 *next* GC would be within 20Mb of the limit or within a quarter of
837 the limit, whichever is larger. If GCC does hit the data limit,
838 compilation will fail, so this tries to be conservative. */
839 limit_kbytes
= MAX (0, limit_kbytes
- MAX (limit_kbytes
/ 4, 20 * 1024));
840 limit_kbytes
= (limit_kbytes
* 100) / (110 + ggc_min_expand_heuristic ());
841 phys_kbytes
= MIN (phys_kbytes
, limit_kbytes
);
843 phys_kbytes
= MAX (phys_kbytes
, 4 * 1024);
844 phys_kbytes
= MIN (phys_kbytes
, 128 * 1024);
851 init_ggc_heuristics (void)
853 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
854 set_param_value ("ggc-min-expand", ggc_min_expand_heuristic ());
855 set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic ());
859 #ifdef GATHER_STATISTICS
861 /* Datastructure used to store per-call-site statistics. */
862 struct loc_descriptor
866 const char *function
;
874 /* Hashtable used for statistics. */
875 static htab_t loc_hash
;
877 /* Hash table helpers functions. */
879 hash_descriptor (const void *p
)
881 const struct loc_descriptor
*const d
= (const struct loc_descriptor
*) p
;
883 return htab_hash_pointer (d
->function
) | d
->line
;
887 eq_descriptor (const void *p1
, const void *p2
)
889 const struct loc_descriptor
*const d
= (const struct loc_descriptor
*) p1
;
890 const struct loc_descriptor
*const d2
= (const struct loc_descriptor
*) p2
;
892 return (d
->file
== d2
->file
&& d
->line
== d2
->line
893 && d
->function
== d2
->function
);
896 /* Hashtable converting address of allocated field to loc descriptor. */
897 static htab_t ptr_hash
;
898 struct ptr_hash_entry
901 struct loc_descriptor
*loc
;
905 /* Hash table helpers functions. */
907 hash_ptr (const void *p
)
909 const struct ptr_hash_entry
*const d
= (const struct ptr_hash_entry
*) p
;
911 return htab_hash_pointer (d
->ptr
);
915 eq_ptr (const void *p1
, const void *p2
)
917 const struct ptr_hash_entry
*const p
= (const struct ptr_hash_entry
*) p1
;
919 return (p
->ptr
== p2
);
922 /* Return descriptor for given call site, create new one if needed. */
923 static struct loc_descriptor
*
924 loc_descriptor (const char *name
, int line
, const char *function
)
926 struct loc_descriptor loc
;
927 struct loc_descriptor
**slot
;
931 loc
.function
= function
;
933 loc_hash
= htab_create (10, hash_descriptor
, eq_descriptor
, NULL
);
935 slot
= (struct loc_descriptor
**) htab_find_slot (loc_hash
, &loc
, INSERT
);
938 *slot
= XCNEW (struct loc_descriptor
);
939 (*slot
)->file
= name
;
940 (*slot
)->line
= line
;
941 (*slot
)->function
= function
;
945 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
947 ggc_record_overhead (size_t allocated
, size_t overhead
, void *ptr
,
948 const char *name
, int line
, const char *function
)
950 struct loc_descriptor
*loc
= loc_descriptor (name
, line
, function
);
951 struct ptr_hash_entry
*p
= XNEW (struct ptr_hash_entry
);
956 p
->size
= allocated
+ overhead
;
958 ptr_hash
= htab_create (10, hash_ptr
, eq_ptr
, NULL
);
959 slot
= htab_find_slot_with_hash (ptr_hash
, ptr
, htab_hash_pointer (ptr
), INSERT
);
964 loc
->allocated
+=allocated
;
965 loc
->overhead
+=overhead
;
968 /* Helper function for prune_overhead_list. See if SLOT is still marked and
969 remove it from hashtable if it is not. */
971 ggc_prune_ptr (void **slot
, void *b ATTRIBUTE_UNUSED
)
973 struct ptr_hash_entry
*p
= (struct ptr_hash_entry
*) *slot
;
974 if (!ggc_marked_p (p
->ptr
))
976 p
->loc
->collected
+= p
->size
;
977 htab_clear_slot (ptr_hash
, slot
);
983 /* After live values has been marked, walk all recorded pointers and see if
984 they are still live. */
986 ggc_prune_overhead_list (void)
988 htab_traverse (ptr_hash
, ggc_prune_ptr
, NULL
);
991 /* Notice that the pointer has been freed. */
993 ggc_free_overhead (void *ptr
)
995 PTR
*slot
= htab_find_slot_with_hash (ptr_hash
, ptr
, htab_hash_pointer (ptr
),
997 struct ptr_hash_entry
*p
;
998 /* The pointer might be not found if a PCH read happened between allocation
999 and ggc_free () call. FIXME: account memory properly in the presence of
1003 p
= (struct ptr_hash_entry
*) *slot
;
1004 p
->loc
->freed
+= p
->size
;
1005 htab_clear_slot (ptr_hash
, slot
);
1009 /* Helper for qsort; sort descriptors by amount of memory consumed. */
1011 final_cmp_statistic (const void *loc1
, const void *loc2
)
1013 const struct loc_descriptor
*const l1
=
1014 *(const struct loc_descriptor
*const *) loc1
;
1015 const struct loc_descriptor
*const l2
=
1016 *(const struct loc_descriptor
*const *) loc2
;
1018 diff
= ((long)(l1
->allocated
+ l1
->overhead
- l1
->freed
) -
1019 (l2
->allocated
+ l2
->overhead
- l2
->freed
));
1020 return diff
> 0 ? 1 : diff
< 0 ? -1 : 0;
1023 /* Helper for qsort; sort descriptors by amount of memory consumed. */
1025 cmp_statistic (const void *loc1
, const void *loc2
)
1027 const struct loc_descriptor
*const l1
=
1028 *(const struct loc_descriptor
*const *) loc1
;
1029 const struct loc_descriptor
*const l2
=
1030 *(const struct loc_descriptor
*const *) loc2
;
1033 diff
= ((long)(l1
->allocated
+ l1
->overhead
- l1
->freed
- l1
->collected
) -
1034 (l2
->allocated
+ l2
->overhead
- l2
->freed
- l2
->collected
));
1036 return diff
> 0 ? 1 : diff
< 0 ? -1 : 0;
1037 diff
= ((long)(l1
->allocated
+ l1
->overhead
- l1
->freed
) -
1038 (l2
->allocated
+ l2
->overhead
- l2
->freed
));
1039 return diff
> 0 ? 1 : diff
< 0 ? -1 : 0;
1042 /* Collect array of the descriptors from hashtable. */
1043 static struct loc_descriptor
**loc_array
;
1045 add_statistics (void **slot
, void *b
)
1048 loc_array
[*n
] = (struct loc_descriptor
*) *slot
;
1053 /* Dump per-site memory statistics. */
1056 dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED
)
1058 #ifdef GATHER_STATISTICS
1061 size_t collected
= 0, freed
= 0, allocated
= 0, overhead
= 0, times
= 0;
1064 ggc_force_collect
= true;
1067 loc_array
= XCNEWVEC (struct loc_descriptor
*, loc_hash
->n_elements
);
1068 fprintf (stderr
, "-------------------------------------------------------\n");
1069 fprintf (stderr
, "\n%-48s %10s %10s %10s %10s %10s\n",
1070 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
1071 fprintf (stderr
, "-------------------------------------------------------\n");
1072 htab_traverse (loc_hash
, add_statistics
, &nentries
);
1073 qsort (loc_array
, nentries
, sizeof (*loc_array
),
1074 final
? final_cmp_statistic
: cmp_statistic
);
1075 for (i
= 0; i
< nentries
; i
++)
1077 struct loc_descriptor
*d
= loc_array
[i
];
1078 allocated
+= d
->allocated
;
1081 collected
+= d
->collected
;
1082 overhead
+= d
->overhead
;
1084 for (i
= 0; i
< nentries
; i
++)
1086 struct loc_descriptor
*d
= loc_array
[i
];
1089 const char *s1
= d
->file
;
1091 while ((s2
= strstr (s1
, "gcc/")))
1093 sprintf (s
, "%s:%i (%s)", s1
, d
->line
, d
->function
);
1095 fprintf (stderr
, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s
,
1097 (d
->collected
) * 100.0 / collected
,
1099 (d
->freed
) * 100.0 / freed
,
1100 (long)(d
->allocated
+ d
->overhead
- d
->freed
- d
->collected
),
1101 (d
->allocated
+ d
->overhead
- d
->freed
- d
->collected
) * 100.0
1102 / (allocated
+ overhead
- freed
- collected
),
1104 d
->overhead
* 100.0 / overhead
,
1108 fprintf (stderr
, "%-48s %10ld %10ld %10ld %10ld %10ld\n",
1109 "Total", (long)collected
, (long)freed
,
1110 (long)(allocated
+ overhead
- freed
- collected
), (long)overhead
,
1112 fprintf (stderr
, "%-48s %10s %10s %10s %10s %10s\n",
1113 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
1114 fprintf (stderr
, "-------------------------------------------------------\n");
1115 ggc_force_collect
= false;