gcc/ggc-common.c

   1 /* Simple garbage collection for the GNU compiler.
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
   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 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* Generic garbage collection (GC) functions and data, not specific to
  23    any particular GC implementation.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "hashtab.h"
  29 #include "ggc.h"
  30 #include "toplev.h"
  31 #include "params.h"
  32 #include "hosthooks.h"
  33 #include "hosthooks-def.h"
  34
  35 #ifdef HAVE_SYS_RESOURCE_H
  36 # include <sys/resource.h>
  37 #endif
  38
  39 #ifdef HAVE_MMAP_FILE
  40 # include <sys/mman.h>
  41 # ifdef HAVE_MINCORE
  42 /* This is on Solaris.  */
  43 #  include <sys/types.h>
  44 # endif
  45 #endif
  46
  47 #ifndef MAP_FAILED
  48 # define MAP_FAILED ((void *)-1)
  49 #endif
  50
  51 #ifdef ENABLE_VALGRIND_CHECKING
  52 # ifdef HAVE_VALGRIND_MEMCHECK_H
  53 #  include <valgrind/memcheck.h>
  54 # elif defined HAVE_MEMCHECK_H
  55 #  include <memcheck.h>
  56 # else
  57 #  include <valgrind.h>
  58 # endif
  59 #else
  60 /* Avoid #ifdef:s when we can help it.  */
  61 #define VALGRIND_DISCARD(x)
  62 #endif
  63
  64 /* Statistics about the allocation.  */
  65 static ggc_statistics *ggc_stats;
  66
  67 struct traversal_state;
  68
  69 static int ggc_htab_delete (void **, void *);
  70 static hashval_t saving_htab_hash (const void *);
  71 static int saving_htab_eq (const void *, const void *);
  72 static int call_count (void **, void *);
  73 static int call_alloc (void **, void *);
  74 static int compare_ptr_data (const void *, const void *);
  75 static void relocate_ptrs (void *, void *);
  76 static void write_pch_globals (const struct ggc_root_tab * const *tab,
  77                                struct traversal_state *state);
  78 static double ggc_rlimit_bound (double);
  79
  80 /* Maintain global roots that are preserved during GC.  */
  81
  82 /* Process a slot of an htab by deleting it if it has not been marked.  */
  83
  84 static int
  85 ggc_htab_delete (void **slot, void *info)
  86 {
  87   const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
  88
  89   if (! (*r->marked_p) (*slot))
  90     htab_clear_slot (*r->base, slot);
  91   else
  92     (*r->cb) (*slot);
  93
  94   return 1;
  95 }
  96
  97 /* Iterate through all registered roots and mark each element.  */
  98
  99 void
 100 ggc_mark_roots (void)
 101 {
 102   const struct ggc_root_tab *const *rt;
 103   const struct ggc_root_tab *rti;
 104   const struct ggc_cache_tab *const *ct;
 105   const struct ggc_cache_tab *cti;
 106   size_t i;
 107
 108   for (rt = gt_ggc_deletable_rtab; *rt; rt++)
 109     for (rti = *rt; rti->base != NULL; rti++)
 110       memset (rti->base, 0, rti->stride);
 111
 112   for (rt = gt_ggc_rtab; *rt; rt++)
 113     for (rti = *rt; rti->base != NULL; rti++)
 114       for (i = 0; i < rti->nelt; i++)
 115         (*rti->cb)(*(void **)((char *)rti->base + rti->stride * i));
 116
 117   ggc_mark_stringpool ();
 118
 119   /* Now scan all hash tables that have objects which are to be deleted if
 120      they are not already marked.  */
 121   for (ct = gt_ggc_cache_rtab; *ct; ct++)
 122     for (cti = *ct; cti->base != NULL; cti++)
 123       if (*cti->base)
 124         {
 125           ggc_set_mark (*cti->base);
 126           htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti);
 127           ggc_set_mark ((*cti->base)->entries);
 128         }
 129 }
 130
 131 /* Allocate a block of memory, then clear it.  */
 132 void *
 133 ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
 134 {
 135   void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
 136   memset (buf, 0, size);
 137   return buf;
 138 }
 139
 140 /* Resize a block of memory, possibly re-allocating it.  */
 141 void *
 142 ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
 143 {
 144   void *r;
 145   size_t old_size;
 146
 147   if (x == NULL)
 148     return ggc_alloc_stat (size PASS_MEM_STAT);
 149
 150   old_size = ggc_get_size (x);
 151
 152   if (size <= old_size)
 153     {
 154       /* Mark the unwanted memory as unaccessible.  We also need to make
 155          the "new" size accessible, since ggc_get_size returns the size of
 156          the pool, not the size of the individually allocated object, the
 157          size which was previously made accessible.  Unfortunately, we
 158          don't know that previously allocated size.  Without that
 159          knowledge we have to lose some initialization-tracking for the
 160          old parts of the object.  An alternative is to mark the whole
 161          old_size as reachable, but that would lose tracking of writes
 162          after the end of the object (by small offsets).  Discard the
 163          handle to avoid handle leak.  */
 164       VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
 165                                                 old_size - size));
 166       VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
 167       return x;
 168     }
 169
 170   r = ggc_alloc_stat (size PASS_MEM_STAT);
 171
 172   /* Since ggc_get_size returns the size of the pool, not the size of the
 173      individually allocated object, we'd access parts of the old object
 174      that were marked invalid with the memcpy below.  We lose a bit of the
 175      initialization-tracking since some of it may be uninitialized.  */
 176   VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
 177
 178   memcpy (r, x, old_size);
 179
 180   /* The old object is not supposed to be used anymore.  */
 181   ggc_free (x);
 182
 183   return r;
 184 }
 185
 186 /* Like ggc_alloc_cleared, but performs a multiplication.  */
 187 void *
 188 ggc_calloc (size_t s1, size_t s2)
 189 {
 190   return ggc_alloc_cleared (s1 * s2);
 191 }
 192
 193 /* These are for splay_tree_new_ggc.  */
 194 void *
 195 ggc_splay_alloc (int sz, void *nl)
 196 {
 197   if (nl != NULL)
 198     abort ();
 199   return ggc_alloc (sz);
 200 }
 201
 202 void
 203 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
 204 {
 205   if (nl != NULL)
 206     abort ();
 207 }
 208
 209 /* Print statistics that are independent of the collector in use.  */
 210 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
 211                   ? (x) \
 212                   : ((x) < 1024*1024*10 \
 213                      ? (x) / 1024 \
 214                      : (x) / (1024*1024))))
 215 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
 216
 217 void
 218 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
 219                              ggc_statistics *stats)
 220 {
 221   /* Set the pointer so that during collection we will actually gather
 222      the statistics.  */
 223   ggc_stats = stats;
 224
 225   /* Then do one collection to fill in the statistics.  */
 226   ggc_collect ();
 227
 228   /* At present, we don't really gather any interesting statistics.  */
 229
 230   /* Don't gather statistics any more.  */
 231   ggc_stats = NULL;
 232 }
 233 \f
 234 /* Functions for saving and restoring GCable memory to disk.  */
 235
 236 static htab_t saving_htab;
 237
 238 struct ptr_data
 239 {
 240   void *obj;
 241   void *note_ptr_cookie;
 242   gt_note_pointers note_ptr_fn;
 243   gt_handle_reorder reorder_fn;
 244   size_t size;
 245   void *new_addr;
 246 };
 247
 248 #define POINTER_HASH(x) (hashval_t)((long)x >> 3)
 249
 250 /* Register an object in the hash table.  */
 251
 252 int
 253 gt_pch_note_object (void *obj, void *note_ptr_cookie,
 254                     gt_note_pointers note_ptr_fn)
 255 {
 256   struct ptr_data **slot;
 257
 258   if (obj == NULL || obj == (void *) 1)
 259     return 0;
 260
 261   slot = (struct ptr_data **)
 262     htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
 263                               INSERT);
 264   if (*slot != NULL)
 265     {
 266       if ((*slot)->note_ptr_fn != note_ptr_fn
 267           || (*slot)->note_ptr_cookie != note_ptr_cookie)
 268         abort ();
 269       return 0;
 270     }
 271
 272   *slot = xcalloc (sizeof (struct ptr_data), 1);
 273   (*slot)->obj = obj;
 274   (*slot)->note_ptr_fn = note_ptr_fn;
 275   (*slot)->note_ptr_cookie = note_ptr_cookie;
 276   if (note_ptr_fn == gt_pch_p_S)
 277     (*slot)->size = strlen (obj) + 1;
 278   else
 279     (*slot)->size = ggc_get_size (obj);
 280   return 1;
 281 }
 282
 283 /* Register an object in the hash table.  */
 284
 285 void
 286 gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
 287                      gt_handle_reorder reorder_fn)
 288 {
 289   struct ptr_data *data;
 290
 291   if (obj == NULL || obj == (void *) 1)
 292     return;
 293
 294   data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
 295   if (data == NULL
 296       || data->note_ptr_cookie != note_ptr_cookie)
 297     abort ();
 298
 299   data->reorder_fn = reorder_fn;
 300 }
 301
 302 /* Hash and equality functions for saving_htab, callbacks for htab_create.  */
 303
 304 static hashval_t
 305 saving_htab_hash (const void *p)
 306 {
 307   return POINTER_HASH (((struct ptr_data *)p)->obj);
 308 }
 309
 310 static int
 311 saving_htab_eq (const void *p1, const void *p2)
 312 {
 313   return ((struct ptr_data *)p1)->obj == p2;
 314 }
 315
 316 /* Handy state for the traversal functions.  */
 317
 318 struct traversal_state
 319 {
 320   FILE *f;
 321   struct ggc_pch_data *d;
 322   size_t count;
 323   struct ptr_data **ptrs;
 324   size_t ptrs_i;
 325 };
 326
 327 /* Callbacks for htab_traverse.  */
 328
 329 static int
 330 call_count (void **slot, void *state_p)
 331 {
 332   struct ptr_data *d = (struct ptr_data *)*slot;
 333   struct traversal_state *state = (struct traversal_state *)state_p;
 334
 335   ggc_pch_count_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);
 336   state->count++;
 337   return 1;
 338 }
 339
 340 static int
 341 call_alloc (void **slot, void *state_p)
 342 {
 343   struct ptr_data *d = (struct ptr_data *)*slot;
 344   struct traversal_state *state = (struct traversal_state *)state_p;
 345
 346   d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);
 347   state->ptrs[state->ptrs_i++] = d;
 348   return 1;
 349 }
 350
 351 /* Callback for qsort.  */
 352
 353 static int
 354 compare_ptr_data (const void *p1_p, const void *p2_p)
 355 {
 356   struct ptr_data *p1 = *(struct ptr_data *const *)p1_p;
 357   struct ptr_data *p2 = *(struct ptr_data *const *)p2_p;
 358   return (((size_t)p1->new_addr > (size_t)p2->new_addr)
 359           - ((size_t)p1->new_addr < (size_t)p2->new_addr));
 360 }
 361
 362 /* Callbacks for note_ptr_fn.  */
 363
 364 static void
 365 relocate_ptrs (void *ptr_p, void *state_p)
 366 {
 367   void **ptr = (void **)ptr_p;
 368   struct traversal_state *state ATTRIBUTE_UNUSED
 369     = (struct traversal_state *)state_p;
 370   struct ptr_data *result;
 371
 372   if (*ptr == NULL || *ptr == (void *)1)
 373     return;
 374
 375   result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
 376   if (result == NULL)
 377     abort ();
 378   *ptr = result->new_addr;
 379 }
 380
 381 /* Write out, after relocation, the pointers in TAB.  */
 382 static void
 383 write_pch_globals (const struct ggc_root_tab * const *tab,
 384                    struct traversal_state *state)
 385 {
 386   const struct ggc_root_tab *const *rt;
 387   const struct ggc_root_tab *rti;
 388   size_t i;
 389
 390   for (rt = tab; *rt; rt++)
 391     for (rti = *rt; rti->base != NULL; rti++)
 392       for (i = 0; i < rti->nelt; i++)
 393         {
 394           void *ptr = *(void **)((char *)rti->base + rti->stride * i);
 395           struct ptr_data *new_ptr;
 396           if (ptr == NULL || ptr == (void *)1)
 397             {
 398               if (fwrite (&ptr, sizeof (void *), 1, state->f)
 399                   != 1)
 400                 fatal_error ("can't write PCH file: %m");
 401             }
 402           else
 403             {
 404               new_ptr = htab_find_with_hash (saving_htab, ptr,
 405                                              POINTER_HASH (ptr));
 406               if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
 407                   != 1)
 408                 fatal_error ("can't write PCH file: %m");
 409             }
 410         }
 411 }
 412
 413 /* Hold the information we need to mmap the file back in.  */
 414
 415 struct mmap_info
 416 {
 417   size_t offset;
 418   size_t size;
 419   void *preferred_base;
 420 };
 421
 422 /* Write out the state of the compiler to F.  */
 423
 424 void
 425 gt_pch_save (FILE *f)
 426 {
 427   const struct ggc_root_tab *const *rt;
 428   const struct ggc_root_tab *rti;
 429   size_t i;
 430   struct traversal_state state;
 431   char *this_object = NULL;
 432   size_t this_object_size = 0;
 433   struct mmap_info mmi;
 434   const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
 435
 436   gt_pch_save_stringpool ();
 437
 438   saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
 439
 440   for (rt = gt_ggc_rtab; *rt; rt++)
 441     for (rti = *rt; rti->base != NULL; rti++)
 442       for (i = 0; i < rti->nelt; i++)
 443         (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 444
 445   for (rt = gt_pch_cache_rtab; *rt; rt++)
 446     for (rti = *rt; rti->base != NULL; rti++)
 447       for (i = 0; i < rti->nelt; i++)
 448         (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 449
 450   /* Prepare the objects for writing, determine addresses and such.  */
 451   state.f = f;
 452   state.d = init_ggc_pch();
 453   state.count = 0;
 454   htab_traverse (saving_htab, call_count, &state);
 455
 456   mmi.size = ggc_pch_total_size (state.d);
 457
 458   /* Try to arrange things so that no relocation is necessary, but
 459      don't try very hard.  On most platforms, this will always work,
 460      and on the rest it's a lot of work to do better.
 461      (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
 462      HOST_HOOKS_GT_PCH_USE_ADDRESS.)  */
 463   mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
 464
 465   ggc_pch_this_base (state.d, mmi.preferred_base);
 466
 467   state.ptrs = xmalloc (state.count * sizeof (*state.ptrs));
 468   state.ptrs_i = 0;
 469   htab_traverse (saving_htab, call_alloc, &state);
 470   qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
 471
 472   /* Write out all the scalar variables.  */
 473   for (rt = gt_pch_scalar_rtab; *rt; rt++)
 474     for (rti = *rt; rti->base != NULL; rti++)
 475       if (fwrite (rti->base, rti->stride, 1, f) != 1)
 476         fatal_error ("can't write PCH file: %m");
 477
 478   /* Write out all the global pointers, after translation.  */
 479   write_pch_globals (gt_ggc_rtab, &state);
 480   write_pch_globals (gt_pch_cache_rtab, &state);
 481
 482   ggc_pch_prepare_write (state.d, state.f);
 483
 484   /* Pad the PCH file so that the mmapped area starts on an allocation
 485      granularity (usually page) boundary.  */
 486   {
 487     long o;
 488     o = ftell (state.f) + sizeof (mmi);
 489     if (o == -1)
 490       fatal_error ("can't get position in PCH file: %m");
 491     mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
 492     if (mmi.offset == mmap_offset_alignment)
 493       mmi.offset = 0;
 494     mmi.offset += o;
 495   }
 496   if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
 497     fatal_error ("can't write PCH file: %m");
 498   if (mmi.offset != 0
 499       && fseek (state.f, mmi.offset, SEEK_SET) != 0)
 500     fatal_error ("can't write padding to PCH file: %m");
 501
 502   /* Actually write out the objects.  */
 503   for (i = 0; i < state.count; i++)
 504     {
 505       if (this_object_size < state.ptrs[i]->size)
 506         {
 507           this_object_size = state.ptrs[i]->size;
 508           this_object = xrealloc (this_object, this_object_size);
 509         }
 510       memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
 511       if (state.ptrs[i]->reorder_fn != NULL)
 512         state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,
 513                                    state.ptrs[i]->note_ptr_cookie,
 514                                    relocate_ptrs, &state);
 515       state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj,
 516                                   state.ptrs[i]->note_ptr_cookie,
 517                                   relocate_ptrs, &state);
 518       ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
 519                             state.ptrs[i]->new_addr, state.ptrs[i]->size,
 520                             state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
 521       if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)
 522         memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
 523     }
 524   ggc_pch_finish (state.d, state.f);
 525   gt_pch_fixup_stringpool ();
 526
 527   free (state.ptrs);
 528   htab_delete (saving_htab);
 529 }
 530
 531 /* Read the state of the compiler back in from F.  */
 532
 533 void
 534 gt_pch_restore (FILE *f)
 535 {
 536   const struct ggc_root_tab *const *rt;
 537   const struct ggc_root_tab *rti;
 538   size_t i;
 539   struct mmap_info mmi;
 540   int result;
 541
 542   /* Delete any deletable objects.  This makes ggc_pch_read much
 543      faster, as it can be sure that no GCable objects remain other
 544      than the ones just read in.  */
 545   for (rt = gt_ggc_deletable_rtab; *rt; rt++)
 546     for (rti = *rt; rti->base != NULL; rti++)
 547       memset (rti->base, 0, rti->stride);
 548
 549   /* Read in all the scalar variables.  */
 550   for (rt = gt_pch_scalar_rtab; *rt; rt++)
 551     for (rti = *rt; rti->base != NULL; rti++)
 552       if (fread (rti->base, rti->stride, 1, f) != 1)
 553         fatal_error ("can't read PCH file: %m");
 554
 555   /* Read in all the global pointers, in 6 easy loops.  */
 556   for (rt = gt_ggc_rtab; *rt; rt++)
 557     for (rti = *rt; rti->base != NULL; rti++)
 558       for (i = 0; i < rti->nelt; i++)
 559         if (fread ((char *)rti->base + rti->stride * i,
 560                    sizeof (void *), 1, f) != 1)
 561           fatal_error ("can't read PCH file: %m");
 562
 563   for (rt = gt_pch_cache_rtab; *rt; rt++)
 564     for (rti = *rt; rti->base != NULL; rti++)
 565       for (i = 0; i < rti->nelt; i++)
 566         if (fread ((char *)rti->base + rti->stride * i,
 567                    sizeof (void *), 1, f) != 1)
 568           fatal_error ("can't read PCH file: %m");
 569
 570   if (fread (&mmi, sizeof (mmi), 1, f) != 1)
 571     fatal_error ("can't read PCH file: %m");
 572
 573   result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
 574                                           fileno (f), mmi.offset);
 575   if (result < 0)
 576     fatal_error ("had to relocate PCH");
 577   if (result == 0)
 578     {
 579       if (fseek (f, mmi.offset, SEEK_SET) != 0
 580           || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
 581         fatal_error ("can't read PCH file: %m");
 582     }
 583   else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
 584     fatal_error ("can't read PCH file: %m");
 585
 586   ggc_pch_read (f, mmi.preferred_base);
 587
 588   gt_pch_restore_stringpool ();
 589 }
 590
 591 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
 592    Select no address whatsoever, and let gt_pch_save choose what it will with
 593    malloc, presumably.  */
 594
 595 void *
 596 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
 597                             int fd ATTRIBUTE_UNUSED)
 598 {
 599   return NULL;
 600 }
 601
 602 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
 603    Allocate SIZE bytes with malloc.  Return 0 if the address we got is the
 604    same as base, indicating that the memory has been allocated but needs to
 605    be read in from the file.  Return -1 if the address differs, to relocation
 606    of the PCH file would be required.  */
 607
 608 int
 609 default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
 610                             size_t offset ATTRIBUTE_UNUSED)
 611 {
 612   void *addr = xmalloc (size);
 613   return (addr == base) - 1;
 614 }
 615
 616 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS.   Return the
 617    alignment required for allocating virtual memory. Usually this is the
 618    same as pagesize.  */
 619
 620 size_t
 621 default_gt_pch_alloc_granularity (void)
 622 {
 623   return getpagesize();
 624 }
 625
 626 #if HAVE_MMAP_FILE
 627 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
 628    We temporarily allocate SIZE bytes, and let the kernel place the data
 629    wherever it will.  If it worked, that's our spot, if not we're likely
 630    to be in trouble.  */
 631
 632 void *
 633 mmap_gt_pch_get_address (size_t size, int fd)
 634 {
 635   void *ret;
 636
 637   ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 638   if (ret == (void *) MAP_FAILED)
 639     ret = NULL;
 640   else
 641     munmap (ret, size);
 642
 643   return ret;
 644 }
 645
 646 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
 647    Map SIZE bytes of FD+OFFSET at BASE.  Return 1 if we succeeded at
 648    mapping the data at BASE, -1 if we couldn't.
 649
 650    This version assumes that the kernel honors the START operand of mmap
 651    even without MAP_FIXED if START through START+SIZE are not currently
 652    mapped with something.  */
 653
 654 int
 655 mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
 656 {
 657   void *addr;
 658
 659   /* We're called with size == 0 if we're not planning to load a PCH
 660      file at all.  This allows the hook to free any static space that
 661      we might have allocated at link time.  */
 662   if (size == 0)
 663     return -1;
 664
 665   addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
 666                fd, offset);
 667
 668   return addr == base ? 1 : -1;
 669 }
 670 #endif /* HAVE_MMAP_FILE */
 671
 672 /* Modify the bound based on rlimits.  Keep the smallest number found.  */
 673 static double
 674 ggc_rlimit_bound (double limit)
 675 {
 676 #if defined(HAVE_GETRLIMIT)
 677   struct rlimit rlim;
 678 # ifdef RLIMIT_RSS
 679   if (getrlimit (RLIMIT_RSS, &rlim) == 0
 680       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
 681       && rlim.rlim_cur < limit)
 682     limit = rlim.rlim_cur;
 683 # endif
 684 # ifdef RLIMIT_DATA
 685   if (getrlimit (RLIMIT_DATA, &rlim) == 0
 686       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
 687       && rlim.rlim_cur < limit)
 688     limit = rlim.rlim_cur;
 689 # endif
 690 # ifdef RLIMIT_AS
 691   if (getrlimit (RLIMIT_AS, &rlim) == 0
 692       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
 693       && rlim.rlim_cur < limit)
 694     limit = rlim.rlim_cur;
 695 # endif
 696 #endif /* HAVE_GETRLIMIT */
 697
 698   return limit;
 699 }
 700
 701 /* Heuristic to set a default for GGC_MIN_EXPAND.  */
 702 int
 703 ggc_min_expand_heuristic (void)
 704 {
 705   double min_expand = physmem_total();
 706
 707   /* Adjust for rlimits.  */
 708   min_expand = ggc_rlimit_bound (min_expand);
 709
 710   /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
 711      a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB).  */
 712   min_expand /= 1024*1024*1024;
 713   min_expand *= 70;
 714   min_expand = MIN (min_expand, 70);
 715   min_expand += 30;
 716
 717   return min_expand;
 718 }
 719
 720 /* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
 721 int
 722 ggc_min_heapsize_heuristic (void)
 723 {
 724   double min_heap_kbytes = physmem_total();
 725
 726   /* Adjust for rlimits.  */
 727   min_heap_kbytes = ggc_rlimit_bound (min_heap_kbytes);
 728
 729   min_heap_kbytes /= 1024; /* Convert to Kbytes.  */
 730
 731   /* The heuristic is RAM/8, with a lower bound of 4M and an upper
 732      bound of 128M (when RAM >= 1GB).  */
 733   min_heap_kbytes /= 8;
 734   min_heap_kbytes = MAX (min_heap_kbytes, 4 * 1024);
 735   min_heap_kbytes = MIN (min_heap_kbytes, 128 * 1024);
 736
 737   return min_heap_kbytes;
 738 }
 739
 740 void
 741 init_ggc_heuristics (void)
 742 {
 743 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
 744   set_param_value ("ggc-min-expand", ggc_min_expand_heuristic());
 745   set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
 746 #endif
 747 }
 748
 749 #ifdef GATHER_STATISTICS
 750
 751 /* Datastructure used to store per-call-site statistics.  */
 752 struct loc_descriptor
 753 {
 754   const char *file;
 755   int line;
 756   const char *function;
 757   int times;
 758   size_t allocated;
 759   size_t overhead;
 760 };
 761
 762 /* Hashtable used for statistics.  */
 763 static htab_t loc_hash;
 764
 765 /* Hash table helpers functions.  */
 766 static hashval_t
 767 hash_descriptor (const void *p)
 768 {
 769   const struct loc_descriptor *d = p;
 770
 771   return htab_hash_pointer (d->function) | d->line;
 772 }
 773
 774 static int
 775 eq_descriptor (const void *p1, const void *p2)
 776 {
 777   const struct loc_descriptor *d = p1;
 778   const struct loc_descriptor *d2 = p2;
 779
 780   return (d->file == d2->file && d->line == d2->line
 781           && d->function == d2->function);
 782 }
 783
 784 /* Return descriptor for given call site, create new one if needed.  */
 785 static struct loc_descriptor *
 786 loc_descriptor (const char *name, int line, const char *function)
 787 {
 788   struct loc_descriptor loc;
 789   struct loc_descriptor **slot;
 790
 791   loc.file = name;
 792   loc.line = line;
 793   loc.function = function;
 794   if (!loc_hash)
 795     loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
 796
 797   slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1);
 798   if (*slot)
 799     return *slot;
 800   *slot = xcalloc (sizeof (**slot), 1);
 801   (*slot)->file = name;
 802   (*slot)->line = line;
 803   (*slot)->function = function;
 804   return *slot;
 805 }
 806
 807 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION).  */
 808 void
 809 ggc_record_overhead (size_t allocated, size_t overhead,
 810                      const char *name, int line, const char *function)
 811 {
 812   struct loc_descriptor *loc = loc_descriptor (name, line, function);
 813
 814   loc->times++;
 815   loc->allocated+=allocated;
 816   loc->overhead+=overhead;
 817 }
 818
 819 /* Helper for qsort; sort descriptors by amount of memory consumed.  */
 820 static int
 821 cmp_statistic (const void *loc1, const void *loc2)
 822 {
 823   struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
 824   struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
 825   return (l1->allocated + l1->overhead) - (l2->allocated + l2->overhead);
 826 }
 827
 828 /* Collect array of the descriptors from hashtable.  */
 829 struct loc_descriptor **loc_array;
 830 static int
 831 add_statistics (void **slot, void *b)
 832 {
 833   int *n = (int *)b;
 834   loc_array[*n] = (struct loc_descriptor *) *slot;
 835   (*n)++;
 836   return 1;
 837 }
 838
 839 /* Dump per-site memory statistics.  */
 840 #endif
 841 void dump_ggc_loc_statistics (void)
 842 {
 843 #ifdef GATHER_STATISTICS
 844   int nentries = 0;
 845   char s[4096];
 846   size_t count, size, overhead;
 847   int i;
 848
 849   loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements);
 850   fprintf (stderr, "-------------------------------------------------------\n");
 851   fprintf (stderr, "\n%-60s %10s %10s %10s\n",
 852            "source location", "Times", "Allocated", "Overhead");
 853   fprintf (stderr, "-------------------------------------------------------\n");
 854   count = 0;
 855   size = 0;
 856   overhead = 0;
 857   htab_traverse (loc_hash, add_statistics, &nentries);
 858   qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
 859   for (i = 0; i < nentries; i++)
 860     {
 861       struct loc_descriptor *d = loc_array[i];
 862       size += d->allocated;
 863       count += d->times;
 864       overhead += d->overhead;
 865     }
 866   for (i = 0; i < nentries; i++)
 867     {
 868       struct loc_descriptor *d = loc_array[i];
 869       if (d->allocated)
 870         {
 871           const char *s1 = d->file;
 872           const char *s2;
 873           while ((s2 = strstr (s1, "gcc/")))
 874             s1 = s2 + 4;
 875           sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
 876           fprintf (stderr, "%-60s %10i %10li %10li:%.3f%%\n", s,
 877                    d->times, (long)d->allocated, (long)d->overhead,
 878                    (d->allocated + d->overhead) *100.0 / (size + overhead));
 879         }
 880     }
 881   fprintf (stderr, "%-60s %10ld %10ld %10ld\n",
 882            "Total", (long)count, (long)size, (long)overhead);
 883   fprintf (stderr, "-------------------------------------------------------\n");
 884 #endif
 885 }