#include "statistics.h"
#include "gtype-desc.h"

Include dependency graph for ggc.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	ggc_root_tab
struct	ggc_cache_tab

Macros
#define	LAST_GGC_ROOT_TAB { NULL, 0, 0, NULL, NULL }
#define	LAST_GGC_CACHE_TAB { NULL, 0, 0, NULL, NULL, NULL }
#define	ggc_test_and_set_mark(EXPR) ((EXPR) != NULL && ((void ) (EXPR)) != (void ) 1 && ! ggc_set_mark (EXPR))
#define	ggc_mark(EXPR)
#define	ggc_internal_alloc(s) ggc_internal_alloc_stat (s MEM_STAT_INFO)
#define	GGC_RESIZEVEC(T, P, N) ((T ) ggc_realloc_stat ((P), (N) sizeof (T) MEM_STAT_INFO))
#define	GGC_RESIZEVAR(T, P, N) ((T *) ggc_realloc_stat ((P), (N) MEM_STAT_INFO))
#define	ggc_internal_cleared_vec_alloc(s, c) (ggc_internal_cleared_vec_alloc_stat ((s), (c) MEM_STAT_INFO))
#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))
#define	htab_create_ggc(SIZE, HASH, EQ, DEL)
#define	splay_tree_new_ggc(COMPARE, ALLOC_TREE, ALLOC_NODE)
#define	ggc_alloc_string(c, l) ggc_alloc_string_stat (c, l MEM_STAT_INFO)
#define	ggc_strdup(S) ggc_alloc_string_stat ((S), -1 MEM_STAT_INFO)
#define	ggc_alloc_rtvec_sized(NELT)

Typedefs
typedef void(*	gt_note_pointers )(void , void , gt_pointer_operator, void *)
typedef void(*	gt_handle_reorder )(void , void , gt_pointer_operator, void *)
typedef void(*	gt_pointer_walker )(void *)

Functions
int	gt_pch_note_object (void , void , gt_note_pointers)
void	gt_pch_note_reorder (void , void , gt_handle_reorder)
int	ggc_set_mark (const void *)
int	ggc_marked_p (const void *)
void	gt_pch_n_S (const void *)
void	gt_ggc_m_S (const void *)
void	init_stringpool (void)
void	init_ggc (void)
void	gt_pch_save (FILE *f)
void *	ggc_internal_alloc_stat (size_t MEM_STAT_DECL) ATTRIBUTE_MALLOC
size_t	ggc_round_alloc_size (size_t requested_size)
void *	ggc_internal_cleared_alloc_stat (size_t MEM_STAT_DECL) ATTRIBUTE_MALLOC
void *	ggc_realloc_stat (void *, size_t MEM_STAT_DECL)
void	ggc_free (void *)
void	dump_ggc_loc_statistics (bool)
static void *	ggc_internal_vec_alloc_stat ()
static void *	ggc_internal_cleared_vec_alloc_stat ()
static void *	ggc_alloc_atomic_stat ()
void *	ggc_cleared_alloc_htab_ignore_args (size_t, size_t) ATTRIBUTE_MALLOC
void *	ggc_cleared_alloc_ptr_array_two_args (size_t, size_t) ATTRIBUTE_MALLOC
void *	ggc_splay_alloc (int, void *) ATTRIBUTE_MALLOC
void	ggc_splay_dont_free (void , void )
const char *	ggc_alloc_string_stat (const char *contents, int length MEM_STAT_DECL)
void	ggc_collect (void)
void	ggc_register_root_tab (const struct ggc_root_tab *)
void	ggc_register_cache_tab (const struct ggc_cache_tab *)
void	gt_pch_restore (FILE *f)
void	ggc_print_statistics (void)
void	stringpool_statistics (void)
void	init_ggc_heuristics (void)
static struct rtx_def *	ggc_alloc_rtx_def_stat ()
static union tree_node *	ggc_alloc_tree_node_stat ()
static union tree_node *	ggc_alloc_cleared_tree_node_stat ()
static struct gimple_statement_base *	ggc_alloc_cleared_gimple_statement_stat ()

Variables
const char	empty_string []
struct ggc_root_tab *const	gt_ggc_rtab []
struct ggc_root_tab *const	gt_ggc_deletable_rtab []
struct ggc_root_tab *const	gt_pch_cache_rtab []
struct ggc_root_tab *const	gt_pch_scalar_rtab []
struct ggc_cache_tab *const	gt_ggc_cache_rtab []
bool	ggc_protect_identifiers

Macro Definition Documentation

#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))

Referenced by add_const_value_attribute().

#define ggc_alloc_rtvec_sized ( NELT )

Value:

ggc_alloc_rtvec_def (sizeof (struct rtvec_def) \

+ ((NELT) - 1) * sizeof (rtx)) \

#define ggc_alloc_string	(	c,
		l
	)	ggc_alloc_string_stat (c, l MEM_STAT_INFO)

