CbC/CbC_gcc: gcc/ggc.h comparison

comparison gcc/ggc.h @ 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	77e2b8dfacca
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Garbage collection for the GNU compiler.
 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
-2008, 2009 Free Software Foundation, Inc.
+2008, 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
 /* Symbols are marked with `ggc' for `gcc gc' so as not to interfere with
 an external gc library that might be linked in.  */
 /* Constants for general use.  */
 extern const char empty_string[];	/* empty string */
-extern const char digit_vector[];	/* "0" .. "9" */
-#define digit_string(d) (digit_vector + ((d) * 2))
 /* Internal functions and data structures used by the GTY
-machinery.  */
+machinery, including the generated gt*.[hc] files.  */
 /* The first parameter is a pointer to a pointer, the second a cookie.  */
 typedef void (*gt_pointer_operator) (void *, void *);
 #include "gtype-desc.h"
 /* Return 1 if P has been marked, zero otherwise.
 P must have been allocated by the GC allocator; it mustn't point to
 static objects, stack variables, or memory allocated with malloc.  */
 extern int ggc_marked_p	(const void *);
-/* Mark the entries in the string pool.  */
-extern void ggc_mark_stringpool	(void);
-/* Purge the entries in the string pool.  */
-extern void ggc_purge_stringpool (void);
-/* Call ggc_set_mark on all the roots.  */
-extern void ggc_mark_roots (void);
-/* Save and restore the string pool entries for PCH.  */
-extern void gt_pch_save_stringpool (void);
-extern void gt_pch_fixup_stringpool (void);
-extern void gt_pch_restore_stringpool (void);
 /* PCH and GGC handling for strings, mostly trivial.  */
-extern void gt_pch_p_S (void *, void *, gt_pointer_operator, void *);
 extern void gt_pch_n_S (const void *);
 extern void gt_ggc_m_S (const void *);
+/* End of GTY machinery API.  */
+struct alloc_zone;
 /* Initialize the string pool.  */
 extern void init_stringpool (void);
-/* A GC implementation must provide these functions.  They are internal
-to the GC system.  */
-/* Forward declare the zone structure.  Only ggc_zone implements this.  */
-struct alloc_zone;
 /* Initialize the garbage collector.  */
 extern void init_ggc (void);
-/* Start a new GGC zone.  */
-extern struct alloc_zone *new_ggc_zone (const char *);
-/* Free a complete GGC zone, destroying everything in it.  */
-extern void destroy_ggc_zone (struct alloc_zone *);
-struct ggc_pch_data;
-/* Return a new ggc_pch_data structure.  */
-extern struct ggc_pch_data *init_ggc_pch (void);
-/* The second parameter and third parameters give the address and size
-of an object.  Update the ggc_pch_data structure with as much of
-that information as is necessary. The bool argument should be true
-if the object is a string.  */
-extern void ggc_pch_count_object (struct ggc_pch_data *, void *, size_t, bool,
-				  enum gt_types_enum);
-/* Return the total size of the data to be written to hold all
-the objects previously passed to ggc_pch_count_object.  */
-extern size_t ggc_pch_total_size (struct ggc_pch_data *);
-/* The objects, when read, will most likely be at the address
-in the second parameter.  */
-extern void ggc_pch_this_base (struct ggc_pch_data *, void *);
-/* Assuming that the objects really do end up at the address
-passed to ggc_pch_this_base, return the address of this object.
-The bool argument should be true if the object is a string.  */
-extern char *ggc_pch_alloc_object (struct ggc_pch_data *, void *, size_t, bool,
-				   enum gt_types_enum);
-/* Write out any initial information required.  */
-extern void ggc_pch_prepare_write (struct ggc_pch_data *, FILE *);
-/* Write out this object, including any padding.  The last argument should be
-true if the object is a string.  */
-extern void ggc_pch_write_object (struct ggc_pch_data *, FILE *, void *,
-				  void *, size_t, bool);
-/* All objects have been written, write out any final information
-required.  */
-extern void ggc_pch_finish (struct ggc_pch_data *, FILE *);
-/* A PCH file has just been read in at the address specified second
-parameter.  Set up the GC implementation for the new objects.  */
-extern void ggc_pch_read (FILE *, void *);
-/* Allocation.  */
-/* When set, ggc_collect will do collection.  */
-extern bool ggc_force_collect;
 /* When true, identifier nodes are considered as GC roots.  When
 false, identifier nodes are treated like any other GC-allocated
 object, and the identifier hash table is treated as a weak
 hash.  */
 extern bool ggc_protect_identifiers;
