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