#define ggc_internal_alloc ( s ) ggc_internal_alloc_stat (s MEM_STAT_INFO)

#define ggc_internal_cleared_vec_alloc	(	s,
		c
	)	(ggc_internal_cleared_vec_alloc_stat ((s), (c) MEM_STAT_INFO))

#define ggc_mark ( EXPR )

Value:

do {                                          \
    const void *const a__ = (EXPR);             \
    if (a__ != NULL && a__ != (void *) 1)       \
      ggc_set_mark (a__);                       \
  } while (0)

#define GGC_RESIZEVAR	(	T,
		P,
		N
	)	((T *) ggc_realloc_stat ((P), (N) MEM_STAT_INFO))

#define GGC_RESIZEVEC	(	T,
		P,
		N
	)	((T ) ggc_realloc_stat ((P), (N) sizeof (T) MEM_STAT_INFO))

Reallocators.

Referenced by free_temp_slots(), and get_skeleton_type_unit().

#define ggc_strdup ( S ) ggc_alloc_string_stat ((S), -1 MEM_STAT_INFO)

Make a copy of S, in GC-able memory.

Referenced by assemble_asm(), decls_for_scope(), default_named_section_asm_out_destructor(), n_occurrences(), rtl_dump_bb_for_graph(), and solve_graph().

#define ggc_test_and_set_mark ( EXPR ) ((EXPR) != NULL && ((void *) (EXPR)) != (void *) 1 && ! ggc_set_mark (EXPR))

If EXPR is not NULL and previously unmarked, mark it and evaluate to true. Otherwise evaluate to false.

#define htab_create_ggc	(	SIZE,
		HASH,
		EQ,
		DEL
	)

Value:

htab_create_typed_alloc (SIZE, HASH, EQ, DEL, \
                           ggc_cleared_alloc_htab_ignore_args,          \
                           ggc_cleared_alloc_ptr_array_two_args,        \
                           ggc_free)

Referenced by check_aligned_type(), decl_for_type_lookup(), expand_dummy_function_end(), merge_weak(), and reset_chrecs_counters().

#define LAST_GGC_CACHE_TAB { NULL, 0, 0, NULL, NULL, NULL }

#define LAST_GGC_ROOT_TAB { NULL, 0, 0, NULL, NULL }

#define splay_tree_new_ggc	(	COMPARE,
		ALLOC_TREE,
		ALLOC_NODE
	)

Value:

splay_tree_new_typed_alloc (COMPARE, NULL, NULL, &ALLOC_TREE, &ALLOC_NODE, \

&ggc_splay_dont_free, NULL)

Referenced by splay_tree_compare_strings().

Typedef Documentation

typedef void(* gt_handle_reorder)(void *, void *, gt_pointer_operator, void *)

One of these is called before objects are re-ordered in memory. The first parameter is the original object, the second is the subobject that has had its pointers reordered, the third parameter can compute the new values of a pointer when given the cookie in the fourth parameter.

typedef void(* gt_note_pointers)(void *, void *, gt_pointer_operator, void *)

Internal functions and data structures used by the GTY machinery, including the generated gt*.[hc] files. One of these applies its third parameter (with cookie in the fourth parameter) to each pointer in the object pointed to by the first parameter, using the second parameter.

typedef void(* gt_pointer_walker)(void *)

Mark the object in the first parameter and anything it points to.

Function Documentation

void dump_ggc_loc_statistics ( bool )

static void* ggc_alloc_atomic_stat ( )

inlinestatic

static struct gimple_statement_base* ggc_alloc_cleared_gimple_statement_stat ( )

staticread

static union tree_node* ggc_alloc_cleared_tree_node_stat ( )

staticwrite

static struct rtx_def* ggc_alloc_rtx_def_stat ( )

staticread

Memory statistics passing versions of some allocators. Too few of them to make gengtype produce them, so just define the needed ones here.

const char* ggc_alloc_string_stat	(	const char *	contents,
		int length	MEM_STAT_DECL
	)

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.

static union tree_node* ggc_alloc_tree_node_stat ( )

staticwrite

void* ggc_cleared_alloc_htab_ignore_args	(	size_t	,
		size_t
	)

void* ggc_cleared_alloc_ptr_array_two_args	(	size_t	,
		size_t
	)

void ggc_collect ( void )

Invoke the collector. Garbage collection occurs only when this function is called, not during allocations.

Top level mark-and-sweep routine.

 Avoid frequent unnecessary work by skipping collection if the
 total allocations haven't expanded much since the last
 collection.

 Zero the total allocated bytes.  This will be recalculated in the
 sweep phase.

 Release the pages we freed the last time we collected, but didn't
 reuse in the interim.

 Indicate that we've seen collections at this context depth.

References ggc_pch_data::base, ggc_pch_data::d, PAGE_ALIGN, and ggc_pch_ondisk::totals.

Referenced by ggc_splay_alloc(), and gcc::pass_manager::pass_manager().

void ggc_free ( void * )

Free a block. To be used when known for certain it's not reachable.

void* ggc_internal_alloc_stat ( size_t MEM_STAT_DECL )

Allocation. The internal primitive.

void* ggc_internal_cleared_alloc_stat ( size_t MEM_STAT_DECL )

Allocates cleared memory.

static void* ggc_internal_cleared_vec_alloc_stat ( )

inlinestatic

Referenced by gimple_build_debug_bind_stat().

static void* ggc_internal_vec_alloc_stat ( )

inlinestatic

int ggc_marked_p ( const void * )

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.

void ggc_print_statistics ( void )

Statistics. Print allocation statistics.

 Clear the statistics.

 Make sure collection will really occur.

 Collect and print the statistics common across collectors.

 Release free pages so that we will not count the bytes allocated
 there as part of the total allocated memory.

 Collect some information about the various sizes of
 allocation.

     Skip empty entries.

     Figure out the total number of bytes allocated for objects of
     this size, and how many of them are actually in use.  Also figure
     out how much memory the page table is using.

References fatal_error().

void* ggc_realloc_stat	(	void *	,
		size_t	MEM_STAT_DECL
	)

Resize a block.

void ggc_register_cache_tab ( const struct ggc_cache_tab * )

Register an additional cache table. This can be useful for some plugins. Does nothing if the passed pointer is NULL.

void ggc_register_root_tab ( const struct ggc_root_tab * )

Register an additional root table. This can be useful for some plugins. Does nothing if the passed pointer is NULL.

size_t ggc_round_alloc_size ( size_t requested_size )

int ggc_set_mark ( const void * )

Actually set the mark on a particular region of memory, but don't follow pointers. This function is called by ggc_mark_*. It returns zero if the object was not previously marked; nonzero if the object was already marked, or if, for any other reason, pointers in this data structure should not be traversed.

void* ggc_splay_alloc	(	int	,
		void *
	)

void ggc_splay_dont_free	(	void *	,
		void *
	)

void gt_ggc_m_S ( const void * )

void gt_pch_n_S ( const void * )

PCH and GGC handling for strings, mostly trivial.

Referenced by gt_pch_p_S().

int gt_pch_note_object	(	void *	obj,
		void *	note_ptr_cookie,
		gt_note_pointers	note_ptr_fn
	)

Used by the gt_pch_n_* routines. Register an object in the hash table.

Register an object in the hash table.

References hash_table< Descriptor, Allocator >::find_with_hash(), gcc_assert, ptr_data::note_ptr_cookie, NULL, POINTER_HASH, and ptr_data::reorder_fn.

Referenced by ggc_purge_stringpool().

void gt_pch_note_reorder	(	void *	obj,
		void *	note_ptr_cookie,
		gt_handle_reorder	reorder_fn
	)

Used by the gt_pch_n_* routines. Register that an object has a reorder function.

Register an object in the hash table.

void gt_pch_restore ( FILE * f )

Read objects previously saved with gt_pch_save from F.

void gt_pch_save ( FILE * f )

Write out all GCed objects to F.

void init_ggc ( void )

Initialize the garbage collector.

Initialize the ggc-mmap allocator.

 Initialize the object size table.

     If S is not a multiple of the MAX_ALIGNMENT, then round it up
     so that we're sure of getting aligned memory.

 Initialize the objects-per-page and inverse tables.

 Reset the size_lookup array to put appropriately sized objects in
 the special orders.  All objects bigger than the previous power
 of two, but no greater than the special size, should go in the
 new order.

void init_ggc_heuristics ( void )

Heuristics.

void init_stringpool ( void )

End of GTY machinery API. Initialize the string pool.

Initialize the string pool.

Create with 16K (2^14) entries.

void stringpool_statistics ( void )

Report some basic statistics about the string pool.

References ggc_marked_p(), and HT_IDENT_TO_GCC_IDENT.

Variable Documentation

const char empty_string[]

Garbage collection for the GNU compiler.

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 Software Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. 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.

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 Software Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/. String text, identifier text and identifier node allocator. Identifiers are uniquely stored in a hash table.

We use cpplib's hash table implementation. libiberty's hashtab.c is not used because it requires 100% average space overhead per string, which is unacceptable. Also, this algorithm is faster. The "" allocated string.

Referenced by maybe_emit_atomic_exchange().

bool ggc_protect_identifiers

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.

When true, protect the contents of the identifier hash table.

struct ggc_cache_tab* const gt_ggc_cache_rtab[]

Pointers to arrays of ggc_cache_tab, terminated by NULL.

struct ggc_root_tab* const gt_ggc_deletable_rtab[]

Referenced by ggc_mark_root_tab().

struct ggc_root_tab* const gt_ggc_rtab[]

Pointers to arrays of ggc_root_tab, terminated by NULL.

Referenced by ggc_mark_root_tab().

struct ggc_root_tab* const gt_pch_cache_rtab[]

struct ggc_root_tab* const gt_pch_scalar_rtab[]

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation