gcc/ggc-common.c

   1 /* Simple garbage collection for the GNU compiler.
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   3    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 "toplev.h"
  30 #include "params.h"
  31 #include "hosthooks.h"
  32 #include "hosthooks-def.h"
  33 #include "plugin.h"
  34 #include "vec.h"
  35 #include "timevar.h"
  36
  37 #ifdef HAVE_SYS_RESOURCE_H
  38 # include <sys/resource.h>
  39 #endif
  40
  41 #ifdef HAVE_MMAP_FILE
  42 # include <sys/mman.h>
  43 # ifdef HAVE_MINCORE
  44 /* This is on Solaris.  */
  45 #  include <sys/types.h>
  46 # endif
  47 #endif
  48
  49 #ifndef MAP_FAILED
  50 # define MAP_FAILED ((void *)-1)
  51 #endif
  52
  53 /* When set, ggc_collect will do collection.  */
  54 bool ggc_force_collect;
  55
  56 /* When true, protect the contents of the identifier hash table.  */
  57 bool ggc_protect_identifiers = true;
  58
  59 /* Statistics about the allocation.  */
  60 static ggc_statistics *ggc_stats;
  61
  62 struct traversal_state;
  63
  64 static int ggc_htab_delete (void **, void *);
  65 static hashval_t saving_htab_hash (const void *);
  66 static int saving_htab_eq (const void *, const void *);
  67 static int call_count (void **, void *);
  68 static int call_alloc (void **, void *);
  69 static int compare_ptr_data (const void *, const void *);
  70 static void relocate_ptrs (void *, void *);
  71 static void write_pch_globals (const struct ggc_root_tab * const *tab,
  72                                struct traversal_state *state);
  73 static double ggc_rlimit_bound (double);
  74
  75 /* Maintain global roots that are preserved during GC.  */
  76
  77 /* Process a slot of an htab by deleting it if it has not been marked.  */
  78
  79 static int
  80 ggc_htab_delete (void **slot, void *info)
  81 {
  82   const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
  83
  84   if (! (*r->marked_p) (*slot))
  85     htab_clear_slot (*r->base, slot);
  86   else
  87     (*r->cb) (*slot);
  88
  89   return 1;
  90 }
  91
  92
  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;
 101
 102 /* Dynamically register a new GGC root table RT. This is useful for
 103    plugins. */
 104
 105 void
 106 ggc_register_root_tab (const struct ggc_root_tab* rt)
 107 {
 108   if (rt)
 109     VEC_safe_push (const_ggc_root_tab_t, heap, extra_root_vec, rt);
 110 }
 111
 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;
 120
 121 /* Dynamically register a new GGC cache table CT. This is useful for
 122    plugins. */
 123
 124 void
 125 ggc_register_cache_tab (const struct ggc_cache_tab* ct)
 126 {
 127   if (ct)
 128     VEC_safe_push (const_ggc_cache_tab_t, heap, extra_cache_vec, ct);
 129 }
 130
 131 /* Scan a hash table that has objects which are to be deleted if they are not
 132    already marked.  */
 133
 134 static void
 135 ggc_scan_cache_tab (const_ggc_cache_tab_t ctp)
 136 {
 137   const struct ggc_cache_tab *cti;
 138
 139   for (cti = ctp; cti->base != NULL; cti++)
 140     if (*cti->base)
 141       {
 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);
 146       }
 147 }
 148
 149 /* Iterate through all registered roots and mark each element.  */
 150
 151 void
 152 ggc_mark_roots (void)
 153 {
 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;
 159   size_t i;
 160
 161   for (rt = gt_ggc_deletable_rtab; *rt; rt++)
 162     for (rti = *rt; rti->base != NULL; rti++)
 163       memset (rti->base, 0, rti->stride);
 164
 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));
 169
 170   for (i = 0; VEC_iterate (const_ggc_root_tab_t, extra_root_vec, i, rtp); i++)
 171     {
 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));
 175     }
 176
 177   if (ggc_protect_identifiers)
 178     ggc_mark_stringpool ();
 179
 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);
 184
 185   for (i = 0; VEC_iterate (const_ggc_cache_tab_t, extra_cache_vec, i, ctp); i++)
 186     ggc_scan_cache_tab (ctp);
 187
 188   if (! ggc_protect_identifiers)
 189     ggc_purge_stringpool ();
 190
 191   /* Some plugins may call ggc_set_mark from here.  */
 192   invoke_plugin_callbacks (PLUGIN_GGC_MARKING, NULL);
 193 }
 194
 195 /* Allocate a block of memory, then clear it.  */
 196 void *
 197 ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
 198 {
 199   void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
 200   memset (buf, 0, size);
 201   return buf;
 202 }
 203
 204 /* Resize a block of memory, possibly re-allocating it.  */
 205 void *
 206 ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
 207 {
 208   void *r;
 209   size_t old_size;
 210
 211   if (x == NULL)
 212     return ggc_alloc_stat (size PASS_MEM_STAT);
 213
 214   old_size = ggc_get_size (x);
 215
 216   if (size <= old_size)
 217     {
 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,
 229                                                     old_size - size));
 230       VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
 231       return x;
 232     }
 233
 234   r = ggc_alloc_stat (size PASS_MEM_STAT);
 235
 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));
 241
 242   memcpy (r, x, old_size);
 243
 244   /* The old object is not supposed to be used anymore.  */
 245   ggc_free (x);
 246
 247   return r;
 248 }
 249
 250 /* Like ggc_alloc_cleared, but performs a multiplication.  */
 251 void *
 252 ggc_calloc (size_t s1, size_t s2)
 253 {
 254   return ggc_alloc_cleared (s1 * s2);
 255 }
 256
 257 /* These are for splay_tree_new_ggc.  */
 258 void *
 259 ggc_splay_alloc (int sz, void *nl)
 260 {
 261   gcc_assert (!nl);
 262   return ggc_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 \f
 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)((long)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 /* Modify the bound based on rlimits.  */
 746 static double
 747 ggc_rlimit_bound (double limit)
 748 {
 749 #if defined(HAVE_GETRLIMIT)
 750   struct rlimit rlim;
 751 # if defined (RLIMIT_AS)
 752   /* RLIMIT_AS is what POSIX says is the limit on mmap.  Presumably
 753      any OS which has RLIMIT_AS also has a working mmap that GCC will use.  */
 754   if (getrlimit (RLIMIT_AS, &rlim) == 0
 755       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
 756       && rlim.rlim_cur < limit)
 757     limit = rlim.rlim_cur;
 758 # elif defined (RLIMIT_DATA)
 759   /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
 760      might be on an OS that has a broken mmap.  (Others don't bound
 761      mmap at all, apparently.)  */
 762   if (getrlimit (RLIMIT_DATA, &rlim) == 0
 763       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
 764       && rlim.rlim_cur < limit
 765       /* Darwin has this horribly bogus default setting of
 766          RLIMIT_DATA, to 6144Kb.  No-one notices because RLIMIT_DATA
 767          appears to be ignored.  Ignore such silliness.  If a limit
 768          this small was actually effective for mmap, GCC wouldn't even
 769          start up.  */
 770       && rlim.rlim_cur >= 8 * 1024 * 1024)
 771     limit = rlim.rlim_cur;
 772 # endif /* RLIMIT_AS or RLIMIT_DATA */
 773 #endif /* HAVE_GETRLIMIT */
 774
 775   return limit;
 776 }
 777
 778 /* Heuristic to set a default for GGC_MIN_EXPAND.  */
 779 int
 780 ggc_min_expand_heuristic (void)
 781 {
 782   double min_expand = physmem_total();
 783
 784   /* Adjust for rlimits.  */
 785   min_expand = ggc_rlimit_bound (min_expand);
 786
 787   /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
 788      a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB).  */
 789   min_expand /= 1024*1024*1024;
 790   min_expand *= 70;
 791   min_expand = MIN (min_expand, 70);
 792   min_expand += 30;
 793
 794   return min_expand;
 795 }
 796
 797 /* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
 798 int
 799 ggc_min_heapsize_heuristic (void)
 800 {
 801   double phys_kbytes = physmem_total();
 802   double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
 803
 804   phys_kbytes /= 1024; /* Convert to Kbytes.  */
 805   limit_kbytes /= 1024;
 806
 807   /* The heuristic is RAM/8, with a lower bound of 4M and an upper
 808      bound of 128M (when RAM >= 1GB).  */
 809   phys_kbytes /= 8;
 810
 811 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
 812   /* Try not to overrun the RSS limit while doing garbage collection.
 813      The RSS limit is only advisory, so no margin is subtracted.  */
 814  {
 815    struct rlimit rlim;
 816    if (getrlimit (RLIMIT_RSS, &rlim) == 0
 817        && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
 818      phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
 819  }
 820 # endif
 821
 822   /* Don't blindly run over our data limit; do GC at least when the
 823      *next* GC would be within 20Mb of the limit or within a quarter of
 824      the limit, whichever is larger.  If GCC does hit the data limit,
 825      compilation will fail, so this tries to be conservative.  */
 826   limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024));
 827   limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
 828   phys_kbytes = MIN (phys_kbytes, limit_kbytes);
 829
 830   phys_kbytes = MAX (phys_kbytes, 4 * 1024);
 831   phys_kbytes = MIN (phys_kbytes, 128 * 1024);
 832
 833   return phys_kbytes;
 834 }
 835
 836 void
 837 init_ggc_heuristics (void)
 838 {
 839 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
 840   set_param_value ("ggc-min-expand", ggc_min_expand_heuristic());
 841   set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
 842 #endif
 843 }
 844
 845 #ifdef GATHER_STATISTICS
 846
 847 /* Datastructure used to store per-call-site statistics.  */
 848 struct loc_descriptor
 849 {
 850   const char *file;
 851   int line;
 852   const char *function;
 853   int times;
 854   size_t allocated;
 855   size_t overhead;
 856   size_t freed;
 857   size_t collected;
 858 };
 859
 860 /* Hashtable used for statistics.  */
 861 static htab_t loc_hash;
 862
 863 /* Hash table helpers functions.  */
 864 static hashval_t
 865 hash_descriptor (const void *p)
 866 {
 867   const struct loc_descriptor *const d = (const struct loc_descriptor *) p;
 868
 869   return htab_hash_pointer (d->function) | d->line;
 870 }
 871
 872 static int
 873 eq_descriptor (const void *p1, const void *p2)
 874 {
 875   const struct loc_descriptor *const d = (const struct loc_descriptor *) p1;
 876   const struct loc_descriptor *const d2 = (const struct loc_descriptor *) p2;
 877
 878   return (d->file == d2->file && d->line == d2->line
 879           && d->function == d2->function);
 880 }
 881
 882 /* Hashtable converting address of allocated field to loc descriptor.  */
 883 static htab_t ptr_hash;
 884 struct ptr_hash_entry
 885 {
 886   void *ptr;
 887   struct loc_descriptor *loc;
 888   size_t size;
 889 };
 890
 891 /* Hash table helpers functions.  */
 892 static hashval_t
 893 hash_ptr (const void *p)
 894 {
 895   const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p;
 896
 897   return htab_hash_pointer (d->ptr);
 898 }
 899
 900 static int
 901 eq_ptr (const void *p1, const void *p2)
 902 {
 903   const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1;
 904
 905   return (p->ptr == p2);
 906 }
 907
 908 /* Return descriptor for given call site, create new one if needed.  */
 909 static struct loc_descriptor *
 910 loc_descriptor (const char *name, int line, const char *function)
 911 {
 912   struct loc_descriptor loc;
 913   struct loc_descriptor **slot;
 914
 915   loc.file = name;
 916   loc.line = line;
 917   loc.function = function;
 918   if (!loc_hash)
 919     loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
 920
 921   slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, INSERT);
 922   if (*slot)
 923     return *slot;
 924   *slot = XCNEW (struct loc_descriptor);
 925   (*slot)->file = name;
 926   (*slot)->line = line;
 927   (*slot)->function = function;
 928   return *slot;
 929 }
 930
 931 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION).  */
 932 void
 933 ggc_record_overhead (size_t allocated, size_t overhead, void *ptr,
 934                      const char *name, int line, const char *function)
 935 {
 936   struct loc_descriptor *loc = loc_descriptor (name, line, function);
 937   struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
 938   PTR *slot;
 939
 940   p->ptr = ptr;
 941   p->loc = loc;
 942   p->size = allocated + overhead;
 943   if (!ptr_hash)
 944     ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
 945   slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
 946   gcc_assert (!*slot);
 947   *slot = p;
 948
 949   loc->times++;
 950   loc->allocated+=allocated;
 951   loc->overhead+=overhead;
 952 }
 953
 954 /* Helper function for prune_overhead_list.  See if SLOT is still marked and
 955    remove it from hashtable if it is not.  */
 956 static int
 957 ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED)
 958 {
 959   struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
 960   if (!ggc_marked_p (p->ptr))
 961     {
 962       p->loc->collected += p->size;
 963       htab_clear_slot (ptr_hash, slot);
 964       free (p);
 965     }
 966   return 1;
 967 }
 968
 969 /* After live values has been marked, walk all recorded pointers and see if
 970    they are still live.  */
 971 void
 972 ggc_prune_overhead_list (void)
 973 {
 974   htab_traverse (ptr_hash, ggc_prune_ptr, NULL);
 975 }
 976
 977 /* Notice that the pointer has been freed.  */
 978 void
 979 ggc_free_overhead (void *ptr)
 980 {
 981   PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
 982                                         NO_INSERT);
 983   struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
 984   p->loc->freed += p->size;
 985   htab_clear_slot (ptr_hash, slot);
 986   free (p);
 987 }
 988
 989 /* Helper for qsort; sort descriptors by amount of memory consumed.  */
 990 static int
 991 final_cmp_statistic (const void *loc1, const void *loc2)
 992 {
 993   const struct loc_descriptor *const l1 =
 994     *(const struct loc_descriptor *const *) loc1;
 995   const struct loc_descriptor *const l2 =
 996     *(const struct loc_descriptor *const *) loc2;
 997   long diff;
 998   diff = ((long)(l1->allocated + l1->overhead - l1->freed) -
 999           (l2->allocated + l2->overhead - l2->freed));
1000   return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1001 }
1002
1003 /* Helper for qsort; sort descriptors by amount of memory consumed.  */
1004 static int
1005 cmp_statistic (const void *loc1, const void *loc2)
1006 {
1007   const struct loc_descriptor *const l1 =
1008     *(const struct loc_descriptor *const *) loc1;
1009   const struct loc_descriptor *const l2 =
1010     *(const struct loc_descriptor *const *) loc2;
1011   long diff;
1012
1013   diff = ((long)(l1->allocated + l1->overhead - l1->freed - l1->collected) -
1014           (l2->allocated + l2->overhead - l2->freed - l2->collected));
1015   if (diff)
1016     return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1017   diff =  ((long)(l1->allocated + l1->overhead - l1->freed) -
1018            (l2->allocated + l2->overhead - l2->freed));
1019   return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1020 }
1021
1022 /* Collect array of the descriptors from hashtable.  */
1023 static struct loc_descriptor **loc_array;
1024 static int
1025 add_statistics (void **slot, void *b)
1026 {
1027   int *n = (int *)b;
1028   loc_array[*n] = (struct loc_descriptor *) *slot;
1029   (*n)++;
1030   return 1;
1031 }
1032
1033 /* Dump per-site memory statistics.  */
1034 #endif
1035 void
1036 dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED)
1037 {
1038 #ifdef GATHER_STATISTICS
1039   int nentries = 0;
1040   char s[4096];
1041   size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
1042   int i;
1043
1044   ggc_force_collect = true;
1045   ggc_collect ();
1046
1047   loc_array = XCNEWVEC (struct loc_descriptor *, loc_hash->n_elements);
1048   fprintf (stderr, "-------------------------------------------------------\n");
1049   fprintf (stderr, "\n%-48s %10s       %10s       %10s       %10s       %10s\n",
1050            "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
1051   fprintf (stderr, "-------------------------------------------------------\n");
1052   htab_traverse (loc_hash, add_statistics, &nentries);
1053   qsort (loc_array, nentries, sizeof (*loc_array),
1054          final ? final_cmp_statistic : cmp_statistic);
1055   for (i = 0; i < nentries; i++)
1056     {
1057       struct loc_descriptor *d = loc_array[i];
1058       allocated += d->allocated;
1059       times += d->times;
1060       freed += d->freed;
1061       collected += d->collected;
1062       overhead += d->overhead;
1063     }
1064   for (i = 0; i < nentries; i++)
1065     {
1066       struct loc_descriptor *d = loc_array[i];
1067       if (d->allocated)
1068         {
1069           const char *s1 = d->file;
1070           const char *s2;
1071           while ((s2 = strstr (s1, "gcc/")))
1072             s1 = s2 + 4;
1073           sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
1074           s[48] = 0;
1075           fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s,
1076                    (long)d->collected,
1077                    (d->collected) * 100.0 / collected,
1078                    (long)d->freed,
1079                    (d->freed) * 100.0 / freed,
1080                    (long)(d->allocated + d->overhead - d->freed - d->collected),
1081                    (d->allocated + d->overhead - d->freed - d->collected) * 100.0
1082                    / (allocated + overhead - freed - collected),
1083                    (long)d->overhead,
1084                    d->overhead * 100.0 / overhead,
1085                    (long)d->times);
1086         }
1087     }
1088   fprintf (stderr, "%-48s %10ld       %10ld       %10ld       %10ld       %10ld\n",
1089            "Total", (long)collected, (long)freed,
1090            (long)(allocated + overhead - freed - collected), (long)overhead,
1091            (long)times);
1092   fprintf (stderr, "%-48s %10s       %10s       %10s       %10s       %10s\n",
1093            "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
1094   fprintf (stderr, "-------------------------------------------------------\n");
1095   ggc_force_collect = false;
1096 #endif
1097 }