1 /* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999-2018 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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
9 version.
10
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
14 for more details.
15
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/>. */
19
20 /* Generic garbage collection (GC) functions and data, not specific to
21 any particular GC implementation. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "timevar.h"
27 #include "diagnostic-core.h"
28 #include "ggc-internal.h"
29 #include "params.h"
30 #include "hosthooks.h"
31 #include "plugin.h"
32
33 /* When set, ggc_collect will do collection. */
34 bool ggc_force_collect;
35
36 /* When true, protect the contents of the identifier hash table. */
37 bool ggc_protect_identifiers = true;
38
39 /* Statistics about the allocation. */
40 static ggc_statistics *ggc_stats;
41
42 struct traversal_state;
43
44 static int compare_ptr_data (const void *, const void *);
45 static void relocate_ptrs (void *, void *);
46 static void write_pch_globals (const struct ggc_root_tab * const *tab,
47 struct traversal_state *state);
48
49 /* Maintain global roots that are preserved during GC. */
50
51 /* This extra vector of dynamically registered root_tab-s is used by
52 ggc_mark_roots and gives the ability to dynamically add new GGC root
53 tables, for instance from some plugins; this vector is on the heap
54 since it is used by GGC internally. */
55 typedef const struct ggc_root_tab *const_ggc_root_tab_t;
56 static vec<const_ggc_root_tab_t> extra_root_vec;
57
58 /* Dynamically register a new GGC root table RT. This is useful for
59 plugins. */
60
61 void
ggc_register_root_tab(const struct ggc_root_tab * rt)62 ggc_register_root_tab (const struct ggc_root_tab* rt)
63 {
64 if (rt)
65 extra_root_vec.safe_push (rt);
66 }
67
68 /* Mark all the roots in the table RT. */
69
70 static void
ggc_mark_root_tab(const_ggc_root_tab_t rt)71 ggc_mark_root_tab (const_ggc_root_tab_t rt)
72 {
73 size_t i;
74
75 for ( ; rt->base != NULL; rt++)
76 for (i = 0; i < rt->nelt; i++)
77 (*rt->cb) (*(void **) ((char *)rt->base + rt->stride * i));
78 }
79
80 /* Iterate through all registered roots and mark each element. */
81
82 void
ggc_mark_roots(void)83 ggc_mark_roots (void)
84 {
85 const struct ggc_root_tab *const *rt;
86 const_ggc_root_tab_t rtp, rti;
87 size_t i;
88
89 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
90 for (rti = *rt; rti->base != NULL; rti++)
91 memset (rti->base, 0, rti->stride);
92
93 for (rt = gt_ggc_rtab; *rt; rt++)
94 ggc_mark_root_tab (*rt);
95
96 FOR_EACH_VEC_ELT (extra_root_vec, i, rtp)
97 ggc_mark_root_tab (rtp);
98
99 if (ggc_protect_identifiers)
100 ggc_mark_stringpool ();
101
102 gt_clear_caches ();
103
104 if (! ggc_protect_identifiers)
105 ggc_purge_stringpool ();
106
107 /* Some plugins may call ggc_set_mark from here. */
108 invoke_plugin_callbacks (PLUGIN_GGC_MARKING, NULL);
109 }
110
111 /* Allocate a block of memory, then clear it. */
112 void *
ggc_internal_cleared_alloc(size_t size,void (* f)(void *),size_t s,size_t n MEM_STAT_DECL)113 ggc_internal_cleared_alloc (size_t size, void (*f)(void *), size_t s, size_t n
114 MEM_STAT_DECL)
115 {
116 void *buf = ggc_internal_alloc (size, f, s, n PASS_MEM_STAT);
117 memset (buf, 0, size);
118 return buf;
119 }
120
121 /* Resize a block of memory, possibly re-allocating it. */
122 void *
ggc_realloc(void * x,size_t size MEM_STAT_DECL)123 ggc_realloc (void *x, size_t size MEM_STAT_DECL)
124 {
125 void *r;
126 size_t old_size;
127
128 if (x == NULL)
129 return ggc_internal_alloc (size PASS_MEM_STAT);
130
131 old_size = ggc_get_size (x);
132
133 if (size <= old_size)
134 {
135 /* Mark the unwanted memory as unaccessible. We also need to make
136 the "new" size accessible, since ggc_get_size returns the size of
137 the pool, not the size of the individually allocated object, the
138 size which was previously made accessible. Unfortunately, we
139 don't know that previously allocated size. Without that
140 knowledge we have to lose some initialization-tracking for the
141 old parts of the object. An alternative is to mark the whole
142 old_size as reachable, but that would lose tracking of writes
143 after the end of the object (by small offsets). Discard the
144 handle to avoid handle leak. */
145 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x + size,
146 old_size - size));
147 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
148 return x;
149 }
150
151 r = ggc_internal_alloc (size PASS_MEM_STAT);
152
153 /* Since ggc_get_size returns the size of the pool, not the size of the
154 individually allocated object, we'd access parts of the old object
155 that were marked invalid with the memcpy below. We lose a bit of the
156 initialization-tracking since some of it may be uninitialized. */
157 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, old_size));
158
159 memcpy (r, x, old_size);
160
161 /* The old object is not supposed to be used anymore. */
162 ggc_free (x);
163
164 return r;
165 }
166
167 void *
ggc_cleared_alloc_htab_ignore_args(size_t c ATTRIBUTE_UNUSED,size_t n ATTRIBUTE_UNUSED)168 ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED,
169 size_t n ATTRIBUTE_UNUSED)
170 {
171 gcc_assert (c * n == sizeof (struct htab));
172 return ggc_cleared_alloc<htab> ();
173 }
174
175 /* TODO: once we actually use type information in GGC, create a new tag
176 gt_gcc_ptr_array and use it for pointer arrays. */
177 void *
ggc_cleared_alloc_ptr_array_two_args(size_t c,size_t n)178 ggc_cleared_alloc_ptr_array_two_args (size_t c, size_t n)
179 {
180 gcc_assert (sizeof (PTR *) == n);
181 return ggc_cleared_vec_alloc<PTR *> (c);
182 }
183
184 /* These are for splay_tree_new_ggc. */
185 void *
ggc_splay_alloc(int sz,void * nl)186 ggc_splay_alloc (int sz, void *nl)
187 {
188 gcc_assert (!nl);
189 return ggc_internal_alloc (sz);
190 }
191
192 void
ggc_splay_dont_free(void * x ATTRIBUTE_UNUSED,void * nl)193 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
194 {
195 gcc_assert (!nl);
196 }
197
198 /* Print statistics that are independent of the collector in use. */
199 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
200 ? (x) \
201 : ((x) < 1024*1024*10 \
202 ? (x) / 1024 \
203 : (x) / (1024*1024))))
204 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
205
206 void
ggc_print_common_statistics(FILE * stream ATTRIBUTE_UNUSED,ggc_statistics * stats)207 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
208 ggc_statistics *stats)
209 {
210 /* Set the pointer so that during collection we will actually gather
211 the statistics. */
212 ggc_stats = stats;
213
214 /* Then do one collection to fill in the statistics. */
215 ggc_collect ();
216
217 /* At present, we don't really gather any interesting statistics. */
218
219 /* Don't gather statistics any more. */
220 ggc_stats = NULL;
221 }
222
223 /* Functions for saving and restoring GCable memory to disk. */
224
225 struct ptr_data
226 {
227 void *obj;
228 void *note_ptr_cookie;
229 gt_note_pointers note_ptr_fn;
230 gt_handle_reorder reorder_fn;
231 size_t size;
232 void *new_addr;
233 };
234
235 #define POINTER_HASH(x) (hashval_t)((intptr_t)x >> 3)
236
237 /* Helper for hashing saving_htab. */
238
239 struct saving_hasher : free_ptr_hash <ptr_data>
240 {
241 typedef void *compare_type;
242 static inline hashval_t hash (const ptr_data *);
243 static inline bool equal (const ptr_data *, const void *);
244 };
245
246 inline hashval_t
hash(const ptr_data * p)247 saving_hasher::hash (const ptr_data *p)
248 {
249 return POINTER_HASH (p->obj);
250 }
251
252 inline bool
equal(const ptr_data * p1,const void * p2)253 saving_hasher::equal (const ptr_data *p1, const void *p2)
254 {
255 return p1->obj == p2;
256 }
257
258 static hash_table<saving_hasher> *saving_htab;
259
260 /* Register an object in the hash table. */
261
262 int
gt_pch_note_object(void * obj,void * note_ptr_cookie,gt_note_pointers note_ptr_fn)263 gt_pch_note_object (void *obj, void *note_ptr_cookie,
264 gt_note_pointers note_ptr_fn)
265 {
266 struct ptr_data **slot;
267
268 if (obj == NULL || obj == (void *) 1)
269 return 0;
270
271 slot = (struct ptr_data **)
272 saving_htab->find_slot_with_hash (obj, POINTER_HASH (obj), INSERT);
273 if (*slot != NULL)
274 {
275 gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
276 && (*slot)->note_ptr_cookie == note_ptr_cookie);
277 return 0;
278 }
279
280 *slot = XCNEW (struct ptr_data);
281 (*slot)->obj = obj;
282 (*slot)->note_ptr_fn = note_ptr_fn;
283 (*slot)->note_ptr_cookie = note_ptr_cookie;
284 if (note_ptr_fn == gt_pch_p_S)
285 (*slot)->size = strlen ((const char *)obj) + 1;
286 else
287 (*slot)->size = ggc_get_size (obj);
288 return 1;
289 }
290
291 /* Register an object in the hash table. */
292
293 void
gt_pch_note_reorder(void * obj,void * note_ptr_cookie,gt_handle_reorder reorder_fn)294 gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
295 gt_handle_reorder reorder_fn)
296 {
297 struct ptr_data *data;
298
299 if (obj == NULL || obj == (void *) 1)
300 return;
301
302 data = (struct ptr_data *)
303 saving_htab->find_with_hash (obj, POINTER_HASH (obj));
304 gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
305
306 data->reorder_fn = reorder_fn;
307 }
308
309 /* Handy state for the traversal functions. */
310
311 struct traversal_state
312 {
313 FILE *f;
314 struct ggc_pch_data *d;
315 size_t count;
316 struct ptr_data **ptrs;
317 size_t ptrs_i;
318 };
319
320 /* Callbacks for htab_traverse. */
321
322 int
ggc_call_count(ptr_data ** slot,traversal_state * state)323 ggc_call_count (ptr_data **slot, traversal_state *state)
324 {
325 struct ptr_data *d = *slot;
326
327 ggc_pch_count_object (state->d, d->obj, d->size,
328 d->note_ptr_fn == gt_pch_p_S);
329 state->count++;
330 return 1;
331 }
332
333 int
ggc_call_alloc(ptr_data ** slot,traversal_state * state)334 ggc_call_alloc (ptr_data **slot, traversal_state *state)
335 {
336 struct ptr_data *d = *slot;
337
338 d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size,
339 d->note_ptr_fn == gt_pch_p_S);
340 state->ptrs[state->ptrs_i++] = d;
341 return 1;
342 }
343
344 /* Callback for qsort. */
345
346 static int
compare_ptr_data(const void * p1_p,const void * p2_p)347 compare_ptr_data (const void *p1_p, const void *p2_p)
348 {
349 const struct ptr_data *const p1 = *(const struct ptr_data *const *)p1_p;
350 const struct ptr_data *const p2 = *(const struct ptr_data *const *)p2_p;
351 return (((size_t)p1->new_addr > (size_t)p2->new_addr)
352 - ((size_t)p1->new_addr < (size_t)p2->new_addr));
353 }
354
355 /* Callbacks for note_ptr_fn. */
356
357 static void
relocate_ptrs(void * ptr_p,void * state_p)358 relocate_ptrs (void *ptr_p, void *state_p)
359 {
360 void **ptr = (void **)ptr_p;
361 struct traversal_state *state ATTRIBUTE_UNUSED
362 = (struct traversal_state *)state_p;
363 struct ptr_data *result;
364
365 if (*ptr == NULL || *ptr == (void *)1)
366 return;
367
368 result = (struct ptr_data *)
369 saving_htab->find_with_hash (*ptr, POINTER_HASH (*ptr));
370 gcc_assert (result);
371 *ptr = result->new_addr;
372 }
373
374 /* Write out, after relocation, the pointers in TAB. */
375 static void
write_pch_globals(const struct ggc_root_tab * const * tab,struct traversal_state * state)376 write_pch_globals (const struct ggc_root_tab * const *tab,
377 struct traversal_state *state)
378 {
379 const struct ggc_root_tab *const *rt;
380 const struct ggc_root_tab *rti;
381 size_t i;
382
383 for (rt = tab; *rt; rt++)
384 for (rti = *rt; rti->base != NULL; rti++)
385 for (i = 0; i < rti->nelt; i++)
386 {
387 void *ptr = *(void **)((char *)rti->base + rti->stride * i);
388 struct ptr_data *new_ptr;
389 if (ptr == NULL || ptr == (void *)1)
390 {
391 if (fwrite (&ptr, sizeof (void *), 1, state->f)
392 != 1)
393 fatal_error (input_location, "can%'t write PCH file: %m");
394 }
395 else
396 {
397 new_ptr = (struct ptr_data *)
398 saving_htab->find_with_hash (ptr, POINTER_HASH (ptr));
399 if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
400 != 1)
401 fatal_error (input_location, "can%'t write PCH file: %m");
402 }
403 }
404 }
405
406 /* Hold the information we need to mmap the file back in. */
407
408 struct mmap_info
409 {
410 size_t offset;
411 size_t size;
412 void *preferred_base;
413 };
414
415 /* Write out the state of the compiler to F. */
416
417 void
gt_pch_save(FILE * f)418 gt_pch_save (FILE *f)
419 {
420 const struct ggc_root_tab *const *rt;
421 const struct ggc_root_tab *rti;
422 size_t i;
423 struct traversal_state state;
424 char *this_object = NULL;
425 size_t this_object_size = 0;
426 struct mmap_info mmi;
427 const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity ();
428
429 gt_pch_save_stringpool ();
430
431 timevar_push (TV_PCH_PTR_REALLOC);
432 saving_htab = new hash_table<saving_hasher> (50000);
433
434 for (rt = gt_ggc_rtab; *rt; rt++)
435 for (rti = *rt; rti->base != NULL; rti++)
436 for (i = 0; i < rti->nelt; i++)
437 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
438
439 /* Prepare the objects for writing, determine addresses and such. */
440 state.f = f;
441 state.d = init_ggc_pch ();
442 state.count = 0;
443 saving_htab->traverse <traversal_state *, ggc_call_count> (&state);
444
445 mmi.size = ggc_pch_total_size (state.d);
446
447 /* Try to arrange things so that no relocation is necessary, but
448 don't try very hard. On most platforms, this will always work,
449 and on the rest it's a lot of work to do better.
450 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
451 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
452 mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
453
454 ggc_pch_this_base (state.d, mmi.preferred_base);
455
456 state.ptrs = XNEWVEC (struct ptr_data *, state.count);
457 state.ptrs_i = 0;
458
459 saving_htab->traverse <traversal_state *, ggc_call_alloc> (&state);
460 timevar_pop (TV_PCH_PTR_REALLOC);
461
462 timevar_push (TV_PCH_PTR_SORT);
463 qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
464 timevar_pop (TV_PCH_PTR_SORT);
465
466 /* Write out all the scalar variables. */
467 for (rt = gt_pch_scalar_rtab; *rt; rt++)
468 for (rti = *rt; rti->base != NULL; rti++)
469 if (fwrite (rti->base, rti->stride, 1, f) != 1)
470 fatal_error (input_location, "can%'t write PCH file: %m");
471
472 /* Write out all the global pointers, after translation. */
473 write_pch_globals (gt_ggc_rtab, &state);
474
475 /* Pad the PCH file so that the mmapped area starts on an allocation
476 granularity (usually page) boundary. */
477 {
478 long o;
479 o = ftell (state.f) + sizeof (mmi);
480 if (o == -1)
481 fatal_error (input_location, "can%'t get position in PCH file: %m");
482 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
483 if (mmi.offset == mmap_offset_alignment)
484 mmi.offset = 0;
485 mmi.offset += o;
486 }
487 if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
488 fatal_error (input_location, "can%'t write PCH file: %m");
489 if (mmi.offset != 0
490 && fseek (state.f, mmi.offset, SEEK_SET) != 0)
491 fatal_error (input_location, "can%'t write padding to PCH file: %m");
492
493 ggc_pch_prepare_write (state.d, state.f);
494
495 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
496 vec<char> vbits = vNULL;
497 #endif
498
499 /* Actually write out the objects. */
500 for (i = 0; i < state.count; i++)
501 {
502 if (this_object_size < state.ptrs[i]->size)
503 {
504 this_object_size = state.ptrs[i]->size;
505 this_object = XRESIZEVAR (char, this_object, this_object_size);
506 }
507 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
508 /* obj might contain uninitialized bytes, e.g. in the trailing
509 padding of the object. Avoid warnings by making the memory
510 temporarily defined and then restoring previous state. */
511 int get_vbits = 0;
512 size_t valid_size = state.ptrs[i]->size;
513 if (__builtin_expect (RUNNING_ON_VALGRIND, 0))
514 {
515 if (vbits.length () < valid_size)
516 vbits.safe_grow (valid_size);
517 get_vbits = VALGRIND_GET_VBITS (state.ptrs[i]->obj,
518 vbits.address (), valid_size);
519 if (get_vbits == 3)
520 {
521 /* We assume that first part of obj is addressable, and
522 the rest is unaddressable. Find out where the boundary is
523 using binary search. */
524 size_t lo = 0, hi = valid_size;
525 while (hi > lo)
526 {
527 size_t mid = (lo + hi) / 2;
528 get_vbits = VALGRIND_GET_VBITS ((char *) state.ptrs[i]->obj
529 + mid, vbits.address (),
530 1);
531 if (get_vbits == 3)
532 hi = mid;
533 else if (get_vbits == 1)
534 lo = mid + 1;
535 else
536 break;
537 }
538 if (get_vbits == 1 || get_vbits == 3)
539 {
540 valid_size = lo;
541 get_vbits = VALGRIND_GET_VBITS (state.ptrs[i]->obj,
542 vbits.address (),
543 valid_size);
544 }
545 }
546 if (get_vbits == 1)
547 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (state.ptrs[i]->obj,
548 state.ptrs[i]->size));
549 }
550 #endif
551 memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
552 if (state.ptrs[i]->reorder_fn != NULL)
553 state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,
554 state.ptrs[i]->note_ptr_cookie,
555 relocate_ptrs, &state);
556 state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj,
557 state.ptrs[i]->note_ptr_cookie,
558 relocate_ptrs, &state);
559 ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
560 state.ptrs[i]->new_addr, state.ptrs[i]->size,
561 state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
562 if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)
563 memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
564 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
565 if (__builtin_expect (get_vbits == 1, 0))
566 {
567 (void) VALGRIND_SET_VBITS (state.ptrs[i]->obj, vbits.address (),
568 valid_size);
569 if (valid_size != state.ptrs[i]->size)
570 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *)
571 state.ptrs[i]->obj
572 + valid_size,
573 state.ptrs[i]->size
574 - valid_size));
575 }
576 #endif
577 }
578 #if defined ENABLE_VALGRIND_ANNOTATIONS && defined VALGRIND_GET_VBITS
579 vbits.release ();
580 #endif
581
582 ggc_pch_finish (state.d, state.f);
583 gt_pch_fixup_stringpool ();
584
585 XDELETE (state.ptrs);
586 XDELETE (this_object);
587 delete saving_htab;
588 saving_htab = NULL;
589 }
590
591 /* Read the state of the compiler back in from F. */
592
593 void
gt_pch_restore(FILE * f)594 gt_pch_restore (FILE *f)
595 {
596 const struct ggc_root_tab *const *rt;
597 const struct ggc_root_tab *rti;
598 size_t i;
599 struct mmap_info mmi;
600 int result;
601
602 /* Delete any deletable objects. This makes ggc_pch_read much
603 faster, as it can be sure that no GCable objects remain other
604 than the ones just read in. */
605 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
606 for (rti = *rt; rti->base != NULL; rti++)
607 memset (rti->base, 0, rti->stride);
608
609 /* Read in all the scalar variables. */
610 for (rt = gt_pch_scalar_rtab; *rt; rt++)
611 for (rti = *rt; rti->base != NULL; rti++)
612 if (fread (rti->base, rti->stride, 1, f) != 1)
613 fatal_error (input_location, "can%'t read PCH file: %m");
614
615 /* Read in all the global pointers, in 6 easy loops. */
616 for (rt = gt_ggc_rtab; *rt; rt++)
617 for (rti = *rt; rti->base != NULL; rti++)
618 for (i = 0; i < rti->nelt; i++)
619 if (fread ((char *)rti->base + rti->stride * i,
620 sizeof (void *), 1, f) != 1)
621 fatal_error (input_location, "can%'t read PCH file: %m");
622
623 if (fread (&mmi, sizeof (mmi), 1, f) != 1)
624 fatal_error (input_location, "can%'t read PCH file: %m");
625
626 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
627 fileno (f), mmi.offset);
628 if (result < 0)
629 fatal_error (input_location, "had to relocate PCH");
630 if (result == 0)
631 {
632 if (fseek (f, mmi.offset, SEEK_SET) != 0
633 || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
634 fatal_error (input_location, "can%'t read PCH file: %m");
635 }
636 else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
637 fatal_error (input_location, "can%'t read PCH file: %m");
638
639 ggc_pch_read (f, mmi.preferred_base);
640
641 gt_pch_restore_stringpool ();
642 }
643
644 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
645 Select no address whatsoever, and let gt_pch_save choose what it will with
646 malloc, presumably. */
647
648 void *
default_gt_pch_get_address(size_t size ATTRIBUTE_UNUSED,int fd ATTRIBUTE_UNUSED)649 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
650 int fd ATTRIBUTE_UNUSED)
651 {
652 return NULL;
653 }
654
655 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
656 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
657 same as base, indicating that the memory has been allocated but needs to
658 be read in from the file. Return -1 if the address differs, to relocation
659 of the PCH file would be required. */
660
661 int
default_gt_pch_use_address(void * base,size_t size,int fd ATTRIBUTE_UNUSED,size_t offset ATTRIBUTE_UNUSED)662 default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
663 size_t offset ATTRIBUTE_UNUSED)
664 {
665 void *addr = xmalloc (size);
666 return (addr == base) - 1;
667 }
668
669 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
670 alignment required for allocating virtual memory. Usually this is the
671 same as pagesize. */
672
673 size_t
default_gt_pch_alloc_granularity(void)674 default_gt_pch_alloc_granularity (void)
675 {
676 return getpagesize ();
677 }
678
679 #if HAVE_MMAP_FILE
680 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
681 We temporarily allocate SIZE bytes, and let the kernel place the data
682 wherever it will. If it worked, that's our spot, if not we're likely
683 to be in trouble. */
684
685 void *
mmap_gt_pch_get_address(size_t size,int fd)686 mmap_gt_pch_get_address (size_t size, int fd)
687 {
688 void *ret;
689
690 ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
691 if (ret == (void *) MAP_FAILED)
692 ret = NULL;
693 else
694 munmap ((caddr_t) ret, size);
695
696 return ret;
697 }
698
699 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
700 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
701 mapping the data at BASE, -1 if we couldn't.
702
703 This version assumes that the kernel honors the START operand of mmap
704 even without MAP_FIXED if START through START+SIZE are not currently
705 mapped with something. */
706
707 int
mmap_gt_pch_use_address(void * base,size_t size,int fd,size_t offset)708 mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
709 {
710 void *addr;
711
712 /* We're called with size == 0 if we're not planning to load a PCH
713 file at all. This allows the hook to free any static space that
714 we might have allocated at link time. */
715 if (size == 0)
716 return -1;
717
718 addr = mmap ((caddr_t) base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
719 fd, offset);
720
721 return addr == base ? 1 : -1;
722 }
723 #endif /* HAVE_MMAP_FILE */
724
725 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
726
727 /* Modify the bound based on rlimits. */
728 static double
ggc_rlimit_bound(double limit)729 ggc_rlimit_bound (double limit)
730 {
731 #if defined(HAVE_GETRLIMIT)
732 struct rlimit rlim;
733 # if defined (RLIMIT_AS)
734 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
735 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
736 if (getrlimit (RLIMIT_AS, &rlim) == 0
737 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
738 && rlim.rlim_cur < limit)
739 limit = rlim.rlim_cur;
740 # elif defined (RLIMIT_DATA)
741 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
742 might be on an OS that has a broken mmap. (Others don't bound
743 mmap at all, apparently.) */
744 if (getrlimit (RLIMIT_DATA, &rlim) == 0
745 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
746 && rlim.rlim_cur < limit
747 /* Darwin has this horribly bogus default setting of
748 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
749 appears to be ignored. Ignore such silliness. If a limit
750 this small was actually effective for mmap, GCC wouldn't even
751 start up. */
752 && rlim.rlim_cur >= 8 * 1024 * 1024)
753 limit = rlim.rlim_cur;
754 # endif /* RLIMIT_AS or RLIMIT_DATA */
755 #endif /* HAVE_GETRLIMIT */
756
757 return limit;
758 }
759
760 /* Heuristic to set a default for GGC_MIN_EXPAND. */
761 static int
ggc_min_expand_heuristic(void)762 ggc_min_expand_heuristic (void)
763 {
764 double min_expand = physmem_total ();
765
766 /* Adjust for rlimits. */
767 min_expand = ggc_rlimit_bound (min_expand);
768
769 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
770 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
771 min_expand /= 1024*1024*1024;
772 min_expand *= 70;
773 min_expand = MIN (min_expand, 70);
774 min_expand += 30;
775
776 return min_expand;
777 }
778
779 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
780 static int
ggc_min_heapsize_heuristic(void)781 ggc_min_heapsize_heuristic (void)
782 {
783 double phys_kbytes = physmem_total ();
784 double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
785
786 phys_kbytes /= 1024; /* Convert to Kbytes. */
787 limit_kbytes /= 1024;
788
789 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
790 bound of 128M (when RAM >= 1GB). */
791 phys_kbytes /= 8;
792
793 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
794 /* Try not to overrun the RSS limit while doing garbage collection.
795 The RSS limit is only advisory, so no margin is subtracted. */
796 {
797 struct rlimit rlim;
798 if (getrlimit (RLIMIT_RSS, &rlim) == 0
799 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
800 phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
801 }
802 # endif
803
804 /* Don't blindly run over our data limit; do GC at least when the
805 *next* GC would be within 20Mb of the limit or within a quarter of
806 the limit, whichever is larger. If GCC does hit the data limit,
807 compilation will fail, so this tries to be conservative. */
808 limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024));
809 limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic ());
810 phys_kbytes = MIN (phys_kbytes, limit_kbytes);
811
812 phys_kbytes = MAX (phys_kbytes, 4 * 1024);
813 phys_kbytes = MIN (phys_kbytes, 128 * 1024);
814
815 return phys_kbytes;
816 }
817 #endif
818
819 void
init_ggc_heuristics(void)820 init_ggc_heuristics (void)
821 {
822 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
823 set_default_param_value (GGC_MIN_EXPAND, ggc_min_expand_heuristic ());
824 set_default_param_value (GGC_MIN_HEAPSIZE, ggc_min_heapsize_heuristic ());
825 #endif
826 }
827
828 /* GGC memory usage. */
829 struct ggc_usage: public mem_usage
830 {
831 /* Default constructor. */
ggc_usageggc_usage832 ggc_usage (): m_freed (0), m_collected (0), m_overhead (0) {}
833 /* Constructor. */
ggc_usageggc_usage834 ggc_usage (size_t allocated, size_t times, size_t peak,
835 size_t freed, size_t collected, size_t overhead)
836 : mem_usage (allocated, times, peak),
837 m_freed (freed), m_collected (collected), m_overhead (overhead) {}
838
839 /* Equality operator. */
840 inline bool
841 operator== (const ggc_usage &second) const
842 {
843 return (get_balance () == second.get_balance ()
844 && m_peak == second.m_peak
845 && m_times == second.m_times);
846 }
847
848 /* Comparison operator. */
849 inline bool
850 operator< (const ggc_usage &second) const
851 {
852 if (*this == second)
853 return false;
854
855 return (get_balance () == second.get_balance () ?
856 (m_peak == second.m_peak ? m_times < second.m_times
857 : m_peak < second.m_peak)
858 : get_balance () < second.get_balance ());
859 }
860
861 /* Register overhead of ALLOCATED and OVERHEAD bytes. */
862 inline void
register_overheadggc_usage863 register_overhead (size_t allocated, size_t overhead)
864 {
865 m_allocated += allocated;
866 m_overhead += overhead;
867 m_times++;
868 }
869
870 /* Release overhead of SIZE bytes. */
871 inline void
release_overheadggc_usage872 release_overhead (size_t size)
873 {
874 m_freed += size;
875 }
876
877 /* Sum the usage with SECOND usage. */
878 ggc_usage
879 operator+ (const ggc_usage &second)
880 {
881 return ggc_usage (m_allocated + second.m_allocated,
882 m_times + second.m_times,
883 m_peak + second.m_peak,
884 m_freed + second.m_freed,
885 m_collected + second.m_collected,
886 m_overhead + second.m_overhead);
887 }
888
889 /* Dump usage with PREFIX, where TOTAL is sum of all rows. */
890 inline void
dumpggc_usage891 dump (const char *prefix, ggc_usage &total) const
892 {
893 long balance = get_balance ();
894 fprintf (stderr,
895 "%-48s %10li:%5.1f%%%10li:%5.1f%%"
896 "%10li:%5.1f%%%10li:%5.1f%%%10li\n",
897 prefix, (long)m_collected,
898 get_percent (m_collected, total.m_collected),
899 (long)m_freed, get_percent (m_freed, total.m_freed),
900 (long)balance, get_percent (balance, total.get_balance ()),
901 (long)m_overhead, get_percent (m_overhead, total.m_overhead),
902 (long)m_times);
903 }
904
905 /* Dump usage coupled to LOC location, where TOTAL is sum of all rows. */
906 inline void
dumpggc_usage907 dump (mem_location *loc, ggc_usage &total) const
908 {
909 char *location_string = loc->to_string ();
910
911 dump (location_string, total);
912
913 free (location_string);
914 }
915
916 /* Dump footer. */
917 inline void
dump_footerggc_usage918 dump_footer ()
919 {
920 print_dash_line ();
921 dump ("Total", *this);
922 print_dash_line ();
923 }
924
925 /* Get balance which is GGC allocation leak. */
926 inline long
get_balanceggc_usage927 get_balance () const
928 {
929 return m_allocated + m_overhead - m_collected - m_freed;
930 }
931
932 typedef std::pair<mem_location *, ggc_usage *> mem_pair_t;
933
934 /* Compare wrapper used by qsort method. */
935 static int
compareggc_usage936 compare (const void *first, const void *second)
937 {
938 const mem_pair_t f = *(const mem_pair_t *)first;
939 const mem_pair_t s = *(const mem_pair_t *)second;
940
941 if (*f.second == *s.second)
942 return 0;
943
944 return *f.second < *s.second ? 1 : -1;
945 }
946
947 /* Compare rows in final GGC summary dump. */
948 static int
compare_finalggc_usage949 compare_final (const void *first, const void *second)
950 {
951 typedef std::pair<mem_location *, ggc_usage *> mem_pair_t;
952
953 const ggc_usage *f = ((const mem_pair_t *)first)->second;
954 const ggc_usage *s = ((const mem_pair_t *)second)->second;
955
956 size_t a = f->m_allocated + f->m_overhead - f->m_freed;
957 size_t b = s->m_allocated + s->m_overhead - s->m_freed;
958
959 return a == b ? 0 : (a < b ? 1 : -1);
960 }
961
962 /* Dump header with NAME. */
963 static inline void
dump_headerggc_usage964 dump_header (const char *name)
965 {
966 fprintf (stderr, "%-48s %11s%17s%17s%16s%17s\n", name, "Garbage", "Freed",
967 "Leak", "Overhead", "Times");
968 print_dash_line ();
969 }
970
971 /* Freed memory in bytes. */
972 size_t m_freed;
973 /* Collected memory in bytes. */
974 size_t m_collected;
975 /* Overhead memory in bytes. */
976 size_t m_overhead;
977 };
978
979 /* GCC memory description. */
980 static mem_alloc_description<ggc_usage> ggc_mem_desc;
981
982 /* Dump per-site memory statistics. */
983
984 void
dump_ggc_loc_statistics(bool final)985 dump_ggc_loc_statistics (bool final)
986 {
987 if (! GATHER_STATISTICS)
988 return;
989
990 ggc_force_collect = true;
991 ggc_collect ();
992
993 ggc_mem_desc.dump (GGC_ORIGIN, final ? ggc_usage::compare_final : NULL);
994
995 ggc_force_collect = false;
996 }
997
998 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
999 void
ggc_record_overhead(size_t allocated,size_t overhead,void * ptr MEM_STAT_DECL)1000 ggc_record_overhead (size_t allocated, size_t overhead, void *ptr MEM_STAT_DECL)
1001 {
1002 ggc_usage *usage = ggc_mem_desc.register_descriptor (ptr, GGC_ORIGIN, false
1003 FINAL_PASS_MEM_STAT);
1004
1005 ggc_mem_desc.register_object_overhead (usage, allocated + overhead, ptr);
1006 usage->register_overhead (allocated, overhead);
1007 }
1008
1009 /* Notice that the pointer has been freed. */
1010 void
ggc_free_overhead(void * ptr)1011 ggc_free_overhead (void *ptr)
1012 {
1013 ggc_mem_desc.release_object_overhead (ptr);
1014 }
1015
1016 /* After live values has been marked, walk all recorded pointers and see if
1017 they are still live. */
1018 void
ggc_prune_overhead_list(void)1019 ggc_prune_overhead_list (void)
1020 {
1021 typedef hash_map<const void *, std::pair<ggc_usage *, size_t > > map_t;
1022
1023 map_t::iterator it = ggc_mem_desc.m_reverse_object_map->begin ();
1024
1025 for (; it != ggc_mem_desc.m_reverse_object_map->end (); ++it)
1026 if (!ggc_marked_p ((*it).first))
1027 (*it).second.first->m_collected += (*it).second.second;
1028
1029 delete ggc_mem_desc.m_reverse_object_map;
1030 ggc_mem_desc.m_reverse_object_map = new map_t (13, false, false);
1031 }
1032