+/* Write out all GCed objects to F.  */
+extern void gt_pch_save (FILE *f);
+/* Allocation.  */
 /* The internal primitive.  */
-extern void *ggc_alloc_stat (size_t MEM_STAT_DECL);
+extern void *ggc_internal_alloc_stat (size_t MEM_STAT_DECL);
-#define ggc_alloc(s) ggc_alloc_stat (s MEM_STAT_INFO)
+#define ggc_internal_alloc(s) ggc_internal_alloc_stat (s MEM_STAT_INFO)
 /* Allocate an object of the specified type and size.  */
 extern void *ggc_alloc_typed_stat (enum gt_types_enum, size_t MEM_STAT_DECL);
-#define ggc_alloc_typed(s,z) ggc_alloc_typed_stat (s,z MEM_STAT_INFO)
-/* Like ggc_alloc, but allocates cleared memory.  */
+#define ggc_alloc_typed(s, z) ggc_alloc_typed_stat (s, z MEM_STAT_INFO)
-extern void *ggc_alloc_cleared_stat (size_t MEM_STAT_DECL);
-#define ggc_alloc_cleared(s) ggc_alloc_cleared_stat (s MEM_STAT_INFO)
+/* Allocates cleared memory.  */
+extern void *ggc_internal_cleared_alloc_stat (size_t MEM_STAT_DECL);
 /* Resize a block.  */
 extern void *ggc_realloc_stat (void *, size_t MEM_STAT_DECL);
-#define ggc_realloc(s,z) ggc_realloc_stat (s,z MEM_STAT_INFO)
-/* Like ggc_alloc_cleared, but performs a multiplication.  */
-extern void *ggc_calloc (size_t, size_t);
 /* Free a block.  To be used when known for certain it's not reachable.  */
 extern void ggc_free (void *);
 extern void ggc_record_overhead (size_t, size_t, void * MEM_STAT_DECL);
 extern void ggc_free_overhead (void *);
 extern void ggc_prune_overhead_list (void);
 extern void dump_ggc_loc_statistics (bool);
-/* Type-safe, C++-friendly versions of ggc_alloc() and gcc_calloc().  */
+/* Reallocators.  */
-#define GGC_NEW(T)		((T *) ggc_alloc (sizeof (T)))
+#define GGC_RESIZEVEC(T, P, N) \
-#define GGC_CNEW(T)		((T *) ggc_alloc_cleared (sizeof (T)))
+((T *) ggc_realloc_stat ((P), (N) * sizeof (T) MEM_STAT_INFO))
-#define GGC_NEWVEC(T, N)	((T *) ggc_alloc ((N) * sizeof(T)))
-#define GGC_CNEWVEC(T, N)	((T *) ggc_alloc_cleared ((N) * sizeof(T)))
+#define GGC_RESIZEVAR(T, P, N)                          \
-#define GGC_RESIZEVEC(T, P, N)  ((T *) ggc_realloc ((P), (N) * sizeof (T)))
+((T *) ggc_realloc_stat ((P), (N) MEM_STAT_INFO))
-#define GGC_NEWVAR(T, S)	((T *) ggc_alloc ((S)))
-#define GGC_CNEWVAR(T, S)	((T *) ggc_alloc_cleared ((S)))
+static inline void *
-#define GGC_RESIZEVAR(T, P, N)  ((T *) ggc_realloc ((P), (N)))
+ggc_internal_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL)
+{
-#define ggc_alloc_rtvec(NELT)						 \
+return ggc_internal_alloc_stat (c * s PASS_MEM_STAT);
-((rtvec) ggc_alloc_zone (sizeof (struct rtvec_def) + ((NELT) - 1)	 \
+}
-			   * sizeof (rtx), &rtl_zone))
+static inline void *
-#define ggc_alloc_tree(LENGTH) ((tree) ggc_alloc_zone (LENGTH, &tree_zone))
+ggc_internal_cleared_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL)
+{
+return ggc_internal_cleared_alloc_stat (c * s PASS_MEM_STAT);
+}
+#define ggc_internal_cleared_vec_alloc(s, c) \
+(ggc_internal_cleared_vec_alloc_stat ((s), (c) MEM_STAT_INFO))
+static inline void *
+ggc_alloc_atomic_stat (size_t s MEM_STAT_DECL)
+{
+return ggc_internal_alloc_stat (s PASS_MEM_STAT);
+}
+#define ggc_alloc_atomic(S)  (ggc_alloc_atomic_stat ((S) MEM_STAT_INFO))
+#define ggc_alloc_cleared_atomic(S)             \
+(ggc_internal_cleared_alloc_stat ((S) MEM_STAT_INFO))
+extern void * ggc_cleared_alloc_htab_ignore_args (size_t, size_t);
+extern void * ggc_cleared_alloc_ptr_array_two_args (size_t, size_t);
 #define htab_create_ggc(SIZE, HASH, EQ, DEL) \
-htab_create_alloc (SIZE, HASH, EQ, DEL, ggc_calloc, ggc_free)
+htab_create_typed_alloc (SIZE, HASH, EQ, DEL,	\
+			   ggc_cleared_alloc_htab_ignore_args,		\
-#define splay_tree_new_ggc(COMPARE)					 \
+			   ggc_cleared_alloc_ptr_array_two_args,	\
-splay_tree_new_with_allocator (COMPARE, NULL, NULL,			 \
+			   ggc_free)
-&ggc_splay_alloc, &ggc_splay_dont_free, \
-				 NULL)
+#define splay_tree_new_ggc(COMPARE, ALLOC_TREE, ALLOC_NODE)		     \
-extern void *ggc_splay_alloc (int, void *);
+splay_tree_new_typed_alloc (COMPARE, NULL, NULL, &ALLOC_TREE, &ALLOC_NODE, \
+			      &ggc_splay_dont_free, NULL)
+extern void *ggc_splay_alloc (enum gt_types_enum, int, void *);
 extern void ggc_splay_dont_free (void *, void *);
 /* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
 If LENGTH is -1, then CONTENTS is assumed to be a
 null-terminated string and the memory sized accordingly.  */
-extern const char *ggc_alloc_string (const char *contents, int length);
+extern const char *ggc_alloc_string_stat (const char *contents, int length
+MEM_STAT_DECL);
+#define ggc_alloc_string(c, l) ggc_alloc_string_stat (c, l MEM_STAT_INFO)
 /* Make a copy of S, in GC-able memory.  */
-#define ggc_strdup(S) ggc_alloc_string((S), -1)
+#define ggc_strdup(S) ggc_alloc_string_stat ((S), -1 MEM_STAT_INFO)
 /* Invoke the collector.  Garbage collection occurs only when this
 function is called, not during allocations.  */
 extern void ggc_collect	(void);
 extern void ggc_register_root_tab (const struct ggc_root_tab *);
 /* Register an additional cache table.  This can be useful for some
 plugins.  Does nothing if the passed pointer is NULL. */
 extern void ggc_register_cache_tab (const struct ggc_cache_tab *);
-/* Return the number of bytes allocated at the indicated address.  */
-extern size_t ggc_get_size (const void *);
-/* Write out all GCed objects to F.  */
-extern void gt_pch_save (FILE *f);
 /* Read objects previously saved with gt_pch_save from F.  */
 extern void gt_pch_restore (FILE *f);
 /* Statistics.  */
-/* This structure contains the statistics common to all collectors.
-Particular collectors can extend this structure.  */
-typedef struct ggc_statistics
-{
-/* At present, we don't really gather any interesting statistics.  */
-int unused;
-} ggc_statistics;
-/* Used by the various collectors to gather and print statistics that
-do not depend on the collector in use.  */
-extern void ggc_print_common_statistics (FILE *, ggc_statistics *);
 /* Print allocation statistics.  */
 extern void ggc_print_statistics (void);
 extern void stringpool_statistics (void);
 /* Heuristics.  */
-extern int ggc_min_expand_heuristic (void);
-extern int ggc_min_heapsize_heuristic (void);
 extern void init_ggc_heuristics (void);
 /* Zone collection.  */
-#if defined (GGC_ZONE) && !defined (GENERATOR_FILE)
 /* For regular rtl allocations.  */
 extern struct alloc_zone rtl_zone;
 /* For regular tree allocations.  */
 extern struct alloc_zone tree_zone;
 /* For IDENTIFIER_NODE allocations.  */
 extern struct alloc_zone tree_id_zone;
+#define ggc_alloc_rtvec_sized(NELT)                                     \
+(ggc_alloc_zone_vec_rtvec_def (sizeof (rtx),                        \
+sizeof (struct rtvec_def) + ((NELT) - 1), \
+&rtl_zone))
+#if defined (GGC_ZONE) && !defined (GENERATOR_FILE)
 /* Allocate an object into the specified allocation zone.  */
-extern void *ggc_alloc_zone_stat (size_t, struct alloc_zone * MEM_STAT_DECL);
+extern void *ggc_internal_alloc_zone_stat (size_t,
-# define ggc_alloc_zone(s,z) ggc_alloc_zone_stat (s,z MEM_STAT_INFO)
+					  struct alloc_zone * MEM_STAT_DECL);
-# define ggc_alloc_zone_pass_stat(s,z) ggc_alloc_zone_stat (s,z PASS_MEM_STAT)
+extern void *ggc_internal_cleared_alloc_zone_stat (size_t,
+					  struct alloc_zone * MEM_STAT_DECL);
+static inline void *
+ggc_internal_zone_alloc_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL)
+{
+return ggc_internal_alloc_zone_stat (s, z PASS_MEM_STAT);
+}
+static inline void *
+ggc_internal_zone_cleared_alloc_stat (struct alloc_zone * z, size_t s
+MEM_STAT_DECL)
+{
+return ggc_internal_cleared_alloc_zone_stat (s, z PASS_MEM_STAT);
+}
+static inline void *
+ggc_internal_zone_vec_alloc_stat (struct alloc_zone * z, size_t s, size_t n
+MEM_STAT_DECL)
+{
+return ggc_internal_alloc_zone_stat (s * n, z PASS_MEM_STAT);
+}
 #else
-# define ggc_alloc_zone(s, z) ggc_alloc (s)
+static inline void *
-# define ggc_alloc_zone_pass_stat(s, z) ggc_alloc_stat (s PASS_MEM_STAT)
+ggc_internal_zone_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED,
+size_t s MEM_STAT_DECL)
+{
+return ggc_internal_alloc_stat (s PASS_MEM_STAT);
+}
+static inline void *
+ggc_internal_zone_cleared_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED,
+size_t s MEM_STAT_DECL)
+{
+return ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
+}
+static inline void *
+ggc_internal_zone_vec_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED,
+size_t s, size_t n MEM_STAT_DECL)
+{
+return ggc_internal_vec_alloc_stat (s, n PASS_MEM_STAT);
+}
 #endif
+/* Memory statistics passing versions of some allocators.  Too few of them to
+make gengtype produce them, so just define the needed ones here.  */
+static inline struct rtx_def *
+ggc_alloc_zone_rtx_def_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL)
+{
+return (struct rtx_def *) ggc_internal_zone_alloc_stat (z, s PASS_MEM_STAT);
+}
+static inline union tree_node *
+ggc_alloc_zone_tree_node_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL)
+{
+return (union tree_node *) ggc_internal_zone_alloc_stat (z, s PASS_MEM_STAT);
+}
+static inline union tree_node *
+ggc_alloc_zone_cleared_tree_node_stat (struct alloc_zone * z, size_t s
+MEM_STAT_DECL)
+{
+return (union tree_node *)
+ggc_internal_zone_cleared_alloc_stat (z, s PASS_MEM_STAT);
+}
+static inline union gimple_statement_d *
+ggc_alloc_cleared_gimple_statement_d_stat (size_t s MEM_STAT_DECL)
+{
+return (union gimple_statement_d *)
+ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
+}
 #endif

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ggc.h @ 67:f6334be47118