CbC/CbC_gcc: gcc/ggc-common.c comparison

comparison gcc/ggc-common.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Simple garbage collection for the GNU compiler.
-Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-Free Software Foundation, Inc.
+2009, 2010 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "hashtab.h"
 #include "ggc.h"
-#include "toplev.h"
+#include "ggc-internal.h"
+#include "diagnostic-core.h"
 #include "params.h"
 #include "hosthooks.h"
 #include "hosthooks-def.h"
 #include "plugin.h"
 #include "vec.h"
 #include "timevar.h"
-#ifdef HAVE_SYS_RESOURCE_H
-# include <sys/resource.h>
-#endif
-#ifdef HAVE_MMAP_FILE
-# include <sys/mman.h>
-# ifdef HAVE_MINCORE
-/* This is on Solaris.  */
-#  include <sys/types.h>
-# endif
-#endif
-#ifndef MAP_FAILED
-# define MAP_FAILED ((void *)-1)
-#endif
 /* When set, ggc_collect will do collection.  */
 bool ggc_force_collect;
 /* When true, protect the contents of the identifier hash table.  */
 static int call_alloc (void **, void *);
 static int compare_ptr_data (const void *, const void *);
 static void relocate_ptrs (void *, void *);
 static void write_pch_globals (const struct ggc_root_tab * const *tab,
 			       struct traversal_state *state);
-static double ggc_rlimit_bound (double);
 /* Maintain global roots that are preserved during GC.  */
 /* Process a slot of an htab by deleting it if it has not been marked.  */
 CONST_CAST (void *, (const void *)cti));
 ggc_set_mark ((*cti->base)->entries);
 }
 }
+/* Mark all the roots in the table RT.  */
+static void
+ggc_mark_root_tab (const_ggc_root_tab_t rt)
+{
+size_t i;
+for ( ; rt->base != NULL; rt++)
+for (i = 0; i < rt->nelt; i++)
+(*rt->cb) (*(void **) ((char *)rt->base + rt->stride * i));
+}
 /* Iterate through all registered roots and mark each element.  */
 void
 ggc_mark_roots (void)
 {
 const struct ggc_root_tab *const *rt;
-const struct ggc_root_tab *rti;
+const_ggc_root_tab_t rtp, rti;
-const_ggc_root_tab_t rtp;
 const struct ggc_cache_tab *const *ct;
 const_ggc_cache_tab_t ctp;
 size_t i;
 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
 for (rti = *rt; rti->base != NULL; rti++)
 memset (rti->base, 0, rti->stride);
 for (rt = gt_ggc_rtab; *rt; rt++)
-for (rti = *rt; rti->base != NULL; rti++)
+ggc_mark_root_tab (*rt);
-for (i = 0; i < rti->nelt; i++)
-	(*rti->cb) (*(void **)((char *)rti->base + rti->stride * i));
+FOR_EACH_VEC_ELT (const_ggc_root_tab_t, extra_root_vec, i, rtp)
+ggc_mark_root_tab (rtp);
-for (i = 0; VEC_iterate (const_ggc_root_tab_t, extra_root_vec, i, rtp); i++)
-{
-for (rti = rtp; rti->base != NULL; rti++)
-for (i = 0; i < rti->nelt; i++)
-(*rti->cb) (*(void **) ((char *)rti->base + rti->stride * i));
-}
 if (ggc_protect_identifiers)
 ggc_mark_stringpool ();
 /* Now scan all hash tables that have objects which are to be deleted if
 they are not already marked.  */
 for (ct = gt_ggc_cache_rtab; *ct; ct++)
 ggc_scan_cache_tab (*ct);
-for (i = 0; VEC_iterate (const_ggc_cache_tab_t, extra_cache_vec, i, ctp); i++)
+FOR_EACH_VEC_ELT (const_ggc_cache_tab_t, extra_cache_vec, i, ctp)
 ggc_scan_cache_tab (ctp);
 if (! ggc_protect_identifiers)
 ggc_purge_stringpool ();
 invoke_plugin_callbacks (PLUGIN_GGC_MARKING, NULL);
 }
 /* Allocate a block of memory, then clear it.  */
 void *
-ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
+ggc_internal_cleared_alloc_stat (size_t size MEM_STAT_DECL)
 {
-void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
+void *buf = ggc_internal_alloc_stat (size PASS_MEM_STAT);
 memset (buf, 0, size);
 return buf;
 }
 /* Resize a block of memory, possibly re-allocating it.  */
 {
 void *r;
 size_t old_size;
 if (x == NULL)
-return ggc_alloc_stat (size PASS_MEM_STAT);
+return ggc_internal_alloc_stat (size PASS_MEM_STAT);
 old_size = ggc_get_size (x);
 if (size <= old_size)
 {
 						    old_size - size));
 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
 return x;
 }
-r = ggc_alloc_stat (size PASS_MEM_STAT);
+r = ggc_internal_alloc_stat (size PASS_MEM_STAT);
 /* Since ggc_get_size returns the size of the pool, not the size of the
 individually allocated object, we'd access parts of the old object
 that were marked invalid with the memcpy below.  We lose a bit of the
 initialization-tracking since some of it may be uninitialized.  */
 ggc_free (x);
 return r;
 }
-/* Like ggc_alloc_cleared, but performs a multiplication.  */
 void *
-ggc_calloc (size_t s1, size_t s2)
+ggc_cleared_alloc_htab_ignore_args (size_t c ATTRIBUTE_UNUSED,
-{
+				    size_t n ATTRIBUTE_UNUSED)
-return ggc_alloc_cleared (s1 * s2);
+{
+gcc_assert (c * n == sizeof (struct htab));
+return ggc_alloc_cleared_htab ();
+}
+/* TODO: once we actually use type information in GGC, create a new tag
+gt_gcc_ptr_array and use it for pointer arrays.  */
+void *
+ggc_cleared_alloc_ptr_array_two_args (size_t c, size_t n)
+{
+gcc_assert (sizeof (PTR *) == n);
+return ggc_internal_cleared_vec_alloc (sizeof (PTR *), c);
 }
 /* These are for splay_tree_new_ggc.  */
 void *
-ggc_splay_alloc (int sz, void *nl)
+ggc_splay_alloc (enum gt_types_enum obj_type ATTRIBUTE_UNUSED, int sz,
+		 void *nl)
 {
 gcc_assert (!nl);
-return ggc_alloc (sz);
+return ggc_internal_alloc (sz);
 }
 void
 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
 {
 	  struct ptr_data *new_ptr;
 	  if (ptr == NULL || ptr == (void *)1)
 	    {
 	      if (fwrite (&ptr, sizeof (void *), 1, state->f)
 		  != 1)
-		fatal_error ("can't write PCH file: %m");
+		fatal_error ("can%'t write PCH file: %m");
 	    }
 	  else
 	    {
 	      new_ptr = (struct ptr_data *)
 		htab_find_with_hash (saving_htab, ptr, POINTER_HASH (ptr));
 	      if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
 		  != 1)
-		fatal_error ("can't write PCH file: %m");
+		fatal_error ("can%'t write PCH file: %m");
 	    }
 	}
 }
 /* Hold the information we need to mmap the file back in.  */
 for (i = 0; i < rti->nelt; i++)
 	(*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 /* Prepare the objects for writing, determine addresses and such.  */
 state.f = f;
-state.d = init_ggc_pch();
+state.d = init_ggc_pch ();
 state.count = 0;
 htab_traverse (saving_htab, call_count, &state);
 mmi.size = ggc_pch_total_size (state.d);
 /* Write out all the scalar variables.  */
 for (rt = gt_pch_scalar_rtab; *rt; rt++)
 for (rti = *rt; rti->base != NULL; rti++)
 if (fwrite (rti->base, rti->stride, 1, f) != 1)
-	fatal_error ("can't write PCH file: %m");
+	fatal_error ("can%'t write PCH file: %m");
 /* Write out all the global pointers, after translation.  */
 write_pch_globals (gt_ggc_rtab, &state);
 write_pch_globals (gt_pch_cache_rtab, &state);
 granularity (usually page) boundary.  */
 {
 long o;
 o = ftell (state.f) + sizeof (mmi);
 if (o == -1)
-fatal_error ("can't get position in PCH file: %m");
+fatal_error ("can%'t get position in PCH file: %m");
 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
 if (mmi.offset == mmap_offset_alignment)
 mmi.offset = 0;
 mmi.offset += o;
 }
 if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
-fatal_error ("can't write PCH file: %m");
+fatal_error ("can%'t write PCH file: %m");
 if (mmi.offset != 0
 && fseek (state.f, mmi.offset, SEEK_SET) != 0)
-fatal_error ("can't write padding to PCH file: %m");
+fatal_error ("can%'t write padding to PCH file: %m");
 ggc_pch_prepare_write (state.d, state.f);
 /* Actually write out the objects.  */
 for (i = 0; i < state.count; i++)
 /* Read in all the scalar variables.  */
 for (rt = gt_pch_scalar_rtab; *rt; rt++)
 for (rti = *rt; rti->base != NULL; rti++)
 if (fread (rti->base, rti->stride, 1, f) != 1)
-	fatal_error ("can't read PCH file: %m");
+	fatal_error ("can%'t read PCH file: %m");
 /* Read in all the global pointers, in 6 easy loops.  */
 for (rt = gt_ggc_rtab; *rt; rt++)
 for (rti = *rt; rti->base != NULL; rti++)
 for (i = 0; i < rti->nelt; i++)
 	if (fread ((char *)rti->base + rti->stride * i,
 		   sizeof (void *), 1, f) != 1)
-	  fatal_error ("can't read PCH file: %m");
+	  fatal_error ("can%'t read PCH file: %m");
 for (rt = gt_pch_cache_rtab; *rt; rt++)
 for (rti = *rt; rti->base != NULL; rti++)
 for (i = 0; i < rti->nelt; i++)
 	if (fread ((char *)rti->base + rti->stride * i,
 		   sizeof (void *), 1, f) != 1)
-	  fatal_error ("can't read PCH file: %m");
+	  fatal_error ("can%'t read PCH file: %m");
 if (fread (&mmi, sizeof (mmi), 1, f) != 1)
-fatal_error ("can't read PCH file: %m");
+fatal_error ("can%'t read PCH file: %m");
 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
 					  fileno (f), mmi.offset);
 if (result < 0)
 fatal_error ("had to relocate PCH");
 if (result == 0)
 {
 if (fseek (f, mmi.offset, SEEK_SET) != 0
 	  || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
-	fatal_error ("can't read PCH file: %m");
+	fatal_error ("can%'t read PCH file: %m");
 }
 else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
-fatal_error ("can't read PCH file: %m");
+fatal_error ("can%'t read PCH file: %m");
 ggc_pch_read (f, mmi.preferred_base);
 gt_pch_restore_stringpool ();
 }
 	       fd, offset);
 return addr == base ? 1 : -1;
 }
 #endif /* HAVE_MMAP_FILE */
+#if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
 /* Modify the bound based on rlimits.  */
 static double
 ggc_rlimit_bound (double limit)
 {
 return limit;
 }
 /* Heuristic to set a default for GGC_MIN_EXPAND.  */
-int
+static int
 ggc_min_expand_heuristic (void)
 {
 double min_expand = physmem_total();
 /* Adjust for rlimits.  */
 return min_expand;
 }
 /* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
-int
+static int
 ggc_min_heapsize_heuristic (void)
 {
 double phys_kbytes = physmem_total();
 double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
 /* Don't blindly run over our data limit; do GC at least when the
 *next* GC would be within 20Mb of the limit or within a quarter of
 the limit, whichever is larger.  If GCC does hit the data limit,
 compilation will fail, so this tries to be conservative.  */
 limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024));
-limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
+limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic ());
 phys_kbytes = MIN (phys_kbytes, limit_kbytes);
 phys_kbytes = MAX (phys_kbytes, 4 * 1024);
 phys_kbytes = MIN (phys_kbytes, 128 * 1024);
 return phys_kbytes;
 }
+#endif
 void
 init_ggc_heuristics (void)
 {
 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
-set_param_value ("ggc-min-expand", ggc_min_expand_heuristic());
+set_default_param_value (GGC_MIN_EXPAND, ggc_min_expand_heuristic ());
-set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
+set_default_param_value (GGC_MIN_HEAPSIZE, ggc_min_heapsize_heuristic ());
 #endif
 }
 #ifdef GATHER_STATISTICS
 void
 ggc_free_overhead (void *ptr)
 {
 PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
 					NO_INSERT);
-struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
+struct ptr_hash_entry *p;
+/* The pointer might be not found if a PCH read happened between allocation
+and ggc_free () call.  FIXME: account memory properly in the presence of
+PCH. */
+if (!slot)
+return;
+p = (struct ptr_hash_entry *) *slot;
 p->loc->freed += p->size;
 htab_clear_slot (ptr_hash, slot);
 free (p);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ggc-common.c @ 67:f6334be47118