OSDN Git Service